Merge branch 'main' into ignite-26722

Author: tkalkirill

docs/_docs/administrators-guide/storage/data-partitions.adoc

@@ -20,7 +20,7 @@ Data partitioning is a method of subdividing large sets of data into smaller chu
 
 When the table is created, it is always assigned to a link:administrators-guide/storage/distribution-zones[distribution zone]. Based on the distribution zone parameters, the table is separated into `PARTITIONS` parts, called *partitions*, stored `REPLICAS` times across the cluster. Each partition is identified by a number from a limited set (0 to 24 for the default zone). Each individual copy of a partition is called a *replica*, and is stored on separate nodes, if possible. Partitions with the same number for all tables in the zone are always stored on the same node.
 
-Apache Ignite uses the *Fair* partition distribution algorithm. It means that it stores information on partition distribution and uses this information for assigning new partitions. This information is preserved in cluster metastorage, and is recalculated only when necessary.
+Apache Ignite uses the *Rendezvous* partition distribution algorithm. It means that it stores information on partition distribution and uses this information for assigning new partitions. This information is preserved in cluster metastorage, and is recalculated only when necessary.
 
 Once partitions and all replicas are created, they are distributed across the available cluster nodes that are included in the distribution zone following the `DATA_NODES_FILTER` parameter and according to the *partition distribution algorithm*. Thus, each key is mapped to a list of nodes owning the corresponding partition and is stored on those nodes. When data is added, it is distributed evenly between partitions.
 
@@ -120,4 +120,12 @@ NOTE: Reset is likely to result in <<Partition Rebalance>>, which may take a lon
 
 == Partition Rebalance
 
-When the link:administrators-guide/storage/distribution-zones#cluster-scaling[cluster size changes], Apache Ignite waits for the timeout specified in the `AUTO SCALE UP` or `AUTO SCALE DOWN` distribution zone properties, and then redistributes partitions according to the partition distribution algorithm and transfers data to make it up-to-date with the replication group. This process is called *data rebalance*.
+When the link:administrators-guide/storage/distribution-zones#cluster-scaling[cluster size changes], Apache Ignite waits for the timeout specified in the `AUTO SCALE UP` or `AUTO SCALE DOWN` distribution zone properties, and then redistributes partitions according to the partition distribution algorithm and transfers data to make it up-to-date with the replication group. This process is called *data rebalance*.
+
+== Old Replication Mode (Table-based Replication)
+
+Ignite 3.1 introduced Zone-based Replication and uses it by default. Ignite 3.0 used Table-based Replication, so clusters created on 3.0 and upgraded to 3.1 will still use Table-based Replication.
+
+Table-based Replication is deprecated in Ignite 3.1, and is planned to be removed in Ignite 3.2. It is recommended to migrate your clusters to Zone-based Replication. Currently, there is no automatic migration tool, so you will need to create a new cluster with Zone-based Replication and move your data there.
+
+Current replication mode for your cluster is specified in the startup logs. Look for the following line: 'Zone based replication: true' or 'Zone based replication: false'. If it is false, you are using Table-based Replication.

modules/core/src/main/java/org/apache/ignite/internal/lang/IgniteSystemProperties.java

@@ -44,7 +44,12 @@ public final class IgniteSystemProperties {
     public static final String IGNITE_SKIP_STORAGE_UPDATE_IN_BENCHMARK = "IGNITE_SKIP_STORAGE_UPDATE_IN_BENCHMARK";
 
     // TODO https://issues.apache.org/jira/browse/IGNITE-22522 Remove this feature flag.
-    /** Enables zone based replication (aka colocation) feature. */
+    /**
+     * Enables zone based replication (aka colocation) feature.
+     *
+     * @deprecated Non-colocation mode is planned to be removed in version 3.2.
+     */
+    @Deprecated(since = "3.1", forRemoval = true)
     public static final String COLOCATION_FEATURE_FLAG = "IGNITE_ZONE_BASED_REPLICATION";
 
     /**
@@ -60,8 +65,10 @@ private IgniteSystemProperties() {
      *
      * <p>Do not use in production code (apart from {@link NodeProperties} implementations). If a component needs colocation status,
      * it should get one from {@link NodeProperties}.
+     *
+     * @deprecated Non-colocation mode is planned to be removed in version 3.2.
      */
-    @Deprecated
+    @Deprecated(since = "3.1", forRemoval = true)
     public static boolean colocationEnabled() {
         return getBoolean(COLOCATION_FEATURE_FLAG, true);
     }

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/GroupIndexMeta.java

@@ -63,13 +63,13 @@ IndexFileMeta indexMeta(long logIndex) {
         return fileMetas.find(logIndex);
     }
 
-    long firstLogIndex() {
-        return fileMetas.get(0).firstLogIndex();
+    long firstLogIndexInclusive() {
+        return fileMetas.get(0).firstLogIndexInclusive();
     }
 
-    long lastLogIndex() {
+    long lastLogIndexExclusive() {
         IndexFileMetaArray fileMetas = this.fileMetas;
 
-        return fileMetas.get(fileMetas.size() - 1).lastLogIndex();
+        return fileMetas.get(fileMetas.size() - 1).lastLogIndexExclusive();
     }
 }

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/IndexFileManager.java

@@ -163,8 +163,8 @@ SegmentFilePointer getSegmentFilePointer(long groupId, long logIndex) throws IOE
 
         Path indexFile = baseDir.resolve(indexFileName(indexFileMeta.indexFileOrdinal(), 0));
 
-        // Index file payload is a 0-based array, which indices correspond to the [fileMeta.firstLogIndex, fileMeta.lastLogIndex] range.
-        long payloadArrayIndex = logIndex - indexFileMeta.firstLogIndex();
+        // Index file payload is a 0-based array, which indices correspond to the [fileMeta.firstLogIndex, fileMeta.lastLogIndex) range.
+        long payloadArrayIndex = logIndex - indexFileMeta.firstLogIndexInclusive();
 
         assert payloadArrayIndex >= 0 : payloadArrayIndex;
 
@@ -192,19 +192,19 @@ SegmentFilePointer getSegmentFilePointer(long groupId, long logIndex) throws IOE
     /**
      * Returns the lowest log index for the given group across all index files or {@code -1} if no such index exists.
      */
-    long firstLogIndex(long groupId) {
+    long firstLogIndexInclusive(long groupId) {
         GroupIndexMeta groupIndexMeta = groupIndexMetas.get(groupId);
 
-        return groupIndexMeta == null ? -1 : groupIndexMeta.firstLogIndex();
+        return groupIndexMeta == null ? -1 : groupIndexMeta.firstLogIndexInclusive();
     }
 
     /**
-     * Returns the highest log index for the given group across all index files or {@code -1} if no such index exists.
+     * Returns the highest possible log index for the given group across all index files or {@code -1} if no such index exists.
      */
-    long lastLogIndex(long groupId) {
+    long lastLogIndexExclusive(long groupId) {
         GroupIndexMeta groupIndexMeta = groupIndexMetas.get(groupId);
 
-        return groupIndexMeta == null ? -1 : groupIndexMeta.lastLogIndex();
+        return groupIndexMeta == null ? -1 : groupIndexMeta.lastLogIndexExclusive();
     }
 
     private byte[] serializeHeaderAndFillMetadata(ReadModeIndexMemTable indexMemTable) {
@@ -230,20 +230,20 @@ private byte[] serializeHeaderAndFillMetadata(ReadModeIndexMemTable indexMemTabl
 
             SegmentInfo segmentInfo = entry.getValue();
 
-            long firstLogIndex = segmentInfo.firstLogIndex();
+            long firstLogIndexInclusive = segmentInfo.firstLogIndexInclusive();
 
-            long lastLogIndex = segmentInfo.lastLogIndex();
+            long lastLogIndexExclusive = segmentInfo.lastLogIndexExclusive();
 
-            var indexFileMeta = new IndexFileMeta(firstLogIndex, lastLogIndex, payloadOffset, curFileOrdinal);
+            var indexFileMeta = new IndexFileMeta(firstLogIndexInclusive, lastLogIndexExclusive, payloadOffset, curFileOrdinal);
 
             putIndexFileMeta(groupId, indexFileMeta);
 
             headerBuffer
                     .putLong(groupId)
                     .putInt(0) // Flags.
                     .putInt(payloadOffset)
-                    .putLong(firstLogIndex)
-                    .putLong(lastLogIndex);
+                    .putLong(firstLogIndexInclusive)
+                    .putLong(lastLogIndexExclusive);
 
             payloadOffset += payloadSize(segmentInfo);
         }

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/IndexFileMeta.java

@@ -25,33 +25,33 @@
  * @see IndexFileManager
  */
 class IndexFileMeta {
-    private final long firstLogIndex;
+    private final long firstLogIndexInclusive;
 
-    private final long lastLogIndex;
+    private final long lastLogIndexExclusive;
 
     private final int indexFilePayloadOffset;
 
     private final int indexFileOrdinal;
 
-    IndexFileMeta(long firstLogIndex, long lastLogIndex, int indexFilePayloadOffset, int indexFileOrdinal) {
-        this.firstLogIndex = firstLogIndex;
-        this.lastLogIndex = lastLogIndex;
+    IndexFileMeta(long firstLogIndexInclusive, long lastLogIndexExclusive, int indexFilePayloadOffset, int indexFileOrdinal) {
+        this.firstLogIndexInclusive = firstLogIndexInclusive;
+        this.lastLogIndexExclusive = lastLogIndexExclusive;
         this.indexFilePayloadOffset = indexFilePayloadOffset;
         this.indexFileOrdinal = indexFileOrdinal;
     }
 
     /**
      * Returns the inclusive lower bound of log indices stored in the index file for the Raft Group.
      */
-    long firstLogIndex() {
-        return firstLogIndex;
+    long firstLogIndexInclusive() {
+        return firstLogIndexInclusive;
     }
 
     /**
-     * Returns the inclusive upper bound of log indices stored in the index file for the Raft Group.
+     * Returns the exclusive upper bound of log indices stored in the index file for the Raft Group.
      */
-    long lastLogIndex() {
-        return lastLogIndex;
+    long lastLogIndexExclusive() {
+        return lastLogIndexExclusive;
     }
 
     /**
@@ -75,15 +75,15 @@ public boolean equals(Object o) {
         }
 
         IndexFileMeta that = (IndexFileMeta) o;
-        return firstLogIndex == that.firstLogIndex && lastLogIndex == that.lastLogIndex
+        return firstLogIndexInclusive == that.firstLogIndexInclusive && lastLogIndexExclusive == that.lastLogIndexExclusive
                 && indexFilePayloadOffset == that.indexFilePayloadOffset
                 && indexFileOrdinal == that.indexFileOrdinal;
     }
 
     @Override
     public int hashCode() {
-        int result = Long.hashCode(firstLogIndex);
-        result = 31 * result + Long.hashCode(lastLogIndex);
+        int result = Long.hashCode(firstLogIndexInclusive);
+        result = 31 * result + Long.hashCode(lastLogIndexExclusive);
         result = 31 * result + indexFilePayloadOffset;
         result = 31 * result + indexFileOrdinal;
         return result;

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/IndexFileMetaArray.java

@@ -45,10 +45,10 @@ private IndexFileMetaArray(IndexFileMeta[] array, int size) {
     }
 
     IndexFileMetaArray add(IndexFileMeta indexFileMeta) {
-        assert indexFileMeta.firstLogIndex() == array[size - 1].lastLogIndex() + 1 :
+        assert indexFileMeta.firstLogIndexInclusive() == array[size - 1].lastLogIndexExclusive() :
                 String.format("Index File Metas must be contiguous. Expected log index: %d, actual log index: %d",
-                        array[size - 1].lastLogIndex() + 1,
-                        indexFileMeta.firstLogIndex()
+                        array[size - 1].lastLogIndexExclusive(),
+                        indexFileMeta.firstLogIndexInclusive()
                 );
 
         // The array can be shared between multiple instances, but since it always grows and we read at most "size" elements,
@@ -72,6 +72,14 @@ int size() {
         return size;
     }
 
+    long firstLogIndexInclusive() {
+        return array[0].firstLogIndexInclusive();
+    }
+
+    long lastLogIndexExclusive() {
+        return array[size - 1].lastLogIndexExclusive();
+    }
+
     /**
      * Returns the {@link IndexFileMeta} containing the given Raft log index or {@code null} if no such meta exists.
      */
@@ -85,9 +93,9 @@ IndexFileMeta find(long logIndex) {
 
             IndexFileMeta midValue = array[middleArrayIndex];
 
-            if (logIndex < midValue.firstLogIndex()) {
+            if (logIndex < midValue.firstLogIndexInclusive()) {
                 highArrayIndex = middleArrayIndex - 1;
-            } else if (logIndex > midValue.lastLogIndex()) {
+            } else if (logIndex >= midValue.lastLogIndexExclusive()) {
                 lowArrayIndex = middleArrayIndex + 1;
             } else {
                 return midValue;

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/RaftLogCheckpointer.java

@@ -129,7 +129,7 @@ void onRollover(SegmentFile segmentFile, ReadModeIndexMemTable indexMemTable) {
     /**
      * Returns the lowest log index for the given group present in the checkpoint queue or {@code -1} if no such index exists.
      */
-    long firstLogIndex(long groupId) {
+    long firstLogIndexInclusive(long groupId) {
         Iterator<Entry> it = queue.tailIterator();
 
         long firstIndex = -1;
@@ -138,24 +138,24 @@ long firstLogIndex(long groupId) {
             SegmentInfo segmentInfo = it.next().memTable().segmentInfo(groupId);
 
             if (segmentInfo != null) {
-                firstIndex = segmentInfo.firstLogIndex();
+                firstIndex = segmentInfo.firstLogIndexInclusive();
             }
         }
 
         return firstIndex;
     }
 
     /**
-     * Returns the highest log index for the given group present in the checkpoint queue or {@code -1} if no such index exists.
+     * Returns the highest possible log index for the given group present in the checkpoint queue or {@code -1} if no such index exists.
      */
-    long lastLogIndex(long groupId) {
+    long lastLogIndexExclusive(long groupId) {
         Iterator<Entry> it = queue.tailIterator();
 
         while (it.hasNext()) {
             SegmentInfo segmentInfo = it.next().memTable().segmentInfo(groupId);
 
             if (segmentInfo != null) {
-                return segmentInfo.lastLogIndex();
+                return segmentInfo.lastLogIndexExclusive();
             }
         }
 

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/SegmentFileManager.java

@@ -219,12 +219,12 @@ void appendEntry(long groupId, LogEntry entry, LogEntryEncoder encoder) throws I
     /**
      * Returns the lowest log index for the given group present in the storage or {@code -1} if no such index exists.
      */
-    long firstLogIndex(long groupId) {
+    long firstLogIndexInclusive(long groupId) {
         long logIndexFromMemtable = firstLogIndexFromMemtable(groupId);
 
-        long logIndexFromCheckpointQueue = checkpointer.firstLogIndex(groupId);
+        long logIndexFromCheckpointQueue = checkpointer.firstLogIndexInclusive(groupId);
 
-        long logIndexFromIndexFiles = indexFileManager.firstLogIndex(groupId);
+        long logIndexFromIndexFiles = indexFileManager.firstLogIndexInclusive(groupId);
 
         if (logIndexFromIndexFiles >= 0) {
             return logIndexFromIndexFiles;
@@ -242,34 +242,36 @@ private long firstLogIndexFromMemtable(long groupId) {
 
         SegmentInfo segmentInfo = currentSegmentFile.memtable().segmentInfo(groupId);
 
-        return segmentInfo == null ? -1 : segmentInfo.firstLogIndex();
+        return segmentInfo == null ? -1 : segmentInfo.firstLogIndexInclusive();
     }
 
     /**
-     * Returns the highest log index for the given group present in the storage or {@code -1} if no such index exists.
+     * Returns the highest possible exclusive log index for the given group or {@code -1} if no such index exists.
+     *
+     * <p>The highest log index currently present in the storage can be computed as {@code lastLogIndexExclusive - 1}.
      */
-    long lastLogIndex(long groupId) {
+    long lastLogIndexExclusive(long groupId) {
         long logIndexFromMemtable = lastLogIndexFromMemtable(groupId);
 
         if (logIndexFromMemtable >= 0) {
             return logIndexFromMemtable;
         }
 
-        long logIndexFromCheckpointQueue = checkpointer.lastLogIndex(groupId);
+        long logIndexFromCheckpointQueue = checkpointer.lastLogIndexExclusive(groupId);
 
         if (logIndexFromCheckpointQueue >= 0) {
             return logIndexFromCheckpointQueue;
         }
 
-        return indexFileManager.lastLogIndex(groupId);
+        return indexFileManager.lastLogIndexExclusive(groupId);
     }
 
     private long lastLogIndexFromMemtable(long groupId) {
         SegmentFileWithMemtable currentSegmentFile = this.currentSegmentFile.get();
 
         SegmentInfo segmentInfo = currentSegmentFile.memtable().segmentInfo(groupId);
 
-        return segmentInfo == null ? -1 : segmentInfo.lastLogIndex();
+        return segmentInfo == null ? -1 : segmentInfo.lastLogIndexExclusive();
     }
 
     /**

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/SegmentInfo.java

@@ -133,15 +133,15 @@ int getOffset(long logIndex) {
     /**
      * Returns the inclusive lower bound of log indices stored in this memtable.
      */
-    long firstLogIndex() {
+    long firstLogIndexInclusive() {
         return logIndexBase;
     }
 
     /**
      * Returns the inclusive upper bound of log indices stored in this memtable.
      */
-    long lastLogIndex() {
-        return logIndexBase + segmentFileOffsets.size() - 1;
+    long lastLogIndexExclusive() {
+        return logIndexBase + segmentFileOffsets.size();
     }
 
     /**

modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/segstore/SegstoreLogStorage.java

@@ -83,16 +83,18 @@ public int appendEntries(List<LogEntry> entries) {
 
     @Override
     public long getFirstLogIndex() {
-        long firstLogIndex = segmentFileManager.firstLogIndex(groupId);
+        long firstLogIndex = segmentFileManager.firstLogIndexInclusive(groupId);
 
+        // JRaft requires to return 1 as the first log index if there are no entries.
         return firstLogIndex >= 0 ? firstLogIndex : 1;
     }
 
     @Override
     public long getLastLogIndex() {
-        long lastLogIndex = segmentFileManager.lastLogIndex(groupId);
+        long lastLogIndex = segmentFileManager.lastLogIndexExclusive(groupId);
 
-        return lastLogIndex >= 0 ? lastLogIndex : 0;
+        // JRaft requires to return 0 as the last log index if there are no entries.
+        return Math.max(lastLogIndex - 1, 0);
     }
 
     @Override