X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-schema-service%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fschema%2Fservice%2Fimpl%2FGlobalBundleScanningSchemaServiceImpl.java;fp=opendaylight%2Fmd-sal%2Fsal-schema-service%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fschema%2Fservice%2Fimpl%2FGlobalBundleScanningSchemaServiceImpl.java;h=c54b2e388506cfaeaaa01f15856528c544d603b0;hb=0e5d0eeeda176fe4ef0d5f65097998b32e38abf1;hp=0000000000000000000000000000000000000000;hpb=08cebe000ade997fd2c84ee0e690beddd4ce9209;p=controller.git diff --git a/opendaylight/md-sal/sal-schema-service/src/main/java/org/opendaylight/controller/sal/schema/service/impl/GlobalBundleScanningSchemaServiceImpl.java b/opendaylight/md-sal/sal-schema-service/src/main/java/org/opendaylight/controller/sal/schema/service/impl/GlobalBundleScanningSchemaServiceImpl.java new file mode 100644 index 0000000000..c54b2e3885 --- /dev/null +++ b/opendaylight/md-sal/sal-schema-service/src/main/java/org/opendaylight/controller/sal/schema/service/impl/GlobalBundleScanningSchemaServiceImpl.java @@ -0,0 +1,280 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.schema.service.impl; + +import static com.google.common.base.Preconditions.checkState; +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 javax.annotation.concurrent.GuardedBy; +import org.opendaylight.controller.sal.core.api.model.SchemaService; +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.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.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; +import org.osgi.framework.ServiceReference; +import org.osgi.util.tracker.BundleTracker; +import org.osgi.util.tracker.BundleTrackerCustomizer; +import org.osgi.util.tracker.ServiceTracker; +import org.osgi.util.tracker.ServiceTrackerCustomizer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvider, SchemaService, ServiceTrackerCustomizer, YangTextSourceProvider, AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(GlobalBundleScanningSchemaServiceImpl.class); + + @GuardedBy(value = "lock") + private final ListenerRegistry listeners = new ListenerRegistry<>(); + 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 volatile boolean stopping; + private final Object lock = new Object(); + + private GlobalBundleScanningSchemaServiceImpl(final BundleContext context) { + this.context = Preconditions.checkNotNull(context); + } + + public static GlobalBundleScanningSchemaServiceImpl createInstance(final BundleContext ctx) { + GlobalBundleScanningSchemaServiceImpl instance = new GlobalBundleScanningSchemaServiceImpl(ctx); + instance.start(); + return instance; + } + + public BundleContext getContext() { + return context; + } + + public void start() { + checkState(context != null); + LOG.debug("start() starting"); + + listenerTracker = new ServiceTracker<>(context, SchemaContextListener.class, GlobalBundleScanningSchemaServiceImpl.this); + 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; + + LOG.debug("start() complete"); + } + + @Override + public SchemaContext getSchemaContext() { + return getGlobalContext(); + } + + @Override + public SchemaContext getGlobalContext() { + return contextResolver.getSchemaContext().orNull(); + } + + @Override + public void addModule(final Module module) { + throw new UnsupportedOperationException(); + } + + @Override + public SchemaContext getSessionContext() { + throw new UnsupportedOperationException(); + } + + @Override + public void removeModule(final Module module) { + throw new UnsupportedOperationException(); + } + + @Override + public ListenerRegistration registerSchemaContextListener(final SchemaContextListener listener) { + synchronized(lock) { + Optional potentialCtx = contextResolver.getSchemaContext(); + if(potentialCtx.isPresent()) { + listener.onGlobalContextUpdated(potentialCtx.get()); + } + return listeners.register(listener); + } + } + + @Override + public void close() { + stopping = true; + if (bundleTracker != null) { + bundleTracker.close(); + } + if (listenerTracker != null) { + listenerTracker.close(); + } + + for (ListenerRegistration l : listeners.getListeners()) { + l.close(); + } + } + + @GuardedBy(value = "lock") + private void notifyListeners(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) { + final SchemaContextListener listener = (SchemaContextListener) rawListener; + try { + listener.onGlobalContextUpdated(snapshot); + } catch (Exception e) { + LOG.error("Exception occured during invoking listener {}", listener, e); + } + } + } + } + + @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) { + + if (bundle.getBundleId() == 0) { + return Collections.emptyList(); + } + + final Enumeration enumeration = bundle.findEntries("META-INF/yang", "*.yang", false); + if (enumeration == null) { + return Collections.emptyList(); + } + + 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); + } + } + + if (!urls.isEmpty()) { + LOG.debug("Loaded {} new URLs from bundle {}, attempting to rebuild schema context", + urls.size(), bundle.getSymbolicName()); + tryToUpdateSchemaContext(); + } + + return ImmutableList.copyOf(urls); + } + + @Override + public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Iterable object) { + } + + /** + * If removing YANG files makes yang store inconsistent, method + * {@link #getYangStoreSnapshot()} will throw exception. There is no + * rollback. + */ + + @Override + public void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable urls) { + for (Registration url : urls) { + try { + url.close(); + } catch (Exception e) { + LOG.warn("Failed do unregister URL {}, proceeding", url, e); + } + } + + int numUrls = Iterables.size(urls); + if(numUrls > 0 ) { + if(LOG.isDebugEnabled()) { + LOG.debug("removedBundle: {}, state: {}, # urls: {}", bundle.getSymbolicName(), bundle.getState(), numUrls); + } + + tryToUpdateSchemaContext(); + } + } + } + + @Override + public SchemaContextListener addingService(final ServiceReference reference) { + + SchemaContextListener listener = context.getService(reference); + SchemaContext _ctxContext = getGlobalContext(); + if (getContext() != null && _ctxContext != null) { + listener.onGlobalContextUpdated(_ctxContext); + } + return listener; + } + + public void tryToUpdateSchemaContext() { + if (starting || stopping) { + return; + } + + 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()); + } + } + } + + @Override + public void modifiedService(final ServiceReference reference, final SchemaContextListener service) { + // NOOP + } + + @Override + public void removedService(final ServiceReference reference, final SchemaContextListener service) { + context.ungetService(reference); + } +}