private TaskStateModelFactory createTaskStateModelFactory(Map<String, TaskFactory> taskFactoryMap) { HelixManager receiverManager = getReceiverManager(); TaskStateModelFactory taskStateModelFactory = new TaskStateModelFactory(receiverManager, taskFactoryMap); receiverManager.getStateMachineEngine() .registerStateModelFactory("Task", taskStateModelFactory); return taskStateModelFactory; }
_helixManager.getStateMachineEngine().registerStateModelFactory("Task", new TaskStateModelFactory(_helixManager, new TaskFactoryRegistry(_taskExecutorFactoryRegistry, _eventObserverFactoryRegistry).getTaskFactoryRegistry())); _helixManager.connect();
public static void addFakeDataInstanceToAutoJoinHelixCluster(String helixClusterName, String zkServer, String instanceId, boolean isSingleTenant, int adminPort) throws Exception { final HelixManager helixZkManager = HelixManagerFactory.getZKHelixManager(helixClusterName, instanceId, InstanceType.PARTICIPANT, zkServer); final StateMachineEngine stateMachineEngine = helixZkManager.getStateMachineEngine(); final StateModelFactory<?> stateModelFactory = new EmptySegmentOnlineOfflineStateModelFactory(); stateMachineEngine .registerStateModelFactory(EmptySegmentOnlineOfflineStateModelFactory.getStateModelDef(), stateModelFactory); helixZkManager.connect(); if (isSingleTenant) { helixZkManager.getClusterManagmentTool().addInstanceTag(helixClusterName, instanceId, TableNameBuilder.OFFLINE.tableNameWithType(TagNameUtils.DEFAULT_TENANT_NAME)); helixZkManager.getClusterManagmentTool().addInstanceTag(helixClusterName, instanceId, TableNameBuilder.REALTIME.tableNameWithType(TagNameUtils.DEFAULT_TENANT_NAME)); } else { helixZkManager.getClusterManagmentTool().addInstanceTag(helixClusterName, instanceId, UNTAGGED_SERVER_INSTANCE); } HelixConfigScope scope = new HelixConfigScopeBuilder(HelixConfigScope.ConfigScopeProperty.PARTICIPANT, helixClusterName) .forParticipant(instanceId).build(); Map<String, String> props = new HashMap<>(); props.put(CommonConstants.Helix.Instance.ADMIN_PORT_KEY, String.valueOf(adminPort)); helixZkManager.getClusterManagmentTool().setConfig(scope, props); }
public static void addFakeBrokerInstancesToAutoJoinHelixCluster(String helixClusterName, String zkServer, int numInstances, boolean isSingleTenant) throws Exception { for (int i = 0; i < numInstances; ++i) { final String brokerId = "Broker_localhost_" + i; final HelixManager helixZkManager = HelixManagerFactory.getZKHelixManager(helixClusterName, brokerId, InstanceType.PARTICIPANT, zkServer); final StateMachineEngine stateMachineEngine = helixZkManager.getStateMachineEngine(); final StateModelFactory<?> stateModelFactory = new EmptyBrokerOnlineOfflineStateModelFactory(); stateMachineEngine .registerStateModelFactory(EmptyBrokerOnlineOfflineStateModelFactory.getStateModelDef(), stateModelFactory); helixZkManager.connect(); if (isSingleTenant) { helixZkManager.getClusterManagmentTool().addInstanceTag(helixClusterName, brokerId, TagNameUtils.getBrokerTagForTenant(TagNameUtils.DEFAULT_TENANT_NAME)); } else { helixZkManager.getClusterManagmentTool().addInstanceTag(helixClusterName, brokerId, UNTAGGED_BROKER_INSTANCE); } } }
_helixManager = HelixManagerFactory.getZKHelixManager(helixClusterName, _instanceId, InstanceType.PARTICIPANT, _zkServers); final StateMachineEngine stateMachineEngine = _helixManager.getStateMachineEngine(); _helixManager.connect(); _helixAdmin = _helixManager.getClusterManagmentTool();
StateMachineEngine stateMachineEngine = _helixManager.getStateMachineEngine(); StateModelFactory<?> stateModelFactory = new BrokerResourceOnlineOfflineStateModelFactory(_spectatorHelixManager, _propertyStore,
/** * Helper method to start a fake server that only implements Helix part. * * @throws Exception */ private void startFakeServer() throws Exception { _serverInstance = CommonConstants.Helix.PREFIX_OF_SERVER_INSTANCE + NetUtil.getHostAddress() + "_" + CommonConstants.Helix.DEFAULT_SERVER_NETTY_PORT; // Create server instance with the fake server state model _serverHelixManager = HelixManagerFactory .getZKHelixManager(_clusterName, _serverInstance, InstanceType.PARTICIPANT, ZkStarter.DEFAULT_ZK_STR); _serverHelixManager.getStateMachineEngine() .registerStateModelFactory(SegmentOnlineOfflineStateModelFactory.getStateModelName(), new FakeServerSegmentStateModelFactory()); _serverHelixManager.connect(); // Add Helix tag to the server _serverHelixManager.getClusterManagmentTool().addInstanceTag(_clusterName, _serverInstance, TableNameBuilder.REALTIME.tableNameWithType(TagNameUtils.DEFAULT_TENANT_NAME)); // Initialize controller leader locator ControllerLeaderLocator.create(_serverHelixManager); }
public void start() throws Exception { _helixZkManager = HelixManagerFactory.getZKHelixManager(_helixClusterName, _instanceId, InstanceType.PARTICIPANT, _zkServer); StateMachineEngine stateMachineEngine = _helixZkManager.getStateMachineEngine(); // create a stateModelFactory that returns a statemodel object for each partition. TestOnlineOfflineStateModelFactory stateModelFactory = new TestOnlineOfflineStateModelFactory(_instanceId, 0); stateMachineEngine.registerStateModelFactory("OnlineOffline", stateModelFactory); _helixZkManager.connect(); }
/** * Stop customer code runner */ public void stop() { LOG.info("Removing stateModelFactory for " + _resourceName); _manager.getStateMachineEngine().removeStateModelFactory(LEADER_STANDBY, _stateModelFty, _resourceName); } }
/** * Stop customer code runner */ public void stop() { LOG.info("Removing stateModelFactory for " + _resourceName); _manager.getStateMachineEngine().removeStateModelFactory(LEADER_STANDBY, _stateModelFty, _resourceName); } }
private TaskStateModelFactory createTaskStateModelFactory(Map<String, TaskFactory> taskFactoryMap) { TaskStateModelFactory taskStateModelFactory = new TaskStateModelFactory(this.helixManager, taskFactoryMap); this.helixManager.getStateMachineEngine() .registerStateModelFactory("Task", taskStateModelFactory); return taskStateModelFactory; }
public synchronized void start() { LOGGER.info("Trying to start ManagerControllerHelix!"); _helixZkManager = HelixManagerFactory.getZKHelixManager(_helixClusterName, _instanceId, InstanceType.PARTICIPANT, _helixZkURL); _helixZkManager.getStateMachineEngine().registerStateModelFactory("OnlineOffline", new ControllerStateModelFactory(this)); try { _helixZkManager.connect(); } catch (Exception e) { LOGGER.error("Failed to start ManagerControllerHelix " + _helixClusterName, e); } }
public void start() throws Exception { System.out.println("STARTING " + instanceName); configureInstance(instanceName); participantManager = HelixManagerFactory.getZKHelixManager(clusterName, instanceName, InstanceType.PARTICIPANT, zkAddress); participantManager.getStateMachineEngine().registerStateModelFactory("OnlineOffline", new LockFactory()); participantManager.connect(); if (startController) { startController(); } System.out.println("STARTED " + instanceName); }
public void start() throws Exception { manager = HelixManagerFactory.getZKHelixManager(CLUSTER_NAME, instanceName, InstanceType.PARTICIPANT, ZK_ADDRESS); MasterSlaveStateModelFactory stateModelFactory = new MasterSlaveStateModelFactory(instanceName); StateMachineEngine stateMach = manager.getStateMachineEngine(); stateMach.registerStateModelFactory(STATE_MODEL_NAME, stateModelFactory); manager.connect(); }
public void start() throws Exception { manager = HelixManagerFactory.getZKHelixManager(CLUSTER_NAME, instanceName, InstanceType.PARTICIPANT, ZK_ADDRESS); MasterSlaveStateModelFactory stateModelFactory = new MasterSlaveStateModelFactory(instanceName); StateMachineEngine stateMach = manager.getStateMachineEngine(); stateMach.registerStateModelFactory(STATE_MODEL_NAME, stateModelFactory); manager.connect(); }
@Override public void start() { if (isStarted()) { return; } try { this.participantManager.connect(); disablePartition(); this.participantManager.getStateMachineEngine().registerStateModelFactory( "LeaderStandby", new LockTransitionalFactory( lock ) ); this.participantManager.getMessagingService().registerMessageHandlerFactory( Message.MessageType.USER_DEFINE_MSG.toString(), new MessageHandlerResolverWrapper( messageHandlerResolver ).convert() ); started.set(true); } catch ( final Exception ex ) { throw new RuntimeException( ex ); } }
private HelixManager initializeHelixManager(String clusterName, String instanceName, String zkAddress, String stateModelName) { HelixManager manager = HelixManagerFactory.getZKHelixManager(clusterName, instanceName, InstanceType.PARTICIPANT, zkAddress); MasterSlaveStateModelFactory stateModelFactory = new MasterSlaveStateModelFactory(instanceName); StateMachineEngine stateMach = manager.getStateMachineEngine(); stateMach.registerStateModelFactory(stateModelName, stateModelFactory); return manager; }
private HelixManager createParticipant(String clusterName, String instanceName) { HelixManager participant = new ZKHelixManager(clusterName, instanceName, InstanceType.PARTICIPANT, ZK_ADDR); participant.getStateMachineEngine().registerStateModelFactory("OnlineOffline", new MockStateModelFactory()); return participant; }
public void start() throws Exception { _helixZkManager = HelixManagerFactory.getZKHelixManager(_helixClusterName, _instanceId, InstanceType.PARTICIPANT, _zkServer); StateMachineEngine stateMachineEngine = _helixZkManager.getStateMachineEngine(); // create a stateModelFactory that returns a statemodel object for each partition. TestOnlineOfflineStateModelFactory stateModelFactory = new TestOnlineOfflineStateModelFactory(_instanceId, 0); stateMachineEngine.registerStateModelFactory("OnlineOffline", stateModelFactory); _helixZkManager.connect(); }
public void start() throws Exception { manager = HelixManagerFactory.getZKHelixManager(clusterName, instanceName, InstanceType.PARTICIPANT, zkConnectString); stateModelFactory = new BootstrapHandler(); // genericStateMachineHandler = new StateMachineEngine(); // genericStateMachineHandler.registerStateModelFactory("MasterSlave", stateModelFactory); StateMachineEngine stateMach = manager.getStateMachineEngine(); stateMach.registerStateModelFactory("MasterSlave", stateModelFactory); manager.getMessagingService().registerMessageHandlerFactory( MessageType.STATE_TRANSITION.name(), stateMach); manager.getMessagingService().registerMessageHandlerFactory( MessageType.USER_DEFINE_MSG.name(), new CustomMessageHandlerFactory()); manager.connect(); }