private void doShutdown(boolean force) {
long start = Clock.currentTimeMillis();
logger.finest("** we are being asked to shutdown when active = " + String.valueOf(active));
if (!force && isActive()) {
final int maxWaitSeconds = groupProperties.GRACEFUL_SHUTDOWN_MAX_WAIT.getInteger();
if (!partitionService.prepareToSafeShutdown(maxWaitSeconds, TimeUnit.SECONDS)) {
logger.warning(
"Graceful shutdown could not be completed in " + maxWaitSeconds + " seconds!");
}
}
if (isActive()) {
if (!force) {
clusterService.sendShutdownMessage();
}
// set the joined=false first so that
// threads do not process unnecessary
// events, such as remove address
joined.set(false);
setActive(false);
setMasterAddress(null);
try {
Runtime.getRuntime().removeShutdownHook(shutdownHookThread);
} catch (Throwable ignored) {
}
if (managementCenterService != null) {
managementCenterService.shutdown();
}
logger.finest("Shutting down client command service");
clientEngine.shutdown();
logger.finest("Shutting down node engine");
nodeEngine.shutdown();
if (multicastService != null) {
logger.finest("Shutting down multicast service");
multicastService.stop();
}
logger.finest("Shutting down connection manager");
connectionManager.shutdown();
textCommandService.stop();
masterAddress = null;
if (securityContext != null) {
securityContext.destroy();
}
initializer.destroy();
serializationService.destroy();
int numThreads = threadGroup.activeCount();
Thread[] threads = new Thread[numThreads * 2];
numThreads = threadGroup.enumerate(threads, false);
for (int i = 0; i < numThreads; i++) {
Thread thread = threads[i];
if (thread.isAlive()) {
logger.finest("Shutting down thread " + thread.getName());
thread.interrupt();
}
}
failedConnections.clear();
systemLogService.shutdown();
logger.info(
"Hazelcast Shutdown is completed in " + (Clock.currentTimeMillis() - start) + " ms.");
}
}
public void start() {
logger.finest(
"We are asked to start and completelyShutdown is " + String.valueOf(completelyShutdown));
if (completelyShutdown) return;
nodeEngine.start();
connectionManager.start();
if (config.getNetworkConfig().getJoin().getMulticastConfig().isEnabled()) {
final Thread multicastServiceThread =
new Thread(
hazelcastInstance.threadGroup,
multicastService,
getThreadNamePrefix("MulticastThread"));
multicastServiceThread.start();
}
setActive(true);
if (!completelyShutdown) {
logger.finest("Adding ShutdownHook");
Runtime.getRuntime().addShutdownHook(shutdownHookThread);
}
logger.finest("finished starting threads, calling join");
join();
int clusterSize = clusterService.getSize();
if (config.getNetworkConfig().isPortAutoIncrement()
&& address.getPort() >= config.getNetworkConfig().getPort() + clusterSize) {
StringBuilder sb = new StringBuilder("Config seed port is ");
sb.append(config.getNetworkConfig().getPort());
sb.append(" and cluster size is ");
sb.append(clusterSize);
sb.append(". Some of the ports seem occupied!");
logger.warning(sb.toString());
}
try {
managementCenterService = new ManagementCenterService(hazelcastInstance);
} catch (Exception e) {
logger.warning("ManagementCenterService could not be constructed!", e);
}
initializer.afterInitialize(this);
}
public Node(HazelcastInstanceImpl hazelcastInstance, Config config, NodeContext nodeContext) {
this.hazelcastInstance = hazelcastInstance;
this.threadGroup = hazelcastInstance.threadGroup;
this.config = config;
configClassLoader = config.getClassLoader();
this.groupProperties = new GroupProperties(config);
SerializationService ss;
try {
ss =
new SerializationServiceBuilder()
.setClassLoader(configClassLoader)
.setConfig(config.getSerializationConfig())
.setManagedContext(hazelcastInstance.managedContext)
.setHazelcastInstance(hazelcastInstance)
.build();
} catch (Exception e) {
throw ExceptionUtil.rethrow(e);
}
serializationService = (SerializationServiceImpl) ss;
systemLogService = new SystemLogService(groupProperties.SYSTEM_LOG_ENABLED.getBoolean());
final AddressPicker addressPicker = nodeContext.createAddressPicker(this);
try {
addressPicker.pickAddress();
} catch (Throwable e) {
throw ExceptionUtil.rethrow(e);
}
final ServerSocketChannel serverSocketChannel = addressPicker.getServerSocketChannel();
address = addressPicker.getPublicAddress();
localMember = new MemberImpl(address, true, UuidUtil.createMemberUuid(address));
String loggingType = groupProperties.LOGGING_TYPE.getString();
loggingService =
new LoggingServiceImpl(
systemLogService, config.getGroupConfig().getName(), loggingType, localMember);
logger = loggingService.getLogger(Node.class.getName());
initializer = NodeInitializerFactory.create(configClassLoader);
try {
initializer.beforeInitialize(this);
} catch (Throwable e) {
try {
serverSocketChannel.close();
} catch (Throwable ignored) {
}
throw ExceptionUtil.rethrow(e);
}
securityContext =
config.getSecurityConfig().isEnabled() ? initializer.getSecurityContext() : null;
nodeEngine = new NodeEngineImpl(this);
clientEngine = new ClientEngineImpl(this);
connectionManager = nodeContext.createConnectionManager(this, serverSocketChannel);
partitionService = new PartitionServiceImpl(this);
clusterService = new ClusterServiceImpl(this);
textCommandService = new TextCommandServiceImpl(this);
initializer.printNodeInfo(this);
buildNumber = initializer.getBuildNumber();
VersionCheck.check(this, initializer.getBuild(), initializer.getVersion());
JoinConfig join = config.getNetworkConfig().getJoin();
MulticastService mcService = null;
try {
if (join.getMulticastConfig().isEnabled()) {
MulticastConfig multicastConfig = join.getMulticastConfig();
MulticastSocket multicastSocket = new MulticastSocket(null);
multicastSocket.setReuseAddress(true);
// bind to receive interface
multicastSocket.bind(new InetSocketAddress(multicastConfig.getMulticastPort()));
multicastSocket.setTimeToLive(multicastConfig.getMulticastTimeToLive());
try {
// set the send interface
final Address bindAddress = addressPicker.getBindAddress();
// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4417033
// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6402758
if (!bindAddress.getInetAddress().isLoopbackAddress()) {
multicastSocket.setInterface(bindAddress.getInetAddress());
}
} catch (Exception e) {
logger.warning(e);
}
multicastSocket.setReceiveBufferSize(64 * 1024);
multicastSocket.setSendBufferSize(64 * 1024);
String multicastGroup = System.getProperty("hazelcast.multicast.group");
if (multicastGroup == null) {
multicastGroup = multicastConfig.getMulticastGroup();
}
multicastConfig.setMulticastGroup(multicastGroup);
multicastSocket.joinGroup(InetAddress.getByName(multicastGroup));
multicastSocket.setSoTimeout(1000);
mcService = new MulticastService(this, multicastSocket);
mcService.addMulticastListener(new NodeMulticastListener(this));
}
} catch (Exception e) {
logger.severe(e);
}
this.multicastService = mcService;
initializeListeners(config);
joiner = nodeContext.createJoiner(this);
}
