/*******************************************************************************
* Copyright (c)2010 REMAIN B.V. The Netherlands. (http://www.remainsoftware.com).
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Wim Jongman - initial API and implementation
* Ahmed Aadel - initial API and implementation
*******************************************************************************/
package org.eclipse.ecf.provider.zookeeper.core;
import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.apache.zookeeper.server.NIOServerCnxn;
import org.apache.zookeeper.server.NIOServerCnxn.Factory;
import org.apache.zookeeper.server.PurgeTxnLog;
import org.apache.zookeeper.server.ServerConfig;
import org.apache.zookeeper.server.ZooKeeperServer;
import org.apache.zookeeper.server.persistence.FileTxnSnapLog;
import org.apache.zookeeper.server.quorum.QuorumPeer;
import org.apache.zookeeper.server.quorum.QuorumPeerConfig;
import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter;
import org.eclipse.ecf.discovery.IServiceInfo;
import org.eclipse.ecf.discovery.IServiceListener;
import org.eclipse.ecf.discovery.IServiceTypeListener;
import org.eclipse.ecf.discovery.identity.IServiceID;
import org.eclipse.ecf.discovery.identity.IServiceTypeID;
import org.eclipse.ecf.provider.zookeeper.core.internal.Advertiser;
import org.eclipse.ecf.provider.zookeeper.core.internal.Configuration;
import org.eclipse.ecf.provider.zookeeper.core.internal.Configurator;
import org.eclipse.ecf.provider.zookeeper.core.internal.Localizer;
import org.eclipse.ecf.provider.zookeeper.core.internal.Notification;
import org.eclipse.ecf.provider.zookeeper.node.internal.WatchManager;
import org.eclipse.ecf.provider.zookeeper.util.Geo;
import org.eclipse.ecf.provider.zookeeper.util.Logger;
import org.eclipse.ecf.provider.zookeeper.util.PrettyPrinter;
import org.osgi.framework.ServiceReference;
import org.osgi.service.log.LogService;
public class ZooDiscoveryContainer extends AbstractDiscoveryContainerAdapter {
private static ZooDiscoveryContainer discovery;
public static ExecutorService CACHED_THREAD_POOL = Executors.newCachedThreadPool();
private QuorumPeer quorumPeer;
private Properties DiscoveryProperties;
protected Advertiser advertiser;
protected Localizer localizer;
private static ZooKeeperServer zooKeeperServer;
private ID targetId;
protected boolean isQuorumPeerReady;
private boolean isConnected;
private boolean isDisposed;
private WatchManager watchManager;
public enum FLAVOR {
STANDALONE, CENTRALIZED, REPLICATED;
public String toString() {
switch (this) {
case STANDALONE:
return DefaultDiscoveryConfig.ZOODISCOVERY_FLAVOR_STANDALONE;
case CENTRALIZED:
return DefaultDiscoveryConfig.ZOODISCOVERY_FLAVOR_CENTRALIZED;
case REPLICATED:
return DefaultDiscoveryConfig.ZOODISCOVERY_FLAVOR_REPLICATED;
}
throw new AssertionError("Unsupported configuration");
}
}
private ZooDiscoveryContainer() {
super(ZooDiscoveryNamespace.NAME, Configurator.INSTANCE);
DiscoveryProperties = new Properties();
if (autoStart()) {
try {
this.targetId = this.getConnectNamespace().createInstance(new String[] { DefaultDiscoveryConfig.getDefaultTarget() });
init(targetId);
} catch (Exception e) {
Logger.log(LogService.LOG_ERROR, e.getMessage(), e);
}
}
Logger.log(LogService.LOG_INFO, PrettyPrinter.prompt(PrettyPrinter.ACTIVATED, null), null);
}
/**
* @return true if the service is in autoStart mode.
*/
public static boolean autoStart() {
return System.getProperty(DefaultDiscoveryConfig.ZOODISCOVERY_PREFIX + DefaultDiscoveryConfig.ZOOKEEPER_AUTOSTART) != null;
}
public synchronized static ZooDiscoveryContainer getSingleton() {
if (discovery == null) {
discovery = new ZooDiscoveryContainer();
}
discovery.setDisposed(false);
return discovery;
}
public void init(ServiceReference reference) {
Configuration conf = Configurator.INSTANCE.createConfig(reference).configure();
doStart(conf);
}
private void init(ID targetID) {
Configuration conf = Configurator.INSTANCE.createConfig(targetID).configure();
doStart(conf);
}
private void doStart(final Configuration conf) {
if (watchManager != null && !watchManager.isDisposed())
return;
watchManager = new WatchManager(conf);
this.advertiser = Advertiser.getSingleton(watchManager);
this.localizer = Localizer.getSingleton();
if (conf.isCentralized()) {
if (Geo.getHost().equals(conf.getServerIps().split(":")[0])) { //$NON-NLS-1$
CACHED_THREAD_POOL.execute(new Runnable() {
public void run() {
startStandAlone(conf);
watchManager.watch();
ZooDiscoveryContainer.this.localizer.init();
}
});
} else {
watchManager.watch();
this.localizer.init();
}
} else if (conf.isQuorum()) {
CACHED_THREAD_POOL.execute(new Runnable() {
public void run() {
startQuorumPeer(conf);
watchManager.watch();
ZooDiscoveryContainer.this.localizer.init();
}
});
}
else if (conf.isStandAlone()) {
CACHED_THREAD_POOL.execute(new Runnable() {
public void run() {
startStandAlone(conf);
watchManager.watch();
ZooDiscoveryContainer.this.localizer.init();
}
});
}
}
/**
* Start a ZooKeeer server locally to write nodes to. Implied by
* {@link IDiscoveryConfig#ZOODISCOVERY_FLAVOR_STANDALONE} configuration.
*
* @param conf
*/
void startStandAlone(final Configuration conf) {
if (ZooDiscoveryContainer.zooKeeperServer != null && ZooDiscoveryContainer.zooKeeperServer.isRunning())
return;
else if (ZooDiscoveryContainer.zooKeeperServer != null && !ZooDiscoveryContainer.zooKeeperServer.isRunning())
try {
ZooDiscoveryContainer.zooKeeperServer.startup();
return;
} catch (Exception e) {
Logger.log(LogService.LOG_DEBUG, "Zookeeper server cannot be started! ", e);//$NON-NLS-1$
}
try {
ZooDiscoveryContainer.zooKeeperServer = new ZooKeeperServer();
FileTxnSnapLog fileTxnSnapLog = new FileTxnSnapLog(conf.getZookeeperDataFile(), conf.getZookeeperDataFile());
ZooDiscoveryContainer.zooKeeperServer.setTxnLogFactory(fileTxnSnapLog);
ZooDiscoveryContainer.zooKeeperServer.setTickTime(conf.getTickTime());
Factory cnxnFactory = new NIOServerCnxn.Factory(new InetSocketAddress(conf.getClientPort()));
cnxnFactory.startup(ZooDiscoveryContainer.zooKeeperServer);
} catch (Exception e) {
Logger.log(LogService.LOG_ERROR,
"Zookeeper server cannot be started! Possibly another instance is already running on the same port. ", e);
}
}
/**
* Start a local ZooKeeer server to write nodes to. It plays as a peer
* within a replicated servers configuration. Implied by
* {@link IDiscoveryConfig#ZOODISCOVERY_FLAVOR_REPLICATED} configuration.
*
* @param conf
*/
void startQuorumPeer(final Configuration conf) {
if (this.quorumPeer != null && this.quorumPeer.isAlive()) {
return;
} else if (this.quorumPeer != null && !this.quorumPeer.isAlive()) {
this.quorumPeer.start();
return;
}
try {
final QuorumPeerConfig quorumPeerConfig = new QuorumPeerConfig();
quorumPeerConfig.parse(conf.getConfFile());
QuorumPeer.Factory qpFactory = new QuorumPeer.Factory() {
public QuorumPeer create(NIOServerCnxn.Factory cnxnFactory) throws IOException {
ServerConfig serverConfig = new ServerConfig();
serverConfig.readFrom(quorumPeerConfig);
QuorumPeer peer = new QuorumPeer(quorumPeerConfig.getServers(), new File(serverConfig.getDataDir()), new File(
serverConfig.getDataLogDir()), quorumPeerConfig.getElectionAlg(), quorumPeerConfig.getServerId(),
quorumPeerConfig.getTickTime(), quorumPeerConfig.getInitLimit(), quorumPeerConfig.getSyncLimit(), cnxnFactory,
quorumPeerConfig.getQuorumVerifier());
ZooDiscoveryContainer.this.quorumPeer = peer;
return peer;
}
public NIOServerCnxn.Factory createConnectionFactory() throws IOException {
return new NIOServerCnxn.Factory(quorumPeerConfig.getClientPortAddress());
}
};
quorumPeer = qpFactory.create(qpFactory.createConnectionFactory());
quorumPeer.start();
quorumPeer.setDaemon(true);
isQuorumPeerReady = true;
} catch (Exception e) {
Logger.log(LogService.LOG_ERROR, "Zookeeper quorum cannot be started! ", e); //$NON-NLS-1$
isQuorumPeerReady = false;
}
}
public void setDiscoveryProperties(Properties discoveryProperties) {
this.DiscoveryProperties = discoveryProperties;
}
public Properties getDiscoveryProperties() {
return this.DiscoveryProperties;
}
public synchronized void shutdown() {
if (isDisposed)
return;
try {
if (watchManager != null) {
watchManager.dispose();
}
if (this.localizer != null) {
this.localizer.close();
}
if (ZooDiscoveryContainer.zooKeeperServer != null) {
// purge snaps and logs. Keep only last three of each
PurgeTxnLog.purge(ZooDiscoveryContainer.zooKeeperServer.getTxnLogFactory().getDataDir(), ZooDiscoveryContainer.zooKeeperServer.getTxnLogFactory()
.getSnapDir(), 3);
ZooDiscoveryContainer.zooKeeperServer.shutdown();
}
if (this.quorumPeer != null) {
// purge snaps and logs. Keep only last three of each
PurgeTxnLog.purge(this.quorumPeer.getTxnFactory().getDataDir(), this.quorumPeer.getTxnFactory().getSnapDir(), 3);
// shut down server
if (this.quorumPeer.isAlive()) {
this.quorumPeer.shutdown();
}
// shutdown sockets
this.quorumPeer.getCnxnFactory().shutdown();
}
} catch (Throwable t) {
Logger.log(LogService.LOG_ERROR, t.getMessage(), t);
}
targetId = null;
isConnected = false;
isDisposed = true;
discovery = null;
}
public ZooKeeperServer getLocalServer() {
return ZooDiscoveryContainer.zooKeeperServer;
}
public void connect(ID id, IConnectContext connectContext) throws ContainerConnectException {
if (isDisposed)
throw new ContainerConnectException("Container already disposed!");
if (this.isConnected)
throw new ContainerConnectException("Container already connected!");
this.targetId = id;
if (this.targetId == null) {
this.targetId = this.getConnectNamespace().createInstance(new String[] { DefaultDiscoveryConfig.getDefaultTarget() });
}
init(this.targetId);
isConnected = true;
}
public void disconnect() {
if (watchManager != null) {
watchManager.dispose();
}
isConnected = false;
targetId = null;
}
public Namespace getConnectNamespace() {
return super.getConnectNamespace();
}
public ID getConnectedID() {
if (!isConnected || isDisposed)
return null;
return this.targetId;
}
public IServiceInfo getServiceInfo(IServiceID serviceID) {
Assert.isNotNull(serviceID);
return watchManager.getAllKnownServices().get(serviceID.getName());
}
public IServiceTypeID[] getServiceTypes() {
IServiceTypeID ids[] = new IServiceTypeID[getServices().length];
for (int i = 0; i < ids.length; i++) {
ids[i] = getServices()[i].getServiceID().getServiceTypeID();
}
return ids;
}
public IServiceInfo[] getServices() {
if (watchManager == null) {
return new IServiceInfo[0];
}
return watchManager.getAllKnownServices().values().toArray(new IServiceInfo[watchManager.getAllKnownServices().size()]);
}
public IServiceInfo[] getServices(IServiceTypeID type) {
Assert.isNotNull(type);
if (watchManager == null) {
return new IServiceInfo[0];
}
List<IServiceInfo> services = new ArrayList<IServiceInfo>();
for (IServiceInfo sinfo : watchManager.getAllKnownServices().values()) {
if (sinfo.getServiceID().getServiceTypeID().getInternal() == type.getInternal())
services.add(sinfo);
}
return services.toArray(new IServiceInfo[services.size()]);
}
public Namespace getServicesNamespace() {
return super.getServicesNamespace();
}
public synchronized void registerService(IServiceInfo serviceInfo) {
Assert.isNotNull(serviceInfo);
if (targetId == null) {
this.targetId = this.getConnectNamespace().createInstance(new String[] { DefaultDiscoveryConfig.getDefaultTarget() });
init(this.targetId);
}
if (serviceInfo instanceof AdvertisedService) {
watchManager.publish((AdvertisedService) serviceInfo);
} else {
watchManager.publish(new AdvertisedService(serviceInfo));
}
Localizer.getSingleton().localize(new Notification(serviceInfo, Notification.AVAILABLE));
}
public void unregisterAllServices() {
watchManager.unpublishAll();
}
public void unregisterService(IServiceInfo serviceInfo) {
Assert.isNotNull(serviceInfo);
watchManager.unpublish(serviceInfo.getServiceID().getName());
Localizer.getSingleton().localize(new Notification(serviceInfo, Notification.UNAVAILABLE));
}
public Collection<IServiceListener> getAllServiceListeners() {
return super.allServiceListeners;
}
public Collection<IServiceListener> getServiceListenersForType(IServiceTypeID type) {
return super.getListeners(type);
}
public Collection<IServiceTypeListener> getServiceTypeListeners() {
return super.serviceTypeListeners;
}
public void dispose() {
shutdown();
super.dispose();
}
public ID getID() {
return Configurator.INSTANCE.getID();
}
public boolean isDisposed() {
return this.isDisposed;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#getContainerName
* ()
*/
public String getContainerName() {
return ZooDiscoveryContainerInstantiator.NAME;
}
private void setDisposed(boolean d) {
this.isDisposed = d;
}
}