stateTransitionPriorityList); return new StateModelDefinition(record);
if (isUpdateStateModel) { final StateModelDefinition curStateModelDef = admin.getStateModelDef(helixClusterName, segmentStateModelName); List<String> states = curStateModelDef.getStatesPriorityList(); if (states.contains(PinotHelixSegmentOnlineOfflineStateModelGenerator.CONSUMING_STATE)) { LOGGER.info("State model {} already updated to contain CONSUMING state", segmentStateModelName);
/** * Instantiate a validator instance * @param stateModelDef the state model definition to validate */ private StateModelDefinitionValidator(StateModelDefinition stateModelDef) { _stateModelDef = stateModelDef; _statePriorityList = stateModelDef.getStatesPriorityList(); _transitionPriorityList = stateModelDef.getStateTransitionPriorityList(); _stateSet = Sets.newHashSet(_statePriorityList); }
@Override public boolean createStateModelDef(StateModelDefinition stateModelDef) { String path = PropertyPathBuilder.stateModelDef(_clusterName, stateModelDef.getId()); HelixProperty property = getProperty(new PropertyKey.Builder(_clusterName).stateModelDef(stateModelDef.getId())); // Set new StateModelDefinition if it is different from old one. if (property != null) { // StateModelDefinition need to be updated if (!new StateModelDefinition(property.getRecord()).equals(stateModelDef)) { return stateModelDef.isValid() && _baseDataAccessor .set(path, stateModelDef.getRecord(), AccessOption.PERSISTENT); } } else { // StateModeDefinition does not exist return stateModelDef.isValid() && _baseDataAccessor .create(path, stateModelDef.getRecord(), AccessOption.PERSISTENT); } // StateModelDefinition exists but not need to be updated return true; }
List<String> statesPriorityList = getStatesPriorityList(); String num = getNumInstancesPerState(state); if (candidateNodeNum <= 0) { break; String num = getNumInstancesPerState(state); if ("R".equals(num)) { if (candidateNodeNum > 0 && replicas > 0) {
final String partition = "resource_0"; final StateModelDefinition STATE_MODEL = new StateModelDefinition(StateModelConfigGenerator.generateConfigForOnlineOffline()); LinkedHashMap<String, Integer> stateCount = Maps.newLinkedHashMap(); stateCount.put("ONLINE", 1); for (String state : STATE_MODEL.getStatesPriorityList()) { upperBounds.put(state, STATE_MODEL.getNumInstancesPerState(state));
private void addStateModels(HelixDataAccessor accessor) { StateModelDefinition masterSlave = new StateModelDefinition(StateModelConfigGenerator.generateConfigForMasterSlave()); accessor.setProperty(accessor.keyBuilder().stateModelDef(masterSlave.getId()), masterSlave); StateModelDefinition onlineOffline = new StateModelDefinition(StateModelConfigGenerator.generateConfigForOnlineOffline()); accessor.setProperty(accessor.keyBuilder().stateModelDef(onlineOffline.getId()), onlineOffline); } }
/** * Ensure that state models that we know to be good pass validation */ @Test public void testValidModels() { StateModelDefinition masterSlave = new StateModelDefinition(StateModelConfigGenerator.generateConfigForMasterSlave()); Assert.assertTrue(masterSlave.isValid()); StateModelDefinition leaderStandby = new StateModelDefinition(StateModelConfigGenerator.generateConfigForLeaderStandby()); Assert.assertTrue(leaderStandby.isValid()); StateModelDefinition onlineOffline = new StateModelDefinition(StateModelConfigGenerator.generateConfigForOnlineOffline()); Assert.assertTrue(onlineOffline.isValid()); }
currentStateOutput.getCurrentState(resourceName, partition, instanceName); if (currentState == null) { currentState = stateModelDef.getInitialState(); if (desiredState.equals(HelixDefinedState.DROPPED.name())) { LogUtil.logDebug(logger, _eventId, String Message cancellationMessage = currentStateOutput.getCancellationMessage(resourceName, partition, instanceName); String nextState = stateModelDef.getNextStateForTransition(currentState, desiredState); message = createStateTransitionCancellationMessage(manager, resource, partition.getPartitionName(), instanceName, sessionIdMap.get(instanceName), stateModelDef.getId(), pendingMessage.getFromState(), pendingMessage.getToState(), null, cancellationMessage, isCancellationEnabled, currentState); stateModelDef.getId(), pendingMessage.getFromState(), pendingState, nextState, cancellationMessage, isCancellationEnabled, currentState); stateModelDef.getId()); List<String> statesPriorityList = stateModelDef.getStatesPriorityList(); for (String state : statesPriorityList) { if (messageMap.containsKey(state)) {
StateModelDefinition stateModelDef = setupTool.getClusterManagementTool().getStateModelDef(clusterName, stateModel); String result = new String(new ZNRecordSerializer().serialize(stateModelDef.getRecord())); System.out.println("StateModelDefinition: " + result); return 0; new StateModelDefinition(stateModelRecord)); return 0; } else if (cmd.hasOption(addIdealState)) {
ExternalView externalView = admin.getResourceExternalView(clusterId, resourceName); StateModelDefinition stateModelDef = admin.getStateModelDef(clusterId, idealState.getStateModelDefRef()); String initialState = stateModelDef.getInitialState(); List<String> statesPriorityList = stateModelDef.getStatesPriorityList(); statesPriorityList = statesPriorityList.subList(0, statesPriorityList.indexOf(initialState)); // Trim stateList to initialState and above int minActiveReplicas = idealState.getMinActiveReplicas(); stateModelDef.getStateCountMap(replicaCount, replicaCount);
}; final StateModelDefinition STATE_MODEL = new StateModelDefinition(StateModelConfigGenerator.generateConfigForMasterSlave()); final int REPLICA_COUNT = 2; final String[] NODES = { STATE_MODEL.getStateCountMap(liveNodes.size(), REPLICA_COUNT); ZNRecord znRecord = new AutoRebalanceStrategy(RESOURCE_NAME, partitions, stateCount) stateCount = STATE_MODEL.getStateCountMap(liveNodes.size(), REPLICA_COUNT); for (String partition : PARTITIONS) { currentMapping.get(partition).put(NODES[0], "MASTER"); stateCount = STATE_MODEL.getStateCountMap(liveNodes.size(), REPLICA_COUNT); stateCount = STATE_MODEL.getStateCountMap(liveNodes.size(), REPLICA_COUNT);
&& _stateModelDef.getNextStateForTransition(state, HelixDefinedState.DROPPED.toString()) == null) { _logger.error("State " + state + " cannot reach the DROPPED state, state model: " + _stateModelDef.getId()); return false; if (!state.equals(_stateModelDef.getInitialState()) && !state.equals(HelixDefinedState.ERROR.toString()) && _stateModelDef.getNextStateForTransition(_stateModelDef.getInitialState(), state) == null) { _logger.error("Initial state " + _stateModelDef.getInitialState() + " should be able to reach all states, state model: " + _stateModelDef.getId()); return false; String intermediate = _stateModelDef.getNextStateForTransition(state, destState); if (intermediate != null && !_stateSet.contains(intermediate)) { _logger.error("Intermediate state " + intermediate + " for transition " + state + "-" + destState + " is not a valid state, state model: " + _stateModelDef.getId()); return false; _logger.error("Intermediate state " + intermediate + " for transition " + state + "-" + destState + " should never be the from state, state model: " + _stateModelDef.getId()); return false;
private void validateMap(String resource, String partition, int replica, Map<String, String> instanceStateMap, StateModelDefinition stateModelDef) { if (instanceStateMap == null || instanceStateMap.isEmpty()) { _testSuccess = false; Assert.fail( String.format("Resource %s partition %s has no active replica!", resource, partition)); } if (instanceStateMap.size() < replica) { _testSuccess = false; Assert.fail(String .format("Resource %s partition %s has %d active replica, less than required %d!", resource, partition, instanceStateMap.size(), replica)); } Map<String, Integer> stateCountMap = stateModelDef.getStateCountMap(NUM_NODE, replica); String topState = stateModelDef.getStatesPriorityList().get(0); if (stateCountMap.get(topState) == 1) { int topCount = 0; for (String val : instanceStateMap.values()) { if (topState.equals(val)) { topCount++; } } if (topCount > 1) { _testSuccess = false; Assert.fail(String .format("Resource %s partition %s has %d replica in %s, more than 1!", resource, partition, topCount, topState)); } } }
.getStateCountMap(liveInstances.size(), Integer.parseInt(idealState.getReplicas())), idealState.getMaxPartitionsPerInstance());
stateModelDef.getStateCountMap(activeList.size(), replica); // StateModelDefinition's counts Map<String, Integer> currentStateCounts = StateModelDefinition.getStateCounts(currentStateMap); // Current && !state.equals(stateModelDef.getInitialState())) { return RebalanceType.RECOVERY_BALANCE;
if (currentStateMap.containsKey(instance)) { if (!currentStateMap.get(instance).equals(HelixDefinedState.ERROR.name())) { bestPossibleStateMap.put(instance, stateModelDef.getInitialState()); bestPossibleStateMap.put(instance, stateModelDef.getInitialState()); List<String> statesPriorityList = stateModelDef.getStatesPriorityList(); Set<String> assigned = new HashSet<>(); Set<String> liveAndEnabled = new HashSet<>(liveInstances);
@Override public int compare(String ins1, String ins2) { String state1 = _currentStateMap.get(ins1); String state2 = _currentStateMap.get(ins2); String topState = _stateModelDef.getStatesPriorityList().get(0); Set<String> preferredStates = new HashSet<String>(_stateModelDef.getSecondTopStates()); preferredStates.add(topState); int p1 = 1; int p2 = 1; if (state1 != null && preferredStates.contains(state1)) { p1 = 0; } if (state2 != null && preferredStates.contains(state2)) { p2 = 0; } return p1 - p2; } }
protected Map<String, String> computeBestPossibleMapForDisabledResource(Map<String, String> currentStateMap , StateModelDefinition stateModelDef) { Map<String, String> bestPossibleStateMap = new HashMap<String, String>(); for (String instance : currentStateMap.keySet()) { if (!HelixDefinedState.ERROR.name().equals(currentStateMap.get(instance))) { bestPossibleStateMap.put(instance, stateModelDef.getInitialState()); } } return bestPossibleStateMap; }
/** * Check if state counts are properly defined for each state * @return true if state counts valid, false otherwise */ private boolean areStateCountsValid() { for (String state : _statePriorityList) { // all states should have a count String count = _stateModelDef.getNumInstancesPerState(state); if (count == null) { _logger.error("State " + state + " needs an upper bound constraint, state model: " + _stateModelDef.getId()); return false; } // count should be a number, N, or R try { Integer.parseInt(count); } catch (NumberFormatException e) { if (!count.equals("N") && !count.equals("R")) { _logger.error("State " + state + " has invalid count " + count + ", state model: " + _stateModelDef.getId()); return false; } } } return true; }