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]