This is an automated email from the ASF dual-hosted git repository.

xbli pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git


The following commit(s) were added to refs/heads/master by this push:
     new 5b18145a72 assign segments for upsert table with respect to ideal 
state (#11628)
5b18145a72 is described below

commit 5b18145a721fe23f5e55e2463336db58169bd90e
Author: Xiaobing <[email protected]>
AuthorDate: Fri Sep 22 19:50:28 2023 -0700

    assign segments for upsert table with respect to ideal state (#11628)
    
    * assign segments for upsert table with respect to ideal state
---
 .../pinot/common/metrics/ControllerMeter.java      |   1 +
 .../pinot/controller/BaseControllerStarter.java    |   2 +-
 .../helix/core/PinotHelixResourceManager.java      |  14 +-
 .../assignment/segment/BaseSegmentAssignment.java  |   6 +-
 .../segment/RealtimeSegmentAssignment.java         |   9 +-
 .../core/assignment/segment/SegmentAssignment.java |   3 +-
 .../segment/SegmentAssignmentFactory.java          |  15 +-
 .../segment/StrictRealtimeSegmentAssignment.java   | 137 ++++++++++
 .../realtime/PinotLLCRealtimeSegmentManager.java   |   9 +-
 .../helix/core/rebalance/TableRebalancer.java      |  11 +-
 ...NonReplicaGroupTieredSegmentAssignmentTest.java |   2 +-
 ...altimeNonReplicaGroupSegmentAssignmentTest.java |   4 +-
 ...NonReplicaGroupTieredSegmentAssignmentTest.java |   2 +-
 .../RealtimeReplicaGroupSegmentAssignmentTest.java |   2 +-
 .../StrictRealtimeSegmentAssignmentTest.java       | 287 +++++++++++++++++++++
 .../AllServersSegmentAssignmentStrategyTest.java   |   2 +-
 .../BalancedNumSegmentAssignmentStrategyTest.java  |   2 +-
 .../ReplicaGroupSegmentAssignmentStrategyTest.java |   6 +-
 .../pinot/tools/perf/PerfBenchmarkDriver.java      |   2 +-
 19 files changed, 485 insertions(+), 31 deletions(-)

diff --git 
a/pinot-common/src/main/java/org/apache/pinot/common/metrics/ControllerMeter.java
 
b/pinot-common/src/main/java/org/apache/pinot/common/metrics/ControllerMeter.java
index a3e6da0086..ac933acf6a 100644
--- 
a/pinot-common/src/main/java/org/apache/pinot/common/metrics/ControllerMeter.java
+++ 
b/pinot-common/src/main/java/org/apache/pinot/common/metrics/ControllerMeter.java
@@ -39,6 +39,7 @@ public enum ControllerMeter implements AbstractMetrics.Meter {
   CONTROLLER_TABLE_TENANT_CREATE_ERROR("TableTenantCreateError", true),
   CONTROLLER_TABLE_TENANT_DELETE_ERROR("TableTenantDeleteError", true),
   CONTROLLER_REALTIME_TABLE_SEGMENT_ASSIGNMENT_ERROR("errors", true),
+  CONTROLLER_REALTIME_TABLE_SEGMENT_ASSIGNMENT_MISMATCH("mismatch", true),
   
CONTROLLER_LEADERSHIP_CHANGE_WITHOUT_CALLBACK("leadershipChangeWithoutCallback",
 true),
   LLC_STATE_MACHINE_ABORTS("aborts", false),
   LLC_ZOOKEEPER_FETCH_FAILURES("failures", false),
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/BaseControllerStarter.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/BaseControllerStarter.java
index e7f02b57df..240e8d662b 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/BaseControllerStarter.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/BaseControllerStarter.java
@@ -421,7 +421,7 @@ public abstract class BaseControllerStarter implements 
ServiceStartable {
     _leadControllerManager.start();
 
     LOGGER.info("Starting Pinot Helix resource manager and connecting to 
Zookeeper");
-    _helixResourceManager.start(_helixParticipantManager);
+    _helixResourceManager.start(_helixParticipantManager, _controllerMetrics);
 
     // Initialize segment lifecycle event listeners
     
PinotSegmentLifecycleEventListenerManager.getInstance().init(_helixParticipantManager);
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/PinotHelixResourceManager.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/PinotHelixResourceManager.java
index ae5b271238..fe54d3cb7b 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/PinotHelixResourceManager.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/PinotHelixResourceManager.java
@@ -111,6 +111,7 @@ import org.apache.pinot.common.metadata.ZKMetadataProvider;
 import org.apache.pinot.common.metadata.controllerjob.ControllerJobType;
 import org.apache.pinot.common.metadata.instance.InstanceZKMetadata;
 import org.apache.pinot.common.metadata.segment.SegmentZKMetadata;
+import org.apache.pinot.common.metrics.ControllerMetrics;
 import org.apache.pinot.common.minion.MinionTaskMetadataUtils;
 import org.apache.pinot.common.restlet.resources.EndReplaceSegmentsRequest;
 import org.apache.pinot.common.restlet.resources.RevertReplaceSegmentsRequest;
@@ -225,6 +226,7 @@ public class PinotHelixResourceManager {
   private ZkHelixPropertyStore<ZNRecord> _propertyStore;
   private HelixDataAccessor _helixDataAccessor;
   private Builder _keyBuilder;
+  private ControllerMetrics _controllerMetrics;
   private SegmentDeletionManager _segmentDeletionManager;
   private PinotLLCRealtimeSegmentManager _pinotLLCRealtimeSegmentManager;
   private TableCache _tableCache;
@@ -274,12 +276,13 @@ public class PinotHelixResourceManager {
    * TODO:For the <a 
href="https://github.com/apache/pinot/pull/10451";>backwards incompatible 
change</a>, this is a
    * reminder to clean up old Zk nodes when the controller starts up.
    */
-  public synchronized void start(HelixManager helixZkManager) {
+  public synchronized void start(HelixManager helixZkManager, @Nullable 
ControllerMetrics controllerMetrics) {
     _helixZkManager = helixZkManager;
     _helixAdmin = _helixZkManager.getClusterManagmentTool();
     _propertyStore = _helixZkManager.getHelixPropertyStore();
     _helixDataAccessor = _helixZkManager.getHelixDataAccessor();
     _keyBuilder = _helixDataAccessor.keyBuilder();
+    _controllerMetrics = controllerMetrics;
     _segmentDeletionManager = new SegmentDeletionManager(_dataDir, 
_helixAdmin, _helixClusterName, _propertyStore,
         _deletedSegmentsRetentionInDays);
     ZKMetadataProvider.setClusterTenantIsolationEnabled(_propertyStore, 
_isSingleTenantCluster);
@@ -2142,7 +2145,8 @@ public class PinotHelixResourceManager {
         }
       }
 
-      SegmentAssignment segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixZkManager, tableConfig);
+      SegmentAssignment segmentAssignment =
+          SegmentAssignmentFactory.getSegmentAssignment(_helixZkManager, 
tableConfig, _controllerMetrics);
       synchronized (getTableUpdaterLock(tableNameWithType)) {
         Map<InstancePartitionsType, InstancePartitions> 
finalInstancePartitionsMap = instancePartitionsMap;
         HelixHelper.updateIdealState(_helixZkManager, tableNameWithType, 
idealState -> {
@@ -2153,8 +2157,7 @@ public class PinotHelixResourceManager {
                 tableNameWithType);
           } else {
             List<String> assignedInstances =
-                segmentAssignment.assignSegment(segmentName, currentAssignment,
-                    finalInstancePartitionsMap);
+                segmentAssignment.assignSegment(segmentName, 
currentAssignment, finalInstancePartitionsMap);
             LOGGER.info("Assigning segment: {} to instances: {} for table: 
{}", segmentName, assignedInstances,
                 tableNameWithType);
             currentAssignment.put(segmentName,
@@ -3107,7 +3110,8 @@ public class PinotHelixResourceManager {
     if (trackRebalanceProgress) {
       zkBasedTableRebalanceObserver = new 
ZkBasedTableRebalanceObserver(tableNameWithType, rebalanceJobId, this);
     }
-    TableRebalancer tableRebalancer = new TableRebalancer(_helixZkManager, 
zkBasedTableRebalanceObserver);
+    TableRebalancer tableRebalancer =
+        new TableRebalancer(_helixZkManager, zkBasedTableRebalanceObserver, 
_controllerMetrics);
     return tableRebalancer.rebalance(tableConfig, rebalanceConfig);
   }
 
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/BaseSegmentAssignment.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/BaseSegmentAssignment.java
index b89fd497be..e82b38d0db 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/BaseSegmentAssignment.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/BaseSegmentAssignment.java
@@ -27,6 +27,7 @@ import javax.annotation.Nullable;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.helix.HelixManager;
 import org.apache.pinot.common.assignment.InstancePartitions;
+import org.apache.pinot.common.metrics.ControllerMetrics;
 import org.apache.pinot.common.tier.Tier;
 import org.apache.pinot.common.utils.config.TableConfigUtils;
 import 
org.apache.pinot.controller.helix.core.assignment.segment.strategy.SegmentAssignmentStrategy;
@@ -69,15 +70,16 @@ public abstract class BaseSegmentAssignment implements 
SegmentAssignment {
   protected int _replication;
   protected String _partitionColumn;
   protected TableConfig _tableConfig;
+  protected ControllerMetrics _controllerMetrics;
 
   @Override
-  public void init(HelixManager helixManager, TableConfig tableConfig) {
+  public void init(HelixManager helixManager, TableConfig tableConfig, 
@Nullable ControllerMetrics controllerMetrics) {
     _helixManager = helixManager;
     _tableNameWithType = tableConfig.getTableName();
     _tableConfig = tableConfig;
     _replication = tableConfig.getReplication();
     _partitionColumn = TableConfigUtils.getPartitionColumn(_tableConfig);
-
+    _controllerMetrics = controllerMetrics;
     if (_partitionColumn == null) {
       _logger.info("Initialized with replication: {} without partition column 
for table: {} ", _replication,
           _tableNameWithType);
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeSegmentAssignment.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeSegmentAssignment.java
index c3e4f4c239..db8b375a4c 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeSegmentAssignment.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeSegmentAssignment.java
@@ -106,8 +106,13 @@ public class RealtimeSegmentAssignment extends 
BaseSegmentAssignment {
    * Helper method to assign instances for CONSUMING segment based on the 
segment partition id and instance partitions.
    */
   private List<String> assignConsumingSegment(String segmentName, 
InstancePartitions instancePartitions) {
-    int segmentPartitionId = SegmentAssignmentUtils
-        .getRealtimeSegmentPartitionId(segmentName, _tableNameWithType, 
_helixManager, _partitionColumn);
+    int segmentPartitionId =
+        SegmentAssignmentUtils.getRealtimeSegmentPartitionId(segmentName, 
_tableNameWithType, _helixManager,
+            _partitionColumn);
+    return assignConsumingSegment(segmentPartitionId, instancePartitions);
+  }
+
+  protected List<String> assignConsumingSegment(int segmentPartitionId, 
InstancePartitions instancePartitions) {
     int numReplicaGroups = instancePartitions.getNumReplicaGroups();
     int numPartitions = instancePartitions.getNumPartitions();
 
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignment.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignment.java
index 9ccf9a8ff0..c2f8f5d61b 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignment.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignment.java
@@ -24,6 +24,7 @@ import javax.annotation.Nullable;
 import org.apache.commons.configuration.Configuration;
 import org.apache.helix.HelixManager;
 import org.apache.pinot.common.assignment.InstancePartitions;
+import org.apache.pinot.common.metrics.ControllerMetrics;
 import org.apache.pinot.common.tier.Tier;
 import org.apache.pinot.spi.config.table.TableConfig;
 import org.apache.pinot.spi.config.table.assignment.InstancePartitionsType;
@@ -39,7 +40,7 @@ public interface SegmentAssignment {
    * @param helixManager Helix manager
    * @param tableConfig Table config
    */
-  void init(HelixManager helixManager, TableConfig tableConfig);
+  void init(HelixManager helixManager, TableConfig tableConfig, @Nullable 
ControllerMetrics controllerMetrics);
 
   /**
    * Assigns segment to instances.
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignmentFactory.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignmentFactory.java
index a49f7b9777..e32a7246b2 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignmentFactory.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/SegmentAssignmentFactory.java
@@ -18,9 +18,12 @@
  */
 package org.apache.pinot.controller.helix.core.assignment.segment;
 
+import javax.annotation.Nullable;
 import org.apache.helix.HelixManager;
+import org.apache.pinot.common.metrics.ControllerMetrics;
 import org.apache.pinot.spi.config.table.TableConfig;
 import org.apache.pinot.spi.config.table.TableType;
+import org.apache.pinot.spi.config.table.UpsertConfig;
 
 
 /**
@@ -30,14 +33,20 @@ public class SegmentAssignmentFactory {
   private SegmentAssignmentFactory() {
   }
 
-  public static SegmentAssignment getSegmentAssignment(HelixManager 
helixManager, TableConfig tableConfig) {
+  public static SegmentAssignment getSegmentAssignment(HelixManager 
helixManager, TableConfig tableConfig,
+      @Nullable ControllerMetrics controllerMetrics) {
     SegmentAssignment segmentAssignment;
     if (tableConfig.getTableType() == TableType.OFFLINE) {
       segmentAssignment = new OfflineSegmentAssignment();
     } else {
-      segmentAssignment = new RealtimeSegmentAssignment();
+      UpsertConfig upsertConfig = tableConfig.getUpsertConfig();
+      if (upsertConfig != null && upsertConfig.getMode() != 
UpsertConfig.Mode.NONE) {
+        segmentAssignment = new StrictRealtimeSegmentAssignment();
+      } else {
+        segmentAssignment = new RealtimeSegmentAssignment();
+      }
     }
-    segmentAssignment.init(helixManager, tableConfig);
+    segmentAssignment.init(helixManager, tableConfig, controllerMetrics);
     return segmentAssignment;
   }
 }
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignment.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignment.java
new file mode 100644
index 0000000000..e8913563e3
--- /dev/null
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignment.java
@@ -0,0 +1,137 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.controller.helix.core.assignment.segment;
+
+import com.google.common.base.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.apache.pinot.common.assignment.InstancePartitions;
+import org.apache.pinot.common.metrics.ControllerMeter;
+import org.apache.pinot.common.utils.LLCSegmentName;
+import org.apache.pinot.spi.config.table.assignment.InstancePartitionsType;
+import org.apache.pinot.spi.utils.CommonConstants;
+
+
+/**
+ * Segment assignment for LLC real-time table using upsert. The 
assignSegment() of RealtimeSegmentAssignment is
+ * overridden to add new segment for a table partition in a way that's 
consistent with the assignment in idealState to
+ * make sure that at any time the segments from the same table partition is 
hosted by the same server.
+ * <ul>
+ *   <li>
+ *     For the CONSUMING segments, in addition to what's done in 
RealtimeSegmentAssignment, the assignment has to be
+ *     checked if it's consistent with the current idealState. If the 
assignment calculated according to the
+ *     InstancePartition and the one in idealState are different, the one in 
idealState must be used so that segments
+ *     from the same table partition are always hosted on the same server as 
set in current idealState. If the
+ *     idealState is not honored, segments from the same table partition may 
be assigned to different servers,
+ *     breaking the key assumption for queries to be correct for the table 
using upsert.
+ *   </li>
+ *   <li>
+ *     There is no need to handle COMPLETED segments for tables using upsert, 
because their completed segments should
+ *     not be relocated to servers tagged to host COMPLETED segments. 
Basically, upsert-enabled tables can only use
+ *     servers tagged for CONSUMING segments to host both consuming and 
completed segments from a table partition.
+ *   </li>
+ * </ul>
+ */
+public class StrictRealtimeSegmentAssignment extends RealtimeSegmentAssignment 
{
+
+  @Override
+  public List<String> assignSegment(String segmentName, Map<String, 
Map<String, String>> currentAssignment,
+      Map<InstancePartitionsType, InstancePartitions> instancePartitionsMap) {
+    Preconditions.checkState(instancePartitionsMap.size() == 1, "One instance 
partition type should be provided");
+    Map.Entry<InstancePartitionsType, InstancePartitions> 
typeToInstancePartitions =
+        instancePartitionsMap.entrySet().iterator().next();
+    InstancePartitionsType instancePartitionsType = 
typeToInstancePartitions.getKey();
+    InstancePartitions instancePartitions = 
typeToInstancePartitions.getValue();
+    Preconditions.checkState(instancePartitionsType == 
InstancePartitionsType.CONSUMING,
+        "Only CONSUMING instance partition type is allowed for table using 
upsert but got: " + instancePartitionsType);
+    _logger.info("Assigning segment: {} with instance partitions: {} for 
table: {}", segmentName, instancePartitions,
+        _tableNameWithType);
+    int segmentPartitionId =
+        SegmentAssignmentUtils.getRealtimeSegmentPartitionId(segmentName, 
_tableNameWithType, _helixManager,
+            _partitionColumn);
+    List<String> instancesAssigned = 
assignConsumingSegment(segmentPartitionId, instancePartitions);
+    // Iterate the idealState to find the first segment that's in the same 
table partition with the new segment, and
+    // check if their assignments are same. We try to derive the partition id 
from segment name to avoid ZK reads.
+    Set<String> idealAssignment = null;
+    List<String> nonStandardSegments = new ArrayList<>();
+    for (Map.Entry<String, Map<String, String>> entry : 
currentAssignment.entrySet()) {
+      // Skip OFFLINE segments as they are not rebalanced, so their assignment 
in idealState can be stale.
+      if (isOfflineSegment(entry.getValue())) {
+        continue;
+      }
+      LLCSegmentName llcSegmentName = LLCSegmentName.of(entry.getKey());
+      if (llcSegmentName == null) {
+        nonStandardSegments.add(entry.getKey());
+        continue;
+      }
+      if (llcSegmentName.getPartitionGroupId() == segmentPartitionId) {
+        idealAssignment = entry.getValue().keySet();
+        break;
+      }
+    }
+    if (idealAssignment == null && !nonStandardSegments.isEmpty()) {
+      if (_logger.isDebugEnabled()) {
+        int segmentCnt = nonStandardSegments.size();
+        if (segmentCnt <= 10) {
+          _logger.debug("Check ZK metadata of {} segments: {} for any one also 
from partition: {}", segmentCnt,
+              nonStandardSegments, segmentPartitionId);
+        } else {
+          _logger.debug("Check ZK metadata of {} segments: {}... for any one 
also from partition: {}", segmentCnt,
+              nonStandardSegments.subList(0, 10), segmentPartitionId);
+        }
+      }
+      // Check ZK metadata for segments with non-standard LLC segment names to 
look for a segment that's in the same
+      // table partition with the new segment.
+      for (String nonStandardSegment : nonStandardSegments) {
+        if 
(SegmentAssignmentUtils.getRealtimeSegmentPartitionId(nonStandardSegment, 
_tableNameWithType, _helixManager,
+            _partitionColumn) == segmentPartitionId) {
+          idealAssignment = currentAssignment.get(nonStandardSegment).keySet();
+          break;
+        }
+      }
+    }
+    // Check if the candidate assignment is consistent with idealState. Use 
idealState if not.
+    if (idealAssignment == null) {
+      _logger.info("No existing assignment from idealState, using the one 
decided by instancePartitions");
+    } else if (!isSameAssignment(idealAssignment, instancesAssigned)) {
+      _logger.warn("Assignment: {} is inconsistent with idealState: {}, using 
the one from idealState",
+          instancesAssigned, idealAssignment);
+      instancesAssigned.clear();
+      instancesAssigned.addAll(idealAssignment);
+      if (_controllerMetrics != null) {
+        _controllerMetrics.addMeteredTableValue(_tableNameWithType,
+            
ControllerMeter.CONTROLLER_REALTIME_TABLE_SEGMENT_ASSIGNMENT_MISMATCH, 1L);
+      }
+    }
+    _logger.info("Assigned segment: {} to instances: {} for table: {}", 
segmentName, instancesAssigned,
+        _tableNameWithType);
+    return instancesAssigned;
+  }
+
+  private boolean isSameAssignment(Set<String> idealAssignment, List<String> 
instancesAssigned) {
+    return idealAssignment.size() == instancesAssigned.size() && 
idealAssignment.containsAll(instancesAssigned);
+  }
+
+  private boolean isOfflineSegment(Map<String, String> instanceStateMap) {
+    return 
!instanceStateMap.containsValue(CommonConstants.Helix.StateModel.SegmentStateModel.ONLINE)
+        && 
!instanceStateMap.containsValue(CommonConstants.Helix.StateModel.SegmentStateModel.CONSUMING);
+  }
+}
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/realtime/PinotLLCRealtimeSegmentManager.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/realtime/PinotLLCRealtimeSegmentManager.java
index a29910ea09..a1f49884c0 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/realtime/PinotLLCRealtimeSegmentManager.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/realtime/PinotLLCRealtimeSegmentManager.java
@@ -316,7 +316,8 @@ public class PinotLLCRealtimeSegmentManager {
     int numPartitionGroups = newPartitionGroupMetadataList.size();
     int numReplicas = getNumReplicas(tableConfig, instancePartitions);
 
-    SegmentAssignment segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig);
+    SegmentAssignment segmentAssignment =
+        SegmentAssignmentFactory.getSegmentAssignment(_helixManager, 
tableConfig, _controllerMetrics);
     Map<InstancePartitionsType, InstancePartitions> instancePartitionsMap =
         Collections.singletonMap(InstancePartitionsType.CONSUMING, 
instancePartitions);
 
@@ -555,7 +556,8 @@ public class PinotLLCRealtimeSegmentManager {
     }
 
     // Step-3
-    SegmentAssignment segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig);
+    SegmentAssignment segmentAssignment =
+        SegmentAssignmentFactory.getSegmentAssignment(_helixManager, 
tableConfig, _controllerMetrics);
     Map<InstancePartitionsType, InstancePartitions> instancePartitionsMap =
         Collections.singletonMap(InstancePartitionsType.CONSUMING, 
instancePartitions);
 
@@ -1054,7 +1056,8 @@ public class PinotLLCRealtimeSegmentManager {
         
newPartitionGroupMetadataList.stream().map(PartitionGroupMetadata::getPartitionGroupId)
             .collect(Collectors.toSet());
 
-    SegmentAssignment segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig);
+    SegmentAssignment segmentAssignment =
+        SegmentAssignmentFactory.getSegmentAssignment(_helixManager, 
tableConfig, _controllerMetrics);
     Map<InstancePartitionsType, InstancePartitions> instancePartitionsMap =
         Collections.singletonMap(InstancePartitionsType.CONSUMING, 
instancePartitions);
 
diff --git 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/rebalance/TableRebalancer.java
 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/rebalance/TableRebalancer.java
index 128d71a373..1a3b7e12f6 100644
--- 
a/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/rebalance/TableRebalancer.java
+++ 
b/pinot-controller/src/main/java/org/apache/pinot/controller/helix/core/rebalance/TableRebalancer.java
@@ -47,6 +47,7 @@ import 
org.apache.helix.zookeeper.zkclient.exception.ZkBadVersionException;
 import org.apache.pinot.common.assignment.InstanceAssignmentConfigUtils;
 import org.apache.pinot.common.assignment.InstancePartitions;
 import org.apache.pinot.common.assignment.InstancePartitionsUtils;
+import org.apache.pinot.common.metrics.ControllerMetrics;
 import org.apache.pinot.common.tier.PinotServerTierStorage;
 import org.apache.pinot.common.tier.Tier;
 import org.apache.pinot.common.tier.TierFactory;
@@ -115,8 +116,10 @@ public class TableRebalancer {
   private final HelixManager _helixManager;
   private final HelixDataAccessor _helixDataAccessor;
   private final TableRebalanceObserver _tableRebalanceObserver;
+  private final ControllerMetrics _controllerMetrics;
 
-  public TableRebalancer(HelixManager helixManager, @Nullable 
TableRebalanceObserver tableRebalanceObserver) {
+  public TableRebalancer(HelixManager helixManager, @Nullable 
TableRebalanceObserver tableRebalanceObserver,
+      @Nullable ControllerMetrics controllerMetrics) {
     _helixManager = helixManager;
     if (tableRebalanceObserver != null) {
       _tableRebalanceObserver = tableRebalanceObserver;
@@ -124,10 +127,11 @@ public class TableRebalancer {
       _tableRebalanceObserver = new NoOpTableRebalanceObserver();
     }
     _helixDataAccessor = helixManager.getHelixDataAccessor();
+    _controllerMetrics = controllerMetrics;
   }
 
   public TableRebalancer(HelixManager helixManager) {
-    this(helixManager, null);
+    this(helixManager, null, null);
   }
 
   public static String createUniqueRebalanceJobIdentifier() {
@@ -237,7 +241,8 @@ public class TableRebalancer {
 
     LOGGER.info("For rebalanceId: {}, calculating the target assignment for 
table: {}", rebalanceJobId,
         tableNameWithType);
-    SegmentAssignment segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig);
+    SegmentAssignment segmentAssignment =
+        SegmentAssignmentFactory.getSegmentAssignment(_helixManager, 
tableConfig, _controllerMetrics);
     Map<String, Map<String, String>> currentAssignment = 
currentIdealState.getRecord().getMapFields();
     Map<String, Map<String, String>> targetAssignment;
     try {
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/OfflineNonReplicaGroupTieredSegmentAssignmentTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/OfflineNonReplicaGroupTieredSegmentAssignmentTest.java
index d2af2c8dfd..af75b05c23 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/OfflineNonReplicaGroupTieredSegmentAssignmentTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/OfflineNonReplicaGroupTieredSegmentAssignmentTest.java
@@ -112,7 +112,7 @@ public class 
OfflineNonReplicaGroupTieredSegmentAssignmentTest {
         new 
TableConfigBuilder(TableType.OFFLINE).setTableName(RAW_TABLE_NAME).setNumReplicas(NUM_REPLICAS)
             .setTierConfigList(tierConfigList).build();
 
-    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig);
+    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig, null);
 
     // {
     //   0_0=[instance_0, instance_1, instance_2, instance_3, instance_4, 
instance_5, instance_6, instance_7,
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupSegmentAssignmentTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupSegmentAssignmentTest.java
index 8bfa93a1aa..4ab378e3a7 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupSegmentAssignmentTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupSegmentAssignmentTest.java
@@ -84,7 +84,7 @@ public class RealtimeNonReplicaGroupSegmentAssignmentTest {
     TableConfig tableConfig =
         new 
TableConfigBuilder(TableType.REALTIME).setTableName(RAW_TABLE_NAME).setNumReplicas(NUM_REPLICAS)
             .setStreamConfigs(streamConfigs).build();
-    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig);
+    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig, null);
 
     _instancePartitionsMap = new TreeMap<>();
     // CONSUMING instances:
@@ -122,7 +122,7 @@ public class RealtimeNonReplicaGroupSegmentAssignmentTest {
     // Update the replication by changing the NUM_REPLICAS_PER_PARTITION
     
tableConfig.getValidationConfig().setReplicasPerPartition(NUM_REPLICAS_PER_PARTITION);
     SegmentAssignment segmentAssignment =
-        SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig);
+        SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig, null);
 
     Map<InstancePartitionsType, InstancePartitions> 
onlyCompletedInstancePartitionMap =
         ImmutableMap.of(InstancePartitionsType.COMPLETED, 
_instancePartitionsMap.get(InstancePartitionsType.COMPLETED));
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupTieredSegmentAssignmentTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupTieredSegmentAssignmentTest.java
index 2686f08178..f540350e64 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupTieredSegmentAssignmentTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeNonReplicaGroupTieredSegmentAssignmentTest.java
@@ -123,7 +123,7 @@ public class 
RealtimeNonReplicaGroupTieredSegmentAssignmentTest {
     TableConfig tableConfig =
         new 
TableConfigBuilder(TableType.REALTIME).setTableName(RAW_TABLE_NAME).setNumReplicas(NUM_REPLICAS)
             
.setTierConfigList(tierConfigList).setStreamConfigs(streamConfigs).build();
-    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig);
+    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig, null);
 
     _instancePartitionsMap = new TreeMap<>();
     // CONSUMING instances:
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeReplicaGroupSegmentAssignmentTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeReplicaGroupSegmentAssignmentTest.java
index ffc9998179..a6da0552cd 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeReplicaGroupSegmentAssignmentTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/RealtimeReplicaGroupSegmentAssignmentTest.java
@@ -90,7 +90,7 @@ public class RealtimeReplicaGroupSegmentAssignmentTest {
             .setStreamConfigs(streamConfigs)
             
.setSegmentAssignmentStrategy(AssignmentStrategy.REPLICA_GROUP_SEGMENT_ASSIGNMENT_STRATEGY)
             .setReplicaGroupStrategyConfig(new 
ReplicaGroupStrategyConfig(PARTITION_COLUMN, 1)).build();
-    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig);
+    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig, null);
 
     _instancePartitionsMap = new TreeMap<>();
     // CONSUMING instances:
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignmentTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignmentTest.java
new file mode 100644
index 0000000000..13520bb4f8
--- /dev/null
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/StrictRealtimeSegmentAssignmentTest.java
@@ -0,0 +1,287 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.controller.helix.core.assignment.segment;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import org.apache.helix.HelixManager;
+import org.apache.helix.store.zk.ZkHelixPropertyStore;
+import org.apache.helix.zookeeper.datamodel.ZNRecord;
+import org.apache.pinot.common.assignment.InstancePartitions;
+import org.apache.pinot.common.utils.LLCSegmentName;
+import org.apache.pinot.core.realtime.impl.fakestream.FakeStreamConfigUtils;
+import org.apache.pinot.spi.config.table.ReplicaGroupStrategyConfig;
+import org.apache.pinot.spi.config.table.TableConfig;
+import org.apache.pinot.spi.config.table.TableType;
+import org.apache.pinot.spi.config.table.UpsertConfig;
+import org.apache.pinot.spi.config.table.assignment.InstancePartitionsType;
+import 
org.apache.pinot.spi.utils.CommonConstants.Helix.StateModel.SegmentStateModel;
+import org.apache.pinot.spi.utils.CommonConstants.Segment.AssignmentStrategy;
+import org.apache.pinot.spi.utils.builder.TableConfigBuilder;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+
+@SuppressWarnings("unchecked")
+public class StrictRealtimeSegmentAssignmentTest {
+  private static final int NUM_REPLICAS = 3;
+  private static final String PARTITION_COLUMN = "partitionColumn";
+  private static final int NUM_PARTITIONS = 4;
+  private static final int NUM_SEGMENTS = 24;
+  private static final String CONSUMING_INSTANCE_NAME_PREFIX = 
"consumingInstance_";
+  private static final int NUM_CONSUMING_INSTANCES = 9;
+  private static final List<String> CONSUMING_INSTANCES =
+      SegmentAssignmentTestUtils.getNameList(CONSUMING_INSTANCE_NAME_PREFIX, 
NUM_CONSUMING_INSTANCES);
+  private static final List<String> NEW_CONSUMING_INSTANCES =
+      SegmentAssignmentTestUtils.getNameList("new_" + 
CONSUMING_INSTANCE_NAME_PREFIX, NUM_CONSUMING_INSTANCES);
+  private static final String RAW_TABLE_NAME = "testTable";
+  private static final String CONSUMING_INSTANCE_PARTITIONS_NAME =
+      
InstancePartitionsType.CONSUMING.getInstancePartitionsName(RAW_TABLE_NAME);
+
+  private List<String> _segments;
+  private SegmentAssignment _segmentAssignment;
+  private Map<InstancePartitionsType, InstancePartitions> 
_instancePartitionsMap;
+  private InstancePartitions _newConsumingInstancePartitions;
+
+  @BeforeClass
+  public void setUp() {
+    _segments = new ArrayList<>(NUM_SEGMENTS);
+    for (int segmentId = 0; segmentId < NUM_SEGMENTS; segmentId++) {
+      _segments.add(new LLCSegmentName(RAW_TABLE_NAME, segmentId % 
NUM_PARTITIONS, segmentId / NUM_PARTITIONS,
+          System.currentTimeMillis()).getSegmentName());
+    }
+
+    Map<String, String> streamConfigs = 
FakeStreamConfigUtils.getDefaultLowLevelStreamConfigs().getStreamConfigsMap();
+    UpsertConfig upsertConfig = new UpsertConfig(UpsertConfig.Mode.FULL);
+    TableConfig tableConfig =
+        new 
TableConfigBuilder(TableType.REALTIME).setTableName(RAW_TABLE_NAME).setNumReplicas(NUM_REPLICAS)
+            .setStreamConfigs(streamConfigs).setUpsertConfig(upsertConfig)
+            
.setSegmentAssignmentStrategy(AssignmentStrategy.REPLICA_GROUP_SEGMENT_ASSIGNMENT_STRATEGY)
+            .setReplicaGroupStrategyConfig(new 
ReplicaGroupStrategyConfig(PARTITION_COLUMN, 1)).build();
+    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(createHelixManager(), 
tableConfig, null);
+
+    _instancePartitionsMap = new TreeMap<>();
+    // CONSUMING instances:
+    // {
+    //   0_0=[instance_0, instance_1, instance_2],
+    //   0_1=[instance_3, instance_4, instance_5],
+    //   0_2=[instance_6, instance_7, instance_8]
+    // }
+    //        p0          p1          p2
+    //        p3
+    InstancePartitions consumingInstancePartitions = new 
InstancePartitions(CONSUMING_INSTANCE_PARTITIONS_NAME);
+    int numConsumingInstancesPerReplicaGroup = NUM_CONSUMING_INSTANCES / 
NUM_REPLICAS;
+    int consumingInstanceIdToAdd = 0;
+    for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+      List<String> consumingInstancesForReplicaGroup = new 
ArrayList<>(numConsumingInstancesPerReplicaGroup);
+      for (int i = 0; i < numConsumingInstancesPerReplicaGroup; i++) {
+        
consumingInstancesForReplicaGroup.add(CONSUMING_INSTANCES.get(consumingInstanceIdToAdd++));
+      }
+      consumingInstancePartitions.setInstances(0, replicaGroupId, 
consumingInstancesForReplicaGroup);
+    }
+    _instancePartitionsMap.put(InstancePartitionsType.CONSUMING, 
consumingInstancePartitions);
+
+    // new CONSUMING instances:
+    // {
+    //   0_0=[new_instance_0, new_instance_1, new_instance_2],
+    //   0_1=[new_instance_3, new_instance_4, new_instance_5],
+    //   0_2=[new_instance_6, new_instance_7, new_instance_8]
+    // }
+    consumingInstanceIdToAdd = 0;
+    _newConsumingInstancePartitions = new 
InstancePartitions(CONSUMING_INSTANCE_PARTITIONS_NAME);
+    for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+      List<String> consumingInstancesForReplicaGroup = new 
ArrayList<>(numConsumingInstancesPerReplicaGroup);
+      for (int i = 0; i < numConsumingInstancesPerReplicaGroup; i++) {
+        
consumingInstancesForReplicaGroup.add(NEW_CONSUMING_INSTANCES.get(consumingInstanceIdToAdd++));
+      }
+      _newConsumingInstancePartitions.setInstances(0, replicaGroupId, 
consumingInstancesForReplicaGroup);
+    }
+  }
+
+  @Test
+  public void testFactory() {
+    assertTrue(_segmentAssignment instanceof StrictRealtimeSegmentAssignment);
+  }
+
+  @Test
+  public void testAssignSegment() {
+    assertTrue(_segmentAssignment instanceof StrictRealtimeSegmentAssignment);
+    Map<InstancePartitionsType, InstancePartitions> 
onlyConsumingInstancePartitionMap =
+        ImmutableMap.of(InstancePartitionsType.CONSUMING, 
_instancePartitionsMap.get(InstancePartitionsType.CONSUMING));
+    int numInstancesPerReplicaGroup = NUM_CONSUMING_INSTANCES / NUM_REPLICAS;
+    Map<String, Map<String, String>> currentAssignment = new TreeMap<>();
+    // Add segments for partition 0/1/2, but add no segment for partition 3.
+    List<String> instancesAssigned;
+    boolean consistent;
+    for (int segmentId = 0; segmentId < 3; segmentId++) {
+      String segmentName = _segments.get(segmentId);
+      instancesAssigned =
+          _segmentAssignment.assignSegment(segmentName, currentAssignment, 
onlyConsumingInstancePartitionMap);
+      assertEquals(instancesAssigned.size(), NUM_REPLICAS);
+      // Segment 0 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 1 (partition 1) should be assigned to instance 1, 4, 7
+      // Segment 2 (partition 2) should be assigned to instance 2, 5, 8
+      // Following segments are assigned to those instances if continue to use 
the same instancePartition
+      // Segment 3 (partition 3) should be assigned to instance 0, 3, 6
+      // Segment 4 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 5 (partition 1) should be assigned to instance 1, 4, 7
+      // ...
+      for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+        int partitionId = segmentId % NUM_PARTITIONS;
+        int expectedAssignedInstanceId =
+            partitionId % numInstancesPerReplicaGroup + replicaGroupId * 
numInstancesPerReplicaGroup;
+        assertEquals(instancesAssigned.get(replicaGroupId), 
CONSUMING_INSTANCES.get(expectedAssignedInstanceId));
+      }
+      addToAssignment(currentAssignment, segmentId, instancesAssigned);
+    }
+    // Use new instancePartition to assign the new segments below.
+    ImmutableMap<InstancePartitionsType, InstancePartitions> 
newConsumingInstancePartitionMap =
+        ImmutableMap.of(InstancePartitionsType.CONSUMING, 
_newConsumingInstancePartitions);
+
+    // No existing segments for partition 3, so use the assignment decided by 
new instancePartition.
+    // So segment 3 (partition 3) should be assigned to instance new_0, new_3, 
new_6
+    int segmentId = 3;
+    String segmentName = _segments.get(segmentId);
+    instancesAssigned =
+        _segmentAssignment.assignSegment(segmentName, currentAssignment, 
newConsumingInstancePartitionMap);
+    assertEquals(instancesAssigned,
+        Arrays.asList("new_consumingInstance_0", "new_consumingInstance_3", 
"new_consumingInstance_6"));
+    addToAssignment(currentAssignment, segmentId, instancesAssigned);
+
+    // Use existing assignment for partition 0/1/2, instead of the one decided 
by new instancePartition.
+    for (segmentId = 4; segmentId < 7; segmentId++) {
+      segmentName = _segments.get(segmentId);
+      instancesAssigned =
+          _segmentAssignment.assignSegment(segmentName, currentAssignment, 
newConsumingInstancePartitionMap);
+      assertEquals(instancesAssigned.size(), NUM_REPLICAS);
+
+      // Those segments are assigned according to the assignment from 
idealState, instead of using new_xxx instances
+      // Segment 4 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 5 (partition 1) should be assigned to instance 1, 4, 7
+      // Segment 6 (partition 2) should be assigned to instance 2, 5, 8
+      for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+        int partitionId = segmentId % NUM_PARTITIONS;
+        int expectedAssignedInstanceId =
+            partitionId % numInstancesPerReplicaGroup + replicaGroupId * 
numInstancesPerReplicaGroup;
+        assertEquals(instancesAssigned.get(replicaGroupId), 
CONSUMING_INSTANCES.get(expectedAssignedInstanceId));
+      }
+      addToAssignment(currentAssignment, segmentId, instancesAssigned);
+    }
+  }
+
+  @Test
+  public void testAssignSegmentWithOfflineSegment() {
+    assertTrue(_segmentAssignment instanceof StrictRealtimeSegmentAssignment);
+    Map<InstancePartitionsType, InstancePartitions> 
onlyConsumingInstancePartitionMap =
+        ImmutableMap.of(InstancePartitionsType.CONSUMING, 
_instancePartitionsMap.get(InstancePartitionsType.CONSUMING));
+    int numInstancesPerReplicaGroup = NUM_CONSUMING_INSTANCES / NUM_REPLICAS;
+    Map<String, Map<String, String>> currentAssignment = new TreeMap<>();
+    // Add segments for partition 0/1/2, but add no segment for partition 3.
+    List<String> instancesAssigned;
+    boolean consistent;
+    for (int segmentId = 0; segmentId < 3; segmentId++) {
+      String segmentName = _segments.get(segmentId);
+      instancesAssigned =
+          _segmentAssignment.assignSegment(segmentName, currentAssignment, 
onlyConsumingInstancePartitionMap);
+      assertEquals(instancesAssigned.size(), NUM_REPLICAS);
+      // Segment 0 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 1 (partition 1) should be assigned to instance 1, 4, 7
+      // Segment 2 (partition 2) should be assigned to instance 2, 5, 8
+      // Following segments are assigned to those instances if continue to use 
the same instancePartition
+      // Segment 3 (partition 3) should be assigned to instance 0, 3, 6
+      // Segment 4 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 5 (partition 1) should be assigned to instance 1, 4, 7
+      // ...
+      for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+        int partitionId = segmentId % NUM_PARTITIONS;
+        int expectedAssignedInstanceId =
+            partitionId % numInstancesPerReplicaGroup + replicaGroupId * 
numInstancesPerReplicaGroup;
+        assertEquals(instancesAssigned.get(replicaGroupId), 
CONSUMING_INSTANCES.get(expectedAssignedInstanceId));
+      }
+      currentAssignment.put(segmentName,
+          SegmentAssignmentUtils.getInstanceStateMap(instancesAssigned, 
SegmentStateModel.OFFLINE));
+    }
+    // Use new instancePartition to assign the new segments below.
+    ImmutableMap<InstancePartitionsType, InstancePartitions> 
newConsumingInstancePartitionMap =
+        ImmutableMap.of(InstancePartitionsType.CONSUMING, 
_newConsumingInstancePartitions);
+
+    // No existing segments for partition 3, so use the assignment decided by 
new instancePartition. All existing
+    // segments for partition 0/1/2 are offline, thus skipped, so use the 
assignment decided by new instancePartition.
+    for (int segmentId = 3; segmentId < 7; segmentId++) {
+      String segmentName = _segments.get(segmentId);
+      instancesAssigned =
+          _segmentAssignment.assignSegment(segmentName, currentAssignment, 
newConsumingInstancePartitionMap);
+      assertEquals(instancesAssigned.size(), NUM_REPLICAS);
+
+      // Those segments are assigned according to the assignment from 
idealState, instead of using new_xxx instances
+      // Segment 4 (partition 0) should be assigned to instance 0, 3, 6
+      // Segment 5 (partition 1) should be assigned to instance 1, 4, 7
+      // Segment 6 (partition 2) should be assigned to instance 2, 5, 8
+      for (int replicaGroupId = 0; replicaGroupId < NUM_REPLICAS; 
replicaGroupId++) {
+        int partitionId = segmentId % NUM_PARTITIONS;
+        int expectedAssignedInstanceId =
+            partitionId % numInstancesPerReplicaGroup + replicaGroupId * 
numInstancesPerReplicaGroup;
+        assertEquals(instancesAssigned.get(replicaGroupId), 
NEW_CONSUMING_INSTANCES.get(expectedAssignedInstanceId));
+      }
+      addToAssignment(currentAssignment, segmentId, instancesAssigned);
+    }
+    System.out.println(currentAssignment);
+  }
+
+  @Test(expectedExceptions = IllegalStateException.class)
+  public void testAssignSegmentToCompletedServers() {
+    _segmentAssignment.assignSegment("seg01", new TreeMap<>(), new 
TreeMap<>());
+  }
+
+  private void addToAssignment(Map<String, Map<String, String>> 
currentAssignment, int segmentId,
+      List<String> instancesAssigned) {
+    // Change the state of the last segment in the same partition from 
CONSUMING to ONLINE if exists
+    if (segmentId >= NUM_PARTITIONS) {
+      String lastSegmentInPartition = _segments.get(segmentId - 
NUM_PARTITIONS);
+      Map<String, String> instanceStateMap = 
currentAssignment.get(lastSegmentInPartition);
+      currentAssignment.put(lastSegmentInPartition,
+          SegmentAssignmentUtils.getInstanceStateMap(new 
ArrayList<>(instanceStateMap.keySet()),
+              SegmentStateModel.ONLINE));
+    }
+
+    // Add the new segment into the assignment as CONSUMING
+    currentAssignment.put(_segments.get(segmentId),
+        SegmentAssignmentUtils.getInstanceStateMap(instancesAssigned, 
SegmentStateModel.CONSUMING));
+  }
+
+  private HelixManager createHelixManager() {
+    HelixManager helixManager = mock(HelixManager.class);
+    ZkHelixPropertyStore<ZNRecord> propertyStore = 
mock(ZkHelixPropertyStore.class);
+    when(helixManager.getHelixPropertyStore()).thenReturn(propertyStore);
+    when(propertyStore.get(anyString(), isNull(), anyInt())).thenReturn(new 
ZNRecord("0"));
+    return helixManager;
+  }
+}
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/AllServersSegmentAssignmentStrategyTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/AllServersSegmentAssignmentStrategyTest.java
index 0f64d608c6..7a75f8350d 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/AllServersSegmentAssignmentStrategyTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/AllServersSegmentAssignmentStrategyTest.java
@@ -86,7 +86,7 @@ public class AllServersSegmentAssignmentStrategyTest {
 
     _instancePartitionsMap.put(InstancePartitionsType.OFFLINE, 
instancePartitions);
     _instancePartitionsMap.put(InstancePartitionsType.COMPLETED, 
completedInstancePartitions);
-    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig);
+    _segmentAssignment = 
SegmentAssignmentFactory.getSegmentAssignment(_helixManager, tableConfig, null);
   }
 
   @Test
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/BalancedNumSegmentAssignmentStrategyTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/BalancedNumSegmentAssignmentStrategyTest.java
index 8cef7ef57e..277043230f 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/BalancedNumSegmentAssignmentStrategyTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/BalancedNumSegmentAssignmentStrategyTest.java
@@ -65,7 +65,7 @@ public class BalancedNumSegmentAssignmentStrategyTest {
   public void setUp() {
     TableConfig tableConfig =
         new 
TableConfigBuilder(TableType.OFFLINE).setTableName(RAW_TABLE_NAME).setNumReplicas(NUM_REPLICAS).build();
-    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig);
+    _segmentAssignment = SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfig, null);
 
     // {
     //   0_0=[instance_0, instance_1, instance_2, instance_3, instance_4, 
instance_5, instance_6, instance_7,
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/ReplicaGroupSegmentAssignmentStrategyTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/ReplicaGroupSegmentAssignmentStrategyTest.java
index f2bf9fca91..e944a3ab2f 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/ReplicaGroupSegmentAssignmentStrategyTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/assignment/segment/strategy/ReplicaGroupSegmentAssignmentStrategyTest.java
@@ -95,7 +95,7 @@ public class ReplicaGroupSegmentAssignmentStrategyTest {
             .setNumReplicas(NUM_REPLICAS)
             
.setSegmentAssignmentStrategy(AssignmentStrategy.REPLICA_GROUP_SEGMENT_ASSIGNMENT_STRATEGY).build();
     _segmentAssignmentWithoutPartition =
-        SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfigWithoutPartitions);
+        SegmentAssignmentFactory.getSegmentAssignment(null, 
tableConfigWithoutPartitions, null);
 
     // {
     //   0_0=[instance_0, instance_1, instance_2, instance_3, instance_4, 
instance_5],
@@ -146,7 +146,7 @@ public class ReplicaGroupSegmentAssignmentStrategyTest {
             
.setSegmentAssignmentStrategy(AssignmentStrategy.REPLICA_GROUP_SEGMENT_ASSIGNMENT_STRATEGY)
             .setReplicaGroupStrategyConfig(replicaGroupStrategyConfig).build();
     _segmentAssignmentWithPartition =
-        
SegmentAssignmentFactory.getSegmentAssignment(helixManagerWithPartitions, 
tableConfigWithPartitions);
+        
SegmentAssignmentFactory.getSegmentAssignment(helixManagerWithPartitions, 
tableConfigWithPartitions, null);
 
     // {
     //   0_0=[instance_0, instance_1], 1_0=[instance_2, instance_3], 
2_0=[instance_4, instance_5],
@@ -404,7 +404,7 @@ public class ReplicaGroupSegmentAssignmentStrategyTest {
             
.setSegmentAssignmentStrategy(AssignmentStrategy.REPLICA_GROUP_SEGMENT_ASSIGNMENT_STRATEGY).build();
     
tableConfigWithPartitions.getValidationConfig().setReplicaGroupStrategyConfig(replicaGroupStrategyConfig);
     SegmentAssignment segmentAssignment =
-        SegmentAssignmentFactory.getSegmentAssignment(helixManager, 
tableConfigWithPartitions);
+        SegmentAssignmentFactory.getSegmentAssignment(helixManager, 
tableConfigWithPartitions, null);
 
     // {
     //   0_0=[instance_0, instance_1, instance_2, instance_3, instance_4, 
instance_5],
diff --git 
a/pinot-tools/src/main/java/org/apache/pinot/tools/perf/PerfBenchmarkDriver.java
 
b/pinot-tools/src/main/java/org/apache/pinot/tools/perf/PerfBenchmarkDriver.java
index c8b4020891..1f0e5d17ba 100644
--- 
a/pinot-tools/src/main/java/org/apache/pinot/tools/perf/PerfBenchmarkDriver.java
+++ 
b/pinot-tools/src/main/java/org/apache/pinot/tools/perf/PerfBenchmarkDriver.java
@@ -290,7 +290,7 @@ public class PerfBenchmarkDriver {
       _helixResourceManager = new PinotHelixResourceManager(controllerConf);
       String instanceId = controllerConf.getControllerHost() + "_" + 
controllerConf.getControllerPort();
       HelixManager helixManager = 
registerAndConnectAsHelixSpectator(instanceId);
-      _helixResourceManager.start(helixManager);
+      _helixResourceManager.start(helixManager, null);
     }
 
     // Create server tenants if required


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to