package org.apache.helix.controller;
/*
* 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.
*/
/**
* start cluster manager controller
* cluster manager controller has two modes:
* 1) stand-alone mode: in this mode each controller gets a list of clusters
* and competes via leader election to become the controller for any of the clusters.
* if a controller fails to become the leader of a given cluster, it remains as a standby
* and re-does the leader election when the current leader fails
*
* 2) distributed mode: in this mode each controller first joins as participant into
* a special CONTROLLER_CLUSTER. Leader election happens in this special
* cluster. The one that becomes the leader controls all controllers (including itself
* to become leaders of other clusters.
*/
import java.util.Arrays;
import org.I0Itec.zkclient.exception.ZkInterruptedException;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.helix.HelixManager;
import org.apache.helix.HelixManagerFactory;
import org.apache.helix.InstanceType;
import org.apache.helix.api.id.StateModelDefId;
import org.apache.helix.manager.zk.HelixManagerShutdownHook;
import org.apache.helix.participant.MultiClusterControllerTransitionHandlerFactory;
import org.apache.helix.model.HelixConfigScope.ConfigScopeProperty;
import org.apache.helix.participant.StateMachineEngine;
import org.apache.log4j.Logger;
public class HelixControllerMain {
public static final String zkServerAddress = "zkSvr";
public static final String cluster = "cluster";
public static final String help = "help";
public static final String mode = "mode";
public static final String name = "controllerName";
public static final String STANDALONE = "STANDALONE";
public static final String DISTRIBUTED = "DISTRIBUTED";
private static final Logger logger = Logger.getLogger(HelixControllerMain.class);
// hack: OptionalBuilder is not thread safe
@SuppressWarnings("static-access")
synchronized private static Options constructCommandLineOptions() {
Option helpOption =
OptionBuilder.withLongOpt(help).withDescription("Prints command-line options info")
.create();
Option zkServerOption =
OptionBuilder.withLongOpt(zkServerAddress).withDescription("Provide zookeeper address")
.create();
zkServerOption.setArgs(1);
zkServerOption.setRequired(true);
zkServerOption.setArgName("ZookeeperServerAddress(Required)");
Option clusterOption =
OptionBuilder.withLongOpt(cluster).withDescription("Provide cluster name").create();
clusterOption.setArgs(1);
clusterOption.setRequired(true);
clusterOption.setArgName("Cluster name (Required)");
Option modeOption =
OptionBuilder
.withLongOpt(mode)
.withDescription(
"Provide cluster controller mode (Optional): STANDALONE (default) or DISTRIBUTED")
.create();
modeOption.setArgs(1);
modeOption.setRequired(false);
modeOption.setArgName("Cluster controller mode (Optional)");
Option controllerNameOption =
OptionBuilder.withLongOpt(name)
.withDescription("Provide cluster controller name (Optional)").create();
controllerNameOption.setArgs(1);
controllerNameOption.setRequired(false);
controllerNameOption.setArgName("Cluster controller name (Optional)");
Options options = new Options();
options.addOption(helpOption);
options.addOption(zkServerOption);
options.addOption(clusterOption);
options.addOption(modeOption);
options.addOption(controllerNameOption);
return options;
}
public static void printUsage(Options cliOptions) {
HelpFormatter helpFormatter = new HelpFormatter();
helpFormatter.setWidth(1000);
helpFormatter.printHelp("java " + HelixControllerMain.class.getName(), cliOptions);
}
public static CommandLine processCommandLineArgs(String[] cliArgs) throws Exception {
CommandLineParser cliParser = new GnuParser();
Options cliOptions = constructCommandLineOptions();
try {
return cliParser.parse(cliOptions, cliArgs);
} catch (ParseException pe) {
logger.error("fail to parse command-line options. cliArgs: " + Arrays.toString(cliArgs), pe);
printUsage(cliOptions);
System.exit(1);
}
return null;
}
public static void addListenersToController(HelixManager manager,
GenericHelixController controller) {
try {
manager.addInstanceConfigChangeListener(controller);
manager.addConfigChangeListener(controller, ConfigScopeProperty.RESOURCE);
manager.addConfigChangeListener(controller, ConfigScopeProperty.CONSTRAINT);
manager.addLiveInstanceChangeListener(controller);
manager.addIdealStateChangeListener(controller);
// no need for controller to listen on external-view
// manager.addExternalViewChangeListener(controller);
manager.addControllerListener(controller);
} catch (ZkInterruptedException e) {
logger
.warn("zk connection is interrupted during HelixManagerMain.addListenersToController(). "
+ e);
} catch (Exception e) {
logger.error("Error when creating HelixManagerContollerMonitor", e);
}
}
public static HelixManager startHelixController(final String zkConnectString,
final String clusterName, final String controllerName, final String controllerMode) {
HelixManager manager = null;
try {
if (controllerMode.equalsIgnoreCase(STANDALONE)) {
manager =
HelixManagerFactory.getZKHelixManager(clusterName, controllerName,
InstanceType.CONTROLLER, zkConnectString);
manager.connect();
} else if (controllerMode.equalsIgnoreCase(DISTRIBUTED)) {
manager =
HelixManagerFactory.getZKHelixManager(clusterName, controllerName,
InstanceType.CONTROLLER_PARTICIPANT, zkConnectString);
MultiClusterControllerTransitionHandlerFactory stateModelFactory =
new MultiClusterControllerTransitionHandlerFactory(zkConnectString);
StateMachineEngine stateMach = manager.getStateMachineEngine();
stateMach.registerStateModelFactory(StateModelDefId.LeaderStandby, stateModelFactory);
manager.connect();
} else {
logger.error("cluster controller mode:" + controllerMode + " NOT supported");
}
} catch (Exception e) {
logger.error("Exception while starting controller", e);
}
return manager;
}
public static void main(String[] args) throws Exception {
// read the config;
// check if the this process is the master wait indefinitely
// other approach is always process the events but when updating the zk
// check if this is master.
// This is difficult to get right
// get the clusters to manage
// for each cluster create a manager
// add the respective listeners for each manager
CommandLine cmd = processCommandLineArgs(args);
String zkConnectString = cmd.getOptionValue(zkServerAddress);
String clusterName = cmd.getOptionValue(cluster);
String controllerMode = STANDALONE;
String controllerName = null;
if (cmd.hasOption(mode)) {
controllerMode = cmd.getOptionValue(mode);
}
if (controllerMode.equalsIgnoreCase(DISTRIBUTED) && !cmd.hasOption(name)) {
throw new IllegalArgumentException(
"A unique cluster controller name is required in DISTRIBUTED mode");
}
controllerName = cmd.getOptionValue(name);
// Espresso_driver.py will consume this
logger.info("Cluster manager started, zkServer: " + zkConnectString + ", clusterName:"
+ clusterName + ", controllerName:" + controllerName + ", mode:" + controllerMode);
HelixManager manager =
startHelixController(zkConnectString, clusterName, controllerName, controllerMode);
Runtime.getRuntime().addShutdownHook(new HelixManagerShutdownHook(manager));
try {
Thread.currentThread().join();
} catch (InterruptedException e) {
logger.info("controller:" + controllerName + ", " + Thread.currentThread().getName()
+ " interrupted");
} finally {
manager.disconnect();
}
}
}