in hazelcast/src/main/java/org/apache/karaf/cellar/hazelcast/internal/osgi/Activator.java [104:345]
public void doStart() throws Exception {
ConfigurationAdmin configurationAdmin = getTrackedService(ConfigurationAdmin.class);
if (configurationAdmin == null)
return;
EventHandlerRegistry eventHandlerRegistry = getTrackedService(EventHandlerRegistry.class);
if (eventHandlerRegistry == null)
return;
ProxyManager proxyManager = getTrackedService(ProxyManager.class);
if (proxyManager == null)
return;
LOGGER.debug("CELLAR HAZELCAST: init combined class loader");
combinedClassLoader = new CombinedClassLoader();
combinedClassLoader.init();
LOGGER.debug("CELLAR HAZELCAST: start the discovery service tracker");
discoveryServiceTracker = new ServiceTracker<DiscoveryService, DiscoveryService>(bundleContext, DiscoveryService.class, new ServiceTrackerCustomizer<DiscoveryService, DiscoveryService>() {
@Override
public DiscoveryService addingService(ServiceReference<DiscoveryService> serviceReference) {
DiscoveryService service = bundleContext.getService(serviceReference);
discoveryServices.add(service);
return service;
}
@Override
public void modifiedService(ServiceReference<DiscoveryService> serviceReference, DiscoveryService discoveryService) {
// nothing to do
}
@Override
public void removedService(ServiceReference<DiscoveryService> serviceReference, DiscoveryService discoveryService) {
discoveryServices.remove(discoveryService);
bundleContext.ungetService(serviceReference);
}
});
discoveryServiceTracker.open();
LOGGER.debug("CELLAR HAZELCAST: init Cellar extender");
extender = new CellarExtender();
extender.setCombinedClassLoader(combinedClassLoader);
extender.setBundleContext(bundleContext);
extender.init();
LOGGER.debug("CELLAR HAZELCAST: init dispatcher");
dispatcher = new EventHandlerRegistryDispatcher();
dispatcher.setHandlerRegistry(eventHandlerRegistry);
dispatcher.init();
LOGGER.debug("CELLAR HAZELCAST: create Hazelcast configuration manager");
HazelcastConfigurationManager hazelcastConfigurationManager = new HazelcastConfigurationManager();
hazelcastConfigurationManager.setDiscoveryServices(discoveryServices);
LOGGER.debug("CELLAR HAZELCAST: init Hazelcast service factory");
hazelcastServiceFactory = new HazelcastServiceFactory();
hazelcastServiceFactory.setCombinedClassLoader(combinedClassLoader);
hazelcastServiceFactory.setConfigurationManager(hazelcastConfigurationManager);
hazelcastServiceFactory.setBundleContext(bundleContext);
hazelcastServiceFactory.init();
if (updatedConfig != null) {
// we have outstanding configuration update: do it now
updated(updatedConfig);
updatedConfig = null;
}
LOGGER.debug("CELLAR HAZELCAST: register Hazelcast instance");
hazelcastInstance = hazelcastServiceFactory.getInstance();
register(HazelcastInstance.class, hazelcastInstance);
LOGGER.debug("CELLAR HAZELCAST: init discovery task");
discoveryTask = new DiscoveryTask();
discoveryTask.setDiscoveryServices(discoveryServices);
discoveryTask.setConfigurationAdmin(configurationAdmin);
discoveryTask.init();
LOGGER.debug("CELLAR HAZELCAST: register Hazelcast cluster manager");
HazelcastClusterManager clusterManager = new HazelcastClusterManager();
clusterManager.setInstance(hazelcastInstance);
clusterManager.setConfigurationAdmin(configurationAdmin);
clusterManager.setCombinedClassLoader(combinedClassLoader);
register(ClusterManager.class, clusterManager);
LOGGER.debug("CELLAR HAZELCAST: create Hazelcast event transport factory");
HazelcastEventTransportFactory eventTransportFactory = new HazelcastEventTransportFactory();
eventTransportFactory.setCombinedClassLoader(combinedClassLoader);
eventTransportFactory.setConfigurationAdmin(configurationAdmin);
eventTransportFactory.setInstance(hazelcastInstance);
eventTransportFactory.setDispatcher(dispatcher);
register(EventTransportFactory.class, eventTransportFactory);
LOGGER.debug("CELLAR HAZELCAST: init Hazelcast group manager");
groupManager = new HazelcastGroupManager();
groupManager.setInstance(hazelcastInstance);
groupManager.setCombinedClassLoader(combinedClassLoader);
groupManager.setBundleContext(bundleContext);
groupManager.setConfigurationAdmin(configurationAdmin);
groupManager.setEventTransportFactory(eventTransportFactory);
groupManager.init();
register(new Class[]{GroupManager.class, SynchronousConfigurationListener.class}, groupManager);
LOGGER.debug("CELLAR HAZELCAST: create Cellar membership listener");
CellarMembershipListener membershipListener = new CellarMembershipListener(hazelcastInstance);
membershipListener.setSynchronizers(synchronizers);
membershipListener.setGroupManager(groupManager);
Node node = clusterManager.getNode();
LOGGER.debug("CELLAR HAZELCAST: init topic consumer");
consumer = new TopicConsumer();
consumer.setInstance(hazelcastInstance);
consumer.setDispatcher(dispatcher);
consumer.setNode(node);
consumer.setConfigurationAdmin(configurationAdmin);
consumer.init();
LOGGER.debug("CELLAR HAZELCAST: init topic producer");
producer = new TopicProducer();
producer.setInstance(hazelcastInstance);
producer.setNode(node);
producer.setConfigurationAdmin(configurationAdmin);
producer.init();
register(EventProducer.class, producer);
LOGGER.debug("CELLAR HAZELCAST: register basic command store");
CommandStore commandStore = new BasicCommandStore();
register(CommandStore.class, commandStore);
LOGGER.debug("CELLAR HAZELCAST: register clustered execution context");
ClusteredExecutionContext executionContext = new ClusteredExecutionContext();
executionContext.setProducer(producer);
executionContext.setCommandStore(commandStore);
register(ExecutionContext.class, executionContext);
LOGGER.debug("CELLAR HAZELCAST: register producer switch command handler");
ProducerSwitchCommandHandler producerSwitchCommandHandler = new ProducerSwitchCommandHandler();
producerSwitchCommandHandler.setProducer(producer);
producerSwitchCommandHandler.setConfigurationAdmin(configurationAdmin);
register(EventHandler.class, producerSwitchCommandHandler);
LOGGER.debug("CELLAR HAZELCAST: register producer switch result handler");
ProducerSwitchResultHandler producerSwitchResultHandler = new ProducerSwitchResultHandler();
producerSwitchResultHandler.setCommandStore(commandStore);
register(EventHandler.class, producerSwitchResultHandler);
LOGGER.debug("CELLAR HAZELCAST: register consumer switch command handler");
ConsumerSwitchCommandHandler consumerSwitchCommandHandler = new ConsumerSwitchCommandHandler();
consumerSwitchCommandHandler.setProducer(producer);
consumerSwitchCommandHandler.setConsumer(consumer);
consumerSwitchCommandHandler.setConfigurationAdmin(configurationAdmin);
register(EventHandler.class, consumerSwitchCommandHandler);
LOGGER.debug("CELLAR HAZELCAST; register consumer switch result handler");
ConsumerSwitchResultHandler consumerSwitchResultHandler = new ConsumerSwitchResultHandler();
consumerSwitchResultHandler.setCommandStore(commandStore);
register(EventHandler.class, consumerSwitchResultHandler);
LOGGER.debug("CELLAR HAZELCAST: register manage handlers command handler");
ManageHandlersCommandHandler manageHandlersCommandHandler = new ManageHandlersCommandHandler();
manageHandlersCommandHandler.setConfigurationAdmin(configurationAdmin);
manageHandlersCommandHandler.setProducer(producer);
manageHandlersCommandHandler.setProxyManager(proxyManager);
register(EventHandler.class, manageHandlersCommandHandler);
LOGGER.debug("CELLAR HAZELCAST: register manage handlers result handler");
ManageHandlersResultHandler manageHandlersResultHandler = new ManageHandlersResultHandler();
manageHandlersResultHandler.setCommandStore(commandStore);
register(EventHandler.class, manageHandlersResultHandler);
LOGGER.debug("CELLAR HAZELCAST: register manage group command handler");
ManageGroupCommandHandler manageGroupCommandHandler = new ManageGroupCommandHandler();
manageGroupCommandHandler.setProducer(producer);
manageGroupCommandHandler.setClusterManager(clusterManager);
manageGroupCommandHandler.setGroupManager(groupManager);
register(EventHandler.class, manageGroupCommandHandler);
LOGGER.debug("CELLAR HAZELCAST: register manage group result handler");
ManageGroupResultHandler manageGroupResultHandler = new ManageGroupResultHandler();
manageGroupResultHandler.setCommandStore(commandStore);
register(EventHandler.class, manageGroupResultHandler);
LOGGER.debug("CELLAR HAZELCAST: register shutdown command handler");
ShutdownCommandHandler shutdownCommandHandler = new ShutdownCommandHandler();
shutdownCommandHandler.setBundleContext(bundleContext);
shutdownCommandHandler.setProducer(producer);
shutdownCommandHandler.setClusterManager(clusterManager);
shutdownCommandHandler.setGroupManager(groupManager);
register(EventHandler.class, shutdownCommandHandler);
LOGGER.debug("CELLAR HAZELCAST: register shutdown command result handler");
ShutdownResultHandler shutdownResultHandler = new ShutdownResultHandler();
shutdownResultHandler.setCommandStore(commandStore);
register(EventHandler.class, shutdownCommandHandler);
LOGGER.debug("CELLAR HAZELCAST: start the synchronizer service tracker");
synchronizerServiceTracker = new ServiceTracker<Synchronizer, Synchronizer>(bundleContext, Synchronizer.class, new ServiceTrackerCustomizer<Synchronizer, Synchronizer>() {
@Override
public Synchronizer addingService(ServiceReference<Synchronizer> serviceReference) {
Synchronizer service = bundleContext.getService(serviceReference);
synchronizers.add(service);
return service;
}
@Override
public void modifiedService(ServiceReference<Synchronizer> serviceReference, Synchronizer synchronizer) {
// nothing to do
}
@Override
public void removedService(ServiceReference<Synchronizer> serviceReference, Synchronizer synchronizer) {
synchronizers.remove(synchronizer);
bundleContext.ungetService(serviceReference);
}
});
synchronizerServiceTracker.open();
LOGGER.debug("CELLAR HAZELCAST: register Cellar Core MBean");
CellarMBeanImpl cellarMBean = new CellarMBeanImpl();
cellarMBean.setBundleContext(bundleContext);
cellarMBean.setClusterManager(clusterManager);
cellarMBean.setGroupManager(groupManager);
cellarMBean.setExecutionContext(executionContext);
Hashtable props = new Hashtable();
props.put("jmx.objectname", "org.apache.karaf.cellar:type=core,name=" + System.getProperty("karaf.name"));
coreMBeanRegistration = bundleContext.registerService(getInterfaceNames(cellarMBean), cellarMBean, props);
LOGGER.debug("CELLAR HAZELCAST: register Cellar Node MBean");
CellarNodeMBeanImpl cellarNodeMBean = new CellarNodeMBeanImpl();
cellarNodeMBean.setClusterManager(clusterManager);
cellarNodeMBean.setExecutionContext(executionContext);
props = new Hashtable();
props.put("jmx.objectname", "org.apache.karaf.cellar:type=node,name=" + System.getProperty("karaf.name"));
nodeMBeanRegistration = bundleContext.registerService(getInterfaceNames(cellarNodeMBean), cellarNodeMBean, props);
LOGGER.debug("CELLAR HAZELCAST: register Cellar Group MBean");
CellarGroupMBeanImpl cellarGroupMBean = new CellarGroupMBeanImpl();
cellarGroupMBean.setClusterManager(clusterManager);
cellarGroupMBean.setExecutionContext(executionContext);
cellarGroupMBean.setGroupManager(groupManager);
props = new Hashtable();
props.put("jmx.objectname", "org.apache.karaf.cellar:type=group,name=" + System.getProperty("karaf.name"));
groupMBeanRegistration = bundleContext.registerService(getInterfaceNames(cellarGroupMBean), cellarGroupMBean, props);
}