import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public boolean registerStateModelFactory(String stateModelName,
    StateModelFactory<? extends StateModel> factory, String factoryName) {
  if (stateModelName == null || factory == null || factoryName == null) {
    throw new HelixException("stateModelDef|stateModelFactory|factoryName cannot be null");
  }

  logger.info("Register state model factory for state model " + stateModelName
      + " using factory name " + factoryName + " with " + factory);

  if (!_stateModelFactoryMap.containsKey(stateModelName)) {
    _stateModelFactoryMap.put(stateModelName,
        new ConcurrentHashMap<String, StateModelFactory<? extends StateModel>>());
  }

  if (_stateModelFactoryMap.get(stateModelName).containsKey(factoryName)) {
    logger.warn("stateModelFactory for " + stateModelName + " using factoryName " + factoryName
        + " has already been registered.");
    return false;
  }

  _stateModelFactoryMap.get(stateModelName).put(factoryName, factory);
  sendNopMessage();
  return true;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public void reset() {
  for (Map<String, StateModelFactory<? extends StateModel>> ftyMap : _stateModelFactoryMap
      .values()) {
    for (StateModelFactory<? extends StateModel> stateModelFactory : ftyMap.values()) {
      for (String resourceName : stateModelFactory.getResourceSet()) {
        for (String partitionKey : stateModelFactory.getPartitionSet(resourceName)) {
          StateModel stateModel = stateModelFactory.getStateModel(resourceName, partitionKey);
          stateModel.reset();
          String initialState = _stateModelParser.getInitialState(stateModel.getClass());
          stateModel.updateState(initialState);
          // TODO probably should update the state on ZK. Shi confirm what needs
          // to be done here.
        }
      }
    }
  }
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName, String partitionName) {
  MasterSlaveStateModel stateModel = new MasterSlaveStateModel();
  stateModel.setInstanceName(_instanceName);
  stateModel.setDelay(_delay);
  stateModel.setPartitionName(partitionName);
  return stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName, String stateUnitKey) {
  OnlineOfflineStateModel stateModel = new OnlineOfflineStateModel();
  stateModel.setDelay(_delay);
  stateModel.setInstanceName(_instanceName);
  return stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override public StateModel createNewStateModel(String resourceName, String partitionName) {
  LeaderStandbyStateModel stateModel = new LeaderStandbyStateModel();
  stateModel.setDelay(_delay);
  stateModel.setInstanceName(_instanceName);
  stateModel.setPartitionName(partitionName);
  return stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
public HelixStateMachineEngine(HelixManager manager) {
  _stateModelParser = new StateModelParser();
  _manager = manager;

  _stateModelFactoryMap =
      new ConcurrentHashMap<String, Map<String, StateModelFactory<? extends StateModel>>>();
  _stateModelDefs = new ConcurrentHashMap<String, StateModelDefinition>();
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModelFactory<? extends StateModel> getStateModelFactory(String stateModelName,
    String factoryName) {
  if (!_stateModelFactoryMap.containsKey(stateModelName)) {
    return null;
  }
  return _stateModelFactoryMap.get(stateModelName).get(factoryName);
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
public HelixStateTransitionHandler(StateModelFactory<? extends StateModel> stateModelFactory,
    StateModel stateModel, Message message, NotificationContext context,
    CurrentState currentStateDelta) {
  super(message, context);
  _stateModel = stateModel;
  _statusUpdateUtil = new StatusUpdateUtil();
  _transitionMethodFinder = new StateModelParser();
  _currentStateDelta = currentStateDelta;
  _manager = _notificationContext.getManager();
  _stateModelFactory = stateModelFactory;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
/**
 * check state-model factory contains state-models same as in expect-state-model map
 * @param fty
 * @param expectStateModelMap
 */
static void checkStateModelMap(StateModelFactory<? extends StateModel> fty,
    Map<String, String> expectStateModelMap) {
  Assert.assertEquals(fty.getPartitionSet("TestDB0").size(), expectStateModelMap.size());
  for (String partition : fty.getPartitionSet("TestDB0")) {
    StateModel stateModel = fty.getStateModel("TestDB0", partition);
    String actualState = stateModel.getCurrentState();
    String expectState = expectStateModelMap.get(partition);
    LOG.debug(partition + " actual state: " + actualState + ", expect state: " + expectState);
    Assert.assertEquals(actualState, expectState, "partition: " + partition
        + " should be in state: " + expectState + " but was " + actualState);
  }
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName, String stateUnitKey) {
  TestOnlineOfflineStateModel stateModel = new TestOnlineOfflineStateModel(_instanceId);
  stateModel.setDelay(_delay);
  return stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resource, String stateModelUnit) {
  OnlineOfflineStateModel stateModel = new OnlineOfflineStateModel();
  return stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String partitionName) {
  final EmptySegmentOnlineOfflineStateModel SegmentOnlineOfflineStateModel = new EmptySegmentOnlineOfflineStateModel();
  return SegmentOnlineOfflineStateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String partitionName) {
  final EmptyBrokerOnlineOfflineStateModel SegmentOnlineOfflineStateModel = new EmptyBrokerOnlineOfflineStateModel();
  return SegmentOnlineOfflineStateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName) {
  return new BrokerResourceOnlineOfflineStateModel();
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String partitionName) {
  final SegmentOnlineOfflineStateModel SegmentOnlineOfflineStateModel =
      new SegmentOnlineOfflineStateModel(HELIX_CLUSTER_NAME, INSTANCE_ID);
  return SegmentOnlineOfflineStateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName, String stateUnitKey) {
  return new BootstrapStateModel(stateUnitKey);
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public boolean removeStateModelFactory(String stateModelDef,
    StateModelFactory<? extends StateModel> factory) {
  throw new UnsupportedOperationException("Remove not yet supported");
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
public HelixStateTransitionCancellationHandler(StateModel stateModel, Message message,
    NotificationContext context) {
  super(message, context);
  _stateModel = stateModel;
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
/**
 * test drop resource should remove all state models
 * @throws Exception
 */
@Test
public void testDrop() throws Exception {
  // Logger.getRootLogger().setLevel(Level.INFO);
  String className = TestHelper.getTestClassName();
  String methodName = TestHelper.getTestMethodName();
  String clusterName = className + "_" + methodName;
  int n = 2;

  System.out.println("START " + clusterName + " at " + new Date(System.currentTimeMillis()));

  TestHelper.setupCluster(clusterName, ZK_ADDR, 12918, // participant port
      "localhost", // participant name prefix
      "TestDB", // resource name prefix
      1, // resources
      4, // partitions per resource
      n, // number of nodes
      2, // replicas
      "MasterSlave", true); // do rebalance

  // start controller
  ClusterControllerManager controller =
      new ClusterControllerManager(ZK_ADDR, clusterName, "controller");
  controller.syncStart();

  MockParticipantManager[] participants = new MockParticipantManager[n];
  for (int i = 0; i < n; i++) {
    final String instanceName = "localhost_" + (12918 + i);

    participants[i] = new MockParticipantManager(ZK_ADDR, clusterName, instanceName);
    participants[i].syncStart();
  }

  boolean result =
      ClusterStateVerifier.verifyByZkCallback(new BestPossAndExtViewZkVerifier(ZK_ADDR,
          clusterName));
  Assert.assertTrue(result);

  // check state-models in state-machine
  HelixStateMachineEngine stateMachine =
      (HelixStateMachineEngine) participants[0].getStateMachineEngine();
  StateModelFactory<? extends StateModel> fty = stateMachine.getStateModelFactory("MasterSlave");
  Map<String, String> expectStateModelMap = new TreeMap<String, String>();
  expectStateModelMap.put("TestDB0_0", "SLAVE");
  expectStateModelMap.put("TestDB0_1", "MASTER");
  expectStateModelMap.put("TestDB0_2", "SLAVE");
  expectStateModelMap.put("TestDB0_3", "MASTER");
  checkStateModelMap(fty, expectStateModelMap);

  // drop resource
  HelixAdmin admin = new ZKHelixAdmin(_gZkClient);
  admin.dropResource(clusterName, "TestDB0");

  result =
      ClusterStateVerifier.verifyByZkCallback(new BestPossAndExtViewZkVerifier(ZK_ADDR,
          clusterName));
  Assert.assertTrue(result);

  // check state models have been dropped also
  Assert.assertTrue(fty.getPartitionSet("TestDB0").isEmpty(),
      "All state-models should be dropped, but was " + fty.getPartitionSet("TestDB0"));

  // cleanup
  controller.syncStop();
  for (int i = 0; i < n; i++) {
    participants[i].syncStop();
  }

  System.out.println("END " + clusterName + " at " + new Date(System.currentTimeMillis()));
}
 

import org.apache.helix.participant.statemachine.StateModel; //导入依赖的package包/类
@Override
public StateModel createNewStateModel(String resourceName, String partitionName) {
  return new FakeSegmentStateModel();
}