X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fdom%2Fbroker%2FGlobalBundleScanningSchemaServiceImpl.java;h=4ba62e4fc40fe62a6c7c4a68fe1d77b12e1f4475;hp=82637327f6b10d719c04e4fa04ad6a7b53b2dafe;hb=f7a0d624f5927875c9d937f07d73feb7b9970546;hpb=8e42b08cb626a60919c145b2a46d94114c3905d6 diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java index 82637327f6..4ba62e4fc4 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java @@ -8,23 +8,32 @@ package org.opendaylight.controller.sal.dom.broker; import static com.google.common.base.Preconditions.checkState; - import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; +import com.google.common.util.concurrent.CheckedFuture; import java.net.URL; import java.util.ArrayList; import java.util.Collections; import java.util.Enumeration; import java.util.List; - +import java.util.concurrent.atomic.AtomicReference; +import javax.annotation.concurrent.GuardedBy; import org.opendaylight.controller.sal.core.api.model.SchemaService; -import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider; +import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.concepts.Registration; -import org.opendaylight.yangtools.concepts.util.ListenerRegistry; +import org.opendaylight.yangtools.util.ListenerRegistry; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; -import org.opendaylight.yangtools.yang.parser.impl.util.URLSchemaContextResolver; +import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider; +import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException; +import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; +import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; +import org.opendaylight.yangtools.yang.parser.repo.YangTextSchemaContextResolver; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; import org.osgi.framework.BundleEvent; @@ -36,42 +45,46 @@ import org.osgi.util.tracker.ServiceTrackerCustomizer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import com.google.common.collect.ImmutableList; - -public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvider, SchemaService, ServiceTrackerCustomizer, AutoCloseable { +public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvider, SchemaService, ServiceTrackerCustomizer, YangTextSourceProvider, AutoCloseable { private static final Logger LOG = LoggerFactory.getLogger(GlobalBundleScanningSchemaServiceImpl.class); + private static AtomicReference globalInstance = new AtomicReference<>(); + + @GuardedBy(value = "lock") private final ListenerRegistry listeners = new ListenerRegistry<>(); - private final URLSchemaContextResolver contextResolver = new URLSchemaContextResolver(); + private final YangTextSchemaContextResolver contextResolver = YangTextSchemaContextResolver.create("global-bundle"); private final BundleScanner scanner = new BundleScanner(); private final BundleContext context; private ServiceTracker listenerTracker; private BundleTracker> bundleTracker; private boolean starting = true; - private static GlobalBundleScanningSchemaServiceImpl instance; + private volatile boolean stopping; + private final Object lock = new Object(); private GlobalBundleScanningSchemaServiceImpl(final BundleContext context) { this.context = Preconditions.checkNotNull(context); } - public synchronized static GlobalBundleScanningSchemaServiceImpl createInstance(final BundleContext ctx) { - Preconditions.checkState(instance == null); - instance = new GlobalBundleScanningSchemaServiceImpl(ctx); + public static GlobalBundleScanningSchemaServiceImpl createInstance(final BundleContext ctx) { + GlobalBundleScanningSchemaServiceImpl instance = new GlobalBundleScanningSchemaServiceImpl(ctx); + Preconditions.checkState(globalInstance.compareAndSet(null, instance)); instance.start(); return instance; } - public synchronized static GlobalBundleScanningSchemaServiceImpl getInstance() { + public static GlobalBundleScanningSchemaServiceImpl getInstance() { + GlobalBundleScanningSchemaServiceImpl instance = globalInstance.get(); Preconditions.checkState(instance != null, "Global Instance was not instantiated"); return instance; } @VisibleForTesting - public static synchronized void destroyInstance() { - instance = null; + public static void destroyInstance() { + GlobalBundleScanningSchemaServiceImpl instance = globalInstance.getAndSet(null); + if(instance != null) { + instance.close(); + } } public BundleContext getContext() { @@ -80,13 +93,27 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi public void start() { checkState(context != null); + LOG.debug("start() starting"); listenerTracker = new ServiceTracker<>(context, SchemaContextListener.class, GlobalBundleScanningSchemaServiceImpl.this); - bundleTracker = new BundleTracker<>(context, BundleEvent.RESOLVED | BundleEvent.UNRESOLVED, scanner); - bundleTracker.open(); + bundleTracker = new BundleTracker<>(context, Bundle.RESOLVED | Bundle.STARTING | + Bundle.STOPPING | Bundle.ACTIVE, scanner); + + synchronized(lock) { + bundleTracker.open(); + + LOG.debug("BundleTracker.open() complete"); + + boolean hasExistingListeners = Iterables.size(listeners.getListeners()) > 0; + if(hasExistingListeners) { + tryToUpdateSchemaContext(); + } + } + listenerTracker.open(); starting = false; - tryToUpdateSchemaContext(); + + LOG.debug("start() complete"); } @Override @@ -115,27 +142,33 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } @Override - public synchronized ListenerRegistration registerSchemaContextListener(final SchemaContextListener listener) { - Optional potentialCtx = contextResolver.getSchemaContext(); - if(potentialCtx.isPresent()) { - listener.onGlobalContextUpdated(potentialCtx.get()); + public ListenerRegistration registerSchemaContextListener(final SchemaContextListener listener) { + synchronized(lock) { + Optional potentialCtx = contextResolver.getSchemaContext(); + if(potentialCtx.isPresent()) { + listener.onGlobalContextUpdated(potentialCtx.get()); + } + return listeners.register(listener); } - return listeners.register(listener); } @Override - public void close() throws Exception { + public void close() { + stopping = true; if (bundleTracker != null) { bundleTracker.close(); } if (listenerTracker != null) { listenerTracker.close(); } - // FIXME: Add listeners.close(); - } + for (ListenerRegistration l : listeners.getListeners()) { + l.close(); + } + } - private synchronized void updateContext(final SchemaContext snapshot) { + @GuardedBy(value = "lock") + private void notifyListeners(final SchemaContext snapshot) { Object[] services = listenerTracker.getServices(); for (ListenerRegistration listener : listeners) { try { @@ -156,6 +189,12 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } } + @Override + public CheckedFuture getSource(final SourceIdentifier sourceIdentifier) { + return contextResolver.getSource(sourceIdentifier); + + } + private class BundleScanner implements BundleTrackerCustomizer> { @Override public Iterable addingBundle(final Bundle bundle, final BundleEvent event) { @@ -181,7 +220,8 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } if (!urls.isEmpty()) { - LOG.debug("Loaded {} new URLs, rebuilding schema context", urls.size()); + LOG.debug("Loaded {} new URLs from bundle {}, attempting to rebuild schema context", + urls.size(), bundle.getSymbolicName()); tryToUpdateSchemaContext(); } @@ -190,7 +230,6 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi @Override public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Iterable object) { - LOG.debug("Modified bundle {} {} {}", bundle, event, object); } /** @@ -200,7 +239,7 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi */ @Override - public synchronized void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable urls) { + public void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable urls) { for (Registration url : urls) { try { url.close(); @@ -208,12 +247,20 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi LOG.warn("Failed do unregister URL {}, proceeding", url, e); } } - tryToUpdateSchemaContext(); + + int numUrls = Iterables.size(urls); + if(numUrls > 0 ) { + if(LOG.isDebugEnabled()) { + LOG.debug("removedBundle: {}, state: {}, # urls: {}", bundle.getSymbolicName(), bundle.getState(), numUrls); + } + + tryToUpdateSchemaContext(); + } } } @Override - public synchronized SchemaContextListener addingService(final ServiceReference reference) { + public SchemaContextListener addingService(final ServiceReference reference) { SchemaContextListener listener = context.getService(reference); SchemaContext _ctxContext = getGlobalContext(); @@ -223,13 +270,20 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi return listener; } - public synchronized void tryToUpdateSchemaContext() { - if (starting) { + public void tryToUpdateSchemaContext() { + if (starting || stopping) { return; } - Optional schema = contextResolver.tryToUpdateSchemaContext(); - if(schema.isPresent()) { - updateContext(schema.get()); + + synchronized(lock) { + Optional schema = contextResolver.getSchemaContext(); + if(schema.isPresent()) { + if(LOG.isDebugEnabled()) { + LOG.debug("Got new SchemaContext: # of modules {}", schema.get().getAllModuleIdentifiers().size()); + } + + notifyListeners(schema.get()); + } } }