*/
package org.opendaylight.controller.blueprint;
+import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.lang.management.ManagementFactory;
+import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
import java.util.LinkedHashSet;
import java.util.List;
+import java.util.Map.Entry;
import java.util.Set;
+import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
+import javax.xml.parsers.ParserConfigurationException;
import org.apache.aries.blueprint.services.BlueprintExtenderService;
+import org.apache.aries.util.AriesFrameworkUtil;
+import org.opendaylight.controller.config.api.ConfigRegistry;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ModuleIdentifier;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.facade.xml.ConfigExecution;
+import org.opendaylight.controller.config.facade.xml.ConfigSubsystemFacade;
+import org.opendaylight.controller.config.facade.xml.ConfigSubsystemFacadeFactory;
+import org.opendaylight.controller.config.facade.xml.TestOption;
+import org.opendaylight.controller.config.facade.xml.mapping.config.Config;
+import org.opendaylight.controller.config.facade.xml.strategy.EditStrategyType;
+import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
+import org.opendaylight.controller.config.util.xml.DocumentedException;
+import org.opendaylight.controller.config.util.xml.XmlElement;
+import org.opendaylight.controller.config.util.xml.XmlMappingConstants;
+import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.blueprint.container.EventConstants;
+import org.osgi.service.event.Event;
+import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
/**
* Implementation of the BlueprintContainerRestartService.
*/
class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintContainerRestartService {
private static final Logger LOG = LoggerFactory.getLogger(BlueprintContainerRestartServiceImpl.class);
+ private static final String CONFIG_MODULE_NAMESPACE_PROP = "config-module-namespace";
+ private static final String CONFIG_MODULE_NAME_PROP = "config-module-name";
+ private static final String CONFIG_INSTANCE_NAME_PROP = "config-instance-name";
private final ExecutorService restartExecutor = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().
setDaemon(true).setNameFormat("BlueprintContainerRestartService").build());
private void restartContainerAndDependentsInternal(Bundle forBundle) {
// We use a LinkedHashSet to preserve insertion order as we walk the service usage hierarchy.
Set<Bundle> containerBundlesSet = new LinkedHashSet<>();
- findDependentContainersRecursively(forBundle, containerBundlesSet);
+ List<Entry<String, ModuleIdentifier>> configModules = new ArrayList<>();
+ findDependentContainersRecursively(forBundle, containerBundlesSet, configModules);
List<Bundle> containerBundles = new ArrayList<>(containerBundlesSet);
blueprintExtenderService.destroyContainer(bundle, blueprintExtenderService.getContainer(bundle));
}
+ // The blueprint containers are created asynchronously so we register a handler for blueprint events
+ // that are sent when a container is complete, successful or not. The CountDownLatch tells when all
+ // containers are complete. This is done to ensure all blueprint containers are finished before we
+ // restart config modules.
+ final CountDownLatch containerCreationComplete = new CountDownLatch(containerBundles.size());
+ ServiceRegistration<?> eventHandlerReg = registerEventHandler(forBundle.getBundleContext(), new EventHandler() {
+ @Override
+ public void handleEvent(Event event) {
+ LOG.debug("handleEvent {} for bundle {}", event.getTopic(), event.getProperty(EventConstants.BUNDLE));
+ if(containerBundles.contains(event.getProperty(EventConstants.BUNDLE))) {
+ containerCreationComplete.countDown();
+ }
+ }
+ });
+
// Restart the containers top-down starting with 'forBundle'.
for(Bundle bundle: containerBundles) {
List<Object> paths = BlueprintBundleTracker.findBlueprintPaths(bundle);
blueprintExtenderService.createContainer(bundle, paths);
}
+
+ try {
+ containerCreationComplete.await(5, TimeUnit.MINUTES);
+ } catch(InterruptedException e) {
+ LOG.debug("CountDownLatch await was interrupted - returning");
+ return;
+ }
+
+ AriesFrameworkUtil.safeUnregisterService(eventHandlerReg);
+
+ // Now restart any associated config system Modules.
+ restartConfigModules(forBundle.getBundleContext(), configModules);
+ }
+
+ private void restartConfigModules(BundleContext bundleContext, List<Entry<String, ModuleIdentifier>> configModules) {
+ if(configModules.isEmpty()) {
+ return;
+ }
+
+ ServiceReference<ConfigSubsystemFacadeFactory> configFacadeFactoryRef =
+ bundleContext.getServiceReference(ConfigSubsystemFacadeFactory.class);
+ if(configFacadeFactoryRef == null) {
+ LOG.debug("ConfigSubsystemFacadeFactory service reference not found");
+ return;
+ }
+
+ ConfigSubsystemFacadeFactory configFacadeFactory = bundleContext.getService(configFacadeFactoryRef);
+ if(configFacadeFactory == null) {
+ LOG.debug("ConfigSubsystemFacadeFactory service not found");
+ return;
+ }
+
+ ConfigSubsystemFacade configFacade = configFacadeFactory.createFacade("BlueprintContainerRestartService");
+ try {
+ restartConfigModules(configModules, configFacade);
+ } catch(Exception e) {
+ LOG.error("Error restarting config modules", e);
+ } finally {
+ configFacade.close();
+ bundleContext.ungetService(configFacadeFactoryRef);
+ }
+
+ }
+
+ private void restartConfigModules(List<Entry<String, ModuleIdentifier>> configModules,
+ ConfigSubsystemFacade configFacade) throws ParserConfigurationException, DocumentedException,
+ ValidationException, ConflictingVersionException {
+
+ Document document = XmlUtil.newDocument();
+ Element dataElement = XmlUtil.createElement(document, XmlMappingConstants.DATA_KEY, Optional.<String>absent());
+ Element modulesElement = XmlUtil.createElement(document, XmlMappingConstants.MODULES_KEY,
+ Optional.of(XmlMappingConstants.URN_OPENDAYLIGHT_PARAMS_XML_NS_YANG_CONTROLLER_CONFIG));
+ dataElement.appendChild(modulesElement);
+
+ Config configMapping = configFacade.getConfigMapping();
+
+ ConfigRegistry configRegistryClient = new ConfigRegistryJMXClient(ManagementFactory.getPlatformMBeanServer());
+ for(Entry<String, ModuleIdentifier> entry: configModules) {
+ String moduleNamespace = entry.getKey();
+ ModuleIdentifier moduleId = entry.getValue();
+ try {
+ ObjectName instanceON = configRegistryClient.lookupConfigBean(moduleId.getFactoryName(),
+ moduleId.getInstanceName());
+
+ LOG.debug("Found config module instance ObjectName: {}", instanceON);
+
+ Element moduleElement = configMapping.moduleToXml(moduleNamespace, moduleId.getFactoryName(),
+ moduleId.getInstanceName(), instanceON, document);
+ modulesElement.appendChild(moduleElement);
+ } catch(InstanceNotFoundException e) {
+ LOG.warn("Error looking up config module: namespace {}, module name {}, instance {}",
+ moduleNamespace, moduleId.getFactoryName(), moduleId.getInstanceName(), e);
+ }
+ }
+
+ if(LOG.isDebugEnabled()) {
+ LOG.debug("Pushing config xml: {}", XmlUtil.toString(dataElement));
+ }
+
+ ConfigExecution execution = new ConfigExecution(configMapping, XmlElement.fromDomElement(dataElement),
+ TestOption.testThenSet, EditStrategyType.recreate);
+ configFacade.executeConfigExecution(execution);
+ configFacade.commitSilentTransaction();
}
/**
* Recursively finds the services registered by the given bundle and the bundles using those services.
- * User bundles that have an associated blueprint container are added to containerBundles.
+ * User bundles that have an associated blueprint container are added to containerBundles. In addition,
+ * if a registered service has an associated config system Module, as determined via the presence of
+ * certain service properties, the ModuleIdentifier is added to the configModules list.
*
* @param bundle the bundle to traverse
* @param containerBundles the current set of bundles containing blueprint containers
*/
- private void findDependentContainersRecursively(Bundle bundle, Set<Bundle> containerBundles) {
+ private void findDependentContainersRecursively(Bundle bundle, Set<Bundle> containerBundles,
+ List<Entry<String, ModuleIdentifier>> configModules) {
if(!containerBundles.add(bundle)) {
// Already seen this bundle...
return;
ServiceReference<?>[] references = bundle.getRegisteredServices();
if (references != null) {
for (ServiceReference<?> reference : references) {
+ possiblyAddConfigModuleIdentifier(reference, configModules);
+
Bundle[] usingBundles = reference.getUsingBundles();
if(usingBundles != null) {
for(Bundle usingBundle: usingBundles) {
if(blueprintExtenderService.getContainer(usingBundle) != null) {
- findDependentContainersRecursively(usingBundle, containerBundles);
+ findDependentContainersRecursively(usingBundle, containerBundles, configModules);
}
}
}
}
}
+ private void possiblyAddConfigModuleIdentifier(ServiceReference<?> reference,
+ List<Entry<String, ModuleIdentifier>> configModules) {
+ Object moduleNamespace = reference.getProperty(CONFIG_MODULE_NAMESPACE_PROP);
+ if(moduleNamespace == null) {
+ return;
+ }
+
+ String moduleName = getRequiredConfigModuleProperty(CONFIG_MODULE_NAME_PROP, moduleNamespace,
+ reference);
+ String instanceName = getRequiredConfigModuleProperty(CONFIG_INSTANCE_NAME_PROP, moduleNamespace,
+ reference);
+ if(moduleName == null || instanceName == null) {
+ return;
+ }
+
+ LOG.debug("Found service with config module: namespace {}, module name {}, instance {}",
+ moduleNamespace, moduleName, instanceName);
+
+ configModules.add(new SimpleEntry<>(moduleNamespace.toString(),
+ new ModuleIdentifier(moduleName, instanceName)));
+ }
+
+ @Nullable
+ private String getRequiredConfigModuleProperty(String propName, Object moduleNamespace,
+ ServiceReference<?> reference) {
+ Object value = reference.getProperty(propName);
+ if(value == null) {
+ LOG.warn("OSGi service with {} property is missing property {} therefore the config module can't be restarted",
+ CONFIG_MODULE_NAMESPACE_PROP, propName);
+ return null;
+ }
+
+ return value.toString();
+ }
+
+ private ServiceRegistration<?> registerEventHandler(BundleContext bundleContext, EventHandler handler) {
+ Dictionary<String, Object> props = new Hashtable<>();
+ props.put(org.osgi.service.event.EventConstants.EVENT_TOPIC,
+ new String[]{EventConstants.TOPIC_CREATED, EventConstants.TOPIC_FAILURE});
+ return bundleContext.registerService(EventHandler.class.getName(), handler, props);
+ }
+
@Override
public void close() {
restartExecutor.shutdownNow();