X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fblueprint%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fblueprint%2FBlueprintContainerRestartServiceImpl.java;h=f3010a41387d21d4765b33309b9c45713270c7c1;hp=6a464b75d03533eea7a992e45439d8771af2df92;hb=a0d14235087d6b2c3cac747ca26c42b15d902dcd;hpb=67ff0fc78b2933b8b4f5a8544c7639499824e622 diff --git a/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/BlueprintContainerRestartServiceImpl.java b/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/BlueprintContainerRestartServiceImpl.java index 6a464b75d0..f3010a4138 100644 --- a/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/BlueprintContainerRestartServiceImpl.java +++ b/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/BlueprintContainerRestartServiceImpl.java @@ -8,11 +8,16 @@ package org.opendaylight.controller.blueprint; import com.google.common.base.Optional; +import com.google.common.base.Preconditions; 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.ArrayDeque; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Deque; import java.util.Dictionary; import java.util.Hashtable; import java.util.LinkedHashSet; @@ -28,6 +33,7 @@ import javax.management.InstanceNotFoundException; import javax.management.ObjectName; import javax.xml.parsers.ParserConfigurationException; import org.apache.aries.blueprint.services.BlueprintExtenderService; +import org.apache.aries.quiesce.participant.QuiesceParticipant; import org.apache.aries.util.AriesFrameworkUtil; import org.opendaylight.controller.config.api.ConfigRegistry; import org.opendaylight.controller.config.api.ConflictingVersionException; @@ -62,18 +68,25 @@ import org.w3c.dom.Element; */ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintContainerRestartService { private static final Logger LOG = LoggerFactory.getLogger(BlueprintContainerRestartServiceImpl.class); + private static final int CONTAINER_CREATE_TIMEOUT_IN_MINUTES = 5; 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 final BlueprintExtenderService blueprintExtenderService; - BlueprintContainerRestartServiceImpl(BlueprintExtenderService blueprintExtenderService) { + private BlueprintExtenderService blueprintExtenderService; + private QuiesceParticipant quiesceParticipant; + + void setBlueprintExtenderService(final BlueprintExtenderService blueprintExtenderService) { this.blueprintExtenderService = blueprintExtenderService; } + void setQuiesceParticipant(final QuiesceParticipant quiesceParticipant) { + this.quiesceParticipant = quiesceParticipant; + } + public void restartContainer(final Bundle bundle, final List paths) { if (restartExecutor.isShutdown()) { return; @@ -99,6 +112,9 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo } private void restartContainerAndDependentsInternal(Bundle forBundle) { + Preconditions.checkNotNull(blueprintExtenderService); + Preconditions.checkNotNull(quiesceParticipant); + // We use a LinkedHashSet to preserve insertion order as we walk the service usage hierarchy. Set containerBundlesSet = new LinkedHashSet<>(); List> configModules = new ArrayList<>(); @@ -109,11 +125,6 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo LOG.info("Restarting blueprint containers for bundle {} and its dependent bundles {}", forBundle, containerBundles.subList(1, containerBundles.size())); - // Destroy the containers in reverse order with 'forBundle' last, ie bottom-up in the service tree. - for (Bundle bundle: Lists.reverse(containerBundles)) { - 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 @@ -126,17 +137,19 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo } }); - // Restart the containers top-down starting with 'forBundle'. - for (Bundle bundle: containerBundles) { - List paths = BlueprintBundleTracker.findBlueprintPaths(bundle); + final Runnable createContainerCallback = () -> createContainers(containerBundles); - LOG.info("Restarting blueprint container for bundle {} with paths {}", bundle, paths); + // Destroy the container down-top recursively and once done, restart the container top-down + destroyContainers(new ArrayDeque<>(Lists.reverse(containerBundles)), createContainerCallback); - blueprintExtenderService.createContainer(bundle, paths); - } try { - containerCreationComplete.await(5, TimeUnit.MINUTES); + if (!containerCreationComplete.await(CONTAINER_CREATE_TIMEOUT_IN_MINUTES, TimeUnit.MINUTES)) { + LOG.warn("Failed to restart all blueprint containers within {} minutes. Attempted to restart {} {} " + + "but only {} completed restart", CONTAINER_CREATE_TIMEOUT_IN_MINUTES, containerBundles.size(), + containerBundles, containerBundles.size() - containerCreationComplete.getCount()); + return; + } } catch (InterruptedException e) { LOG.debug("CountDownLatch await was interrupted - returning"); return; @@ -148,6 +161,62 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo restartConfigModules(forBundle.getBundleContext(), configModules); } + /** + * Recursively quiesce and destroy the bundles one by one in order to maintain synchronicity and ordering. + * @param remainingBundlesToDestroy the list of remaining bundles to destroy. + * @param createContainerCallback a {@link Runnable} to {@code run()} when the recursive function is completed. + */ + private void destroyContainers(final Deque remainingBundlesToDestroy, + final Runnable createContainerCallback) { + + final Bundle nextBundle; + synchronized (remainingBundlesToDestroy) { + if (remainingBundlesToDestroy.isEmpty()) { + LOG.debug("All blueprint containers were quiesced and destroyed"); + createContainerCallback.run(); + return; + } + + nextBundle = remainingBundlesToDestroy.poll(); + } + + // The Quiesce capability is a like a soft-stop, clean-stop. In the case of the Blueprint extender, in flight + // service calls are allowed to finish; they're counted in and counted out, and no new calls are allowed. When + // there are no in flight service calls, the bundle is told to stop. The Blueprint bundle itself doesn't know + // this is happening which is a key design point. In the case of Blueprint, the extender ensures no new Entity + // Managers(EMs) are created. Then when all those EMs are closed the quiesce operation reports that it is + // finished. + // To properly restart the blueprint containers, first we have to quiesce the list of bundles, and once done, it + // is safe to destroy their BlueprintContainer, so no reference is retained. + // + // Mail - thread explaining Quiesce API: + // https://www.mail-archive.com/dev@aries.apache.org/msg08403.html + + // Quiesced the bundle to unregister the associated BlueprintContainer + quiesceParticipant.quiesce(bundlesQuiesced -> { + + // Destroy the container once Quiesced + Arrays.stream(bundlesQuiesced).forEach(quiescedBundle -> { + LOG.debug("Quiesced bundle {}", quiescedBundle); + blueprintExtenderService.destroyContainer( + quiescedBundle, blueprintExtenderService.getContainer(quiescedBundle)); + }); + + destroyContainers(remainingBundlesToDestroy, createContainerCallback); + + }, Collections.singletonList(nextBundle)); + } + + private void createContainers(List containerBundles) { + containerBundles.forEach(bundle -> { + List paths = BlueprintBundleTracker.findBlueprintPaths(bundle); + + LOG.info("Restarting blueprint container for bundle {} with paths {}", bundle, paths); + + blueprintExtenderService.createContainer(bundle, paths); + }); + } + private void restartConfigModules(BundleContext bundleContext, List> configModules) { if (configModules.isEmpty()) { @@ -167,14 +236,13 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo return; } - ConfigSubsystemFacade configFacade = configFacadeFactory.createFacade("BlueprintContainerRestartService"); - try { + try (ConfigSubsystemFacade configFacade = configFacadeFactory.createFacade( + "BlueprintContainerRestartService")) { restartConfigModules(configModules, configFacade); } catch (ParserConfigurationException | DocumentedException | ValidationException | ConflictingVersionException e) { LOG.error("Error restarting config modules", e); } finally { - configFacade.close(); bundleContext.ungetService(configFacadeFactoryRef); } @@ -193,7 +261,7 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo Config configMapping = configFacade.getConfigMapping(); ConfigRegistry configRegistryClient = new ConfigRegistryJMXClient(ManagementFactory.getPlatformMBeanServer()); - for (Entry entry: configModules) { + for (Entry entry : configModules) { String moduleNamespace = entry.getKey(); ModuleIdentifier moduleId = entry.getValue(); try { @@ -229,6 +297,7 @@ class BlueprintContainerRestartServiceImpl implements AutoCloseable, BlueprintCo * * @param bundle the bundle to traverse * @param containerBundles the current set of bundles containing blueprint containers + * @param configModules the current set of bundles containing config modules */ private void findDependentContainersRecursively(Bundle bundle, Set containerBundles, List> configModules) {