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=82637327f6b10d719c04e4fa04ad6a7b53b2dafe;hp=bf35037b224beae2e1f4f0434d22c7e58a920bc0;hb=9c3a7d1aa13908ee5f0be33b63dfd2467af551be;hpb=ab7bfb1d8a4f5c0fb800074c9a8f12caeb35925c 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 bf35037b22..82637327f6 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 @@ -9,8 +9,12 @@ package org.opendaylight.controller.sal.dom.broker; import static com.google.common.base.Preconditions.checkState; +import com.google.common.annotations.VisibleForTesting; import java.net.URL; +import java.util.ArrayList; +import java.util.Collections; import java.util.Enumeration; +import java.util.List; import org.opendaylight.controller.sal.core.api.model.SchemaService; import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider; @@ -19,7 +23,7 @@ import org.opendaylight.yangtools.concepts.Registration; import org.opendaylight.yangtools.concepts.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.SchemaServiceListener; +import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.opendaylight.yangtools.yang.parser.impl.util.URLSchemaContextResolver; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; @@ -33,54 +37,52 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Optional; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.ImmutableSet.Builder; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; -public class GlobalBundleScanningSchemaServiceImpl implements // - SchemaContextProvider, // - SchemaService, // - ServiceTrackerCustomizer, // - AutoCloseable { - private static final Logger logger = LoggerFactory.getLogger(GlobalBundleScanningSchemaServiceImpl.class); - - private ListenerRegistry listeners; - - private BundleContext context; - private BundleScanner scanner = new BundleScanner(); - - private BundleTracker>> bundleTracker; +public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvider, SchemaService, ServiceTrackerCustomizer, AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(GlobalBundleScanningSchemaServiceImpl.class); + private final ListenerRegistry listeners = new ListenerRegistry<>(); private final URLSchemaContextResolver contextResolver = new URLSchemaContextResolver(); + private final BundleScanner scanner = new BundleScanner(); + private final BundleContext context; - private ServiceTracker listenerTracker; - + private ServiceTracker listenerTracker; + private BundleTracker> bundleTracker; private boolean starting = true; + private static GlobalBundleScanningSchemaServiceImpl instance; - public ListenerRegistry getListeners() { - return listeners; + private GlobalBundleScanningSchemaServiceImpl(final BundleContext context) { + this.context = Preconditions.checkNotNull(context); } - public void setListeners(ListenerRegistry listeners) { - this.listeners = listeners; + public synchronized static GlobalBundleScanningSchemaServiceImpl createInstance(final BundleContext ctx) { + Preconditions.checkState(instance == null); + instance = new GlobalBundleScanningSchemaServiceImpl(ctx); + instance.start(); + return instance; } - public BundleContext getContext() { - return context; + public synchronized static GlobalBundleScanningSchemaServiceImpl getInstance() { + Preconditions.checkState(instance != null, "Global Instance was not instantiated"); + return instance; + } + + @VisibleForTesting + public static synchronized void destroyInstance() { + instance = null; } - public void setContext(BundleContext context) { - this.context = context; + public BundleContext getContext() { + return context; } public void start() { checkState(context != null); - if (listeners == null) { - listeners = new ListenerRegistry<>(); - } - listenerTracker = new ServiceTracker<>(context, SchemaServiceListener.class, GlobalBundleScanningSchemaServiceImpl.this); - bundleTracker = new BundleTracker>>(context, BundleEvent.RESOLVED - | BundleEvent.UNRESOLVED, scanner); + listenerTracker = new ServiceTracker<>(context, SchemaContextListener.class, GlobalBundleScanningSchemaServiceImpl.this); + bundleTracker = new BundleTracker<>(context, BundleEvent.RESOLVED | BundleEvent.UNRESOLVED, scanner); bundleTracker.open(); listenerTracker.open(); starting = false; @@ -92,12 +94,13 @@ public class GlobalBundleScanningSchemaServiceImpl implements // return getGlobalContext(); } + @Override public SchemaContext getGlobalContext() { return contextResolver.getSchemaContext().orNull(); } @Override - public void addModule(Module module) { + public void addModule(final Module module) { throw new UnsupportedOperationException(); } @@ -107,12 +110,16 @@ public class GlobalBundleScanningSchemaServiceImpl implements // } @Override - public void removeModule(Module module) { + public void removeModule(final Module module) { throw new UnsupportedOperationException(); } @Override - public ListenerRegistration registerSchemaServiceListener(SchemaServiceListener listener) { + public synchronized ListenerRegistration registerSchemaContextListener(final SchemaContextListener listener) { + Optional potentialCtx = contextResolver.getSchemaContext(); + if(potentialCtx.isPresent()) { + listener.onGlobalContextUpdated(potentialCtx.get()); + } return listeners.register(listener); } @@ -128,52 +135,62 @@ public class GlobalBundleScanningSchemaServiceImpl implements // } - private void updateContext(SchemaContext snapshot) { + private synchronized void updateContext(final SchemaContext snapshot) { Object[] services = listenerTracker.getServices(); + for (ListenerRegistration listener : listeners) { + try { + listener.getInstance().onGlobalContextUpdated(snapshot); + } catch (Exception e) { + LOG.error("Exception occured during invoking listener", e); + } + } if (services != null) { for (Object rawListener : services) { - SchemaServiceListener listener = (SchemaServiceListener) rawListener; + final SchemaContextListener listener = (SchemaContextListener) rawListener; try { listener.onGlobalContextUpdated(snapshot); } catch (Exception e) { - logger.error("Exception occured during invoking listener", e); + LOG.error("Exception occured during invoking listener {}", listener, e); } } } - for (ListenerRegistration listener : listeners) { - try { - listener.getInstance().onGlobalContextUpdated(snapshot); - } catch (Exception e) { - logger.error("Exception occured during invoking listener", e); - } - } } - private class BundleScanner implements BundleTrackerCustomizer>> { + private class BundleScanner implements BundleTrackerCustomizer> { @Override - public ImmutableSet> addingBundle(Bundle bundle, BundleEvent event) { + public Iterable addingBundle(final Bundle bundle, final BundleEvent event) { if (bundle.getBundleId() == 0) { - return ImmutableSet.of(); + return Collections.emptyList(); } - Enumeration enumeration = bundle.findEntries("META-INF/yang", "*.yang", false); - Builder> builder = ImmutableSet.> builder(); - while (enumeration != null && enumeration.hasMoreElements()) { - Registration reg = contextResolver.registerSource(enumeration.nextElement()); - builder.add(reg); + final Enumeration enumeration = bundle.findEntries("META-INF/yang", "*.yang", false); + if (enumeration == null) { + return Collections.emptyList(); } - ImmutableSet> urls = builder.build(); - if(urls.isEmpty()) { - return urls; + + final List urls = new ArrayList<>(); + while (enumeration.hasMoreElements()) { + final URL u = enumeration.nextElement(); + try { + urls.add(contextResolver.registerSource(u)); + LOG.debug("Registered {}", u); + } catch (Exception e) { + LOG.warn("Failed to register {}, ignoring it", e); + } } - tryToUpdateSchemaContext(); - return urls; + + if (!urls.isEmpty()) { + LOG.debug("Loaded {} new URLs, rebuilding schema context", urls.size()); + tryToUpdateSchemaContext(); + } + + return ImmutableList.copyOf(urls); } @Override - public void modifiedBundle(Bundle bundle, BundleEvent event, ImmutableSet> object) { - logger.debug("Modified bundle {} {} {}", bundle, event, object); + public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Iterable object) { + LOG.debug("Modified bundle {} {} {}", bundle, event, object); } /** @@ -183,12 +200,12 @@ public class GlobalBundleScanningSchemaServiceImpl implements // */ @Override - public synchronized void removedBundle(Bundle bundle, BundleEvent event, ImmutableSet> urls) { - for (Registration url : urls) { + public synchronized void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable urls) { + for (Registration url : urls) { try { url.close(); } catch (Exception e) { - e.printStackTrace(); + LOG.warn("Failed do unregister URL {}, proceeding", url, e); } } tryToUpdateSchemaContext(); @@ -196,9 +213,9 @@ public class GlobalBundleScanningSchemaServiceImpl implements // } @Override - public SchemaServiceListener addingService(ServiceReference reference) { + public synchronized SchemaContextListener addingService(final ServiceReference reference) { - SchemaServiceListener listener = context.getService(reference); + SchemaContextListener listener = context.getService(reference); SchemaContext _ctxContext = getGlobalContext(); if (getContext() != null && _ctxContext != null) { listener.onGlobalContextUpdated(_ctxContext); @@ -207,7 +224,7 @@ public class GlobalBundleScanningSchemaServiceImpl implements // } public synchronized void tryToUpdateSchemaContext() { - if(starting ) { + if (starting) { return; } Optional schema = contextResolver.tryToUpdateSchemaContext(); @@ -217,12 +234,12 @@ public class GlobalBundleScanningSchemaServiceImpl implements // } @Override - public void modifiedService(ServiceReference reference, SchemaServiceListener service) { + public void modifiedService(final ServiceReference reference, final SchemaContextListener service) { // NOOP } @Override - public void removedService(ServiceReference reference, SchemaServiceListener service) { + public void removedService(final ServiceReference reference, final SchemaContextListener service) { context.ungetService(reference); } }