X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=dom%2Fmdsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fdom%2Fbroker%2FDOMMountPointServiceImpl.java;h=80d0c80ee34a53e1420714bce6b476188dbb5b57;hb=11408d627adca7eb71ac956c3ad01f75b6b91596;hp=0968b1884a19c8db736ffa5d7f4f6b5a20b0bcb4;hpb=f2910f31928b7f29c7e3593065ba35460052c38f;p=mdsal.git

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMMountPointServiceImpl.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMMountPointServiceImpl.java
index 0968b1884a..80d0c80ee3 100644
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMMountPointServiceImpl.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMMountPointServiceImpl.java
@@ -5,27 +5,38 @@
  * 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.mdsal.dom.broker;
 
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ClassToInstanceMap;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.collect.MutableClassToInstanceMap;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
+import javax.inject.Singleton;
+import org.kohsuke.MetaInfServices;
 import org.opendaylight.mdsal.dom.api.DOMMountPoint;
 import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
 import org.opendaylight.mdsal.dom.api.DOMService;
 import org.opendaylight.mdsal.dom.spi.SimpleDOMMountPoint;
+import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.concepts.ObjectRegistration;
 import org.opendaylight.yangtools.util.ListenerRegistry;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-public class DOMMountPointServiceImpl implements DOMMountPointService {
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Component(immediate = true)
+@MetaInfServices
+@Singleton
+public final class DOMMountPointServiceImpl implements DOMMountPointService {
+    private static final Logger LOG = LoggerFactory.getLogger(DOMMountPointServiceImpl.class);
 
     private final Map<YangInstanceIdentifier, DOMMountPoint> mountPoints = new HashMap<>();
 
@@ -33,100 +44,95 @@ public class DOMMountPointServiceImpl implements DOMMountPointService {
 
     @Override
     public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier path) {
-        return Optional.fromNullable(mountPoints.get(path));
+        return Optional.ofNullable(mountPoints.get(path));
     }
 
     @Override
     public DOMMountPointBuilder createMountPoint(final YangInstanceIdentifier path) {
-        Preconditions.checkState(!mountPoints.containsKey(path), "Mount point already exists");
+        checkState(!mountPoints.containsKey(path), "Mount point already exists");
         return new DOMMountPointBuilderImpl(path);
     }
 
-    public void notifyMountCreated(final YangInstanceIdentifier identifier) {
-        for (final ListenerRegistration<DOMMountPointListener> listener : listeners
-                .getListeners()) {
-            listener.getInstance().onMountPointCreated(identifier);
-        }
+    @Override
+    public ListenerRegistration<DOMMountPointListener> registerProvisionListener(final DOMMountPointListener listener) {
+        return listeners.register(listener);
     }
 
-    public void notifyMountRemoved(final YangInstanceIdentifier identifier) {
-        for (final ListenerRegistration<DOMMountPointListener> listener : listeners
-                .getListeners()) {
-            listener.getInstance().onMountPointRemoved(identifier);
-        }
+    @Activate
+    @SuppressWarnings("static-method")
+    void activate() {
+        LOG.info("DOMMountPointService activated");
     }
 
-    @Override
-    public ListenerRegistration<DOMMountPointListener> registerProvisionListener(
-            final DOMMountPointListener listener) {
-        return listeners.register(listener);
+    @Deactivate
+    @SuppressWarnings("static-method")
+    void deactivate() {
+        LOG.info("DOMMountPointService deactivated");
     }
 
-    public ObjectRegistration<DOMMountPoint> registerMountPoint(final DOMMountPoint mountPoint) {
+    @SuppressWarnings("checkstyle:IllegalCatch")
+    private ObjectRegistration<DOMMountPoint> registerMountPoint(final SimpleDOMMountPoint mountPoint) {
+        final YangInstanceIdentifier mountPointId = mountPoint.getIdentifier();
         synchronized (mountPoints) {
-            Preconditions.checkState(!mountPoints.containsKey(mountPoint.getIdentifier()),
-                    "Mount point already exists");
-            mountPoints.put(mountPoint.getIdentifier(), mountPoint);
+            final DOMMountPoint prev = mountPoints.putIfAbsent(mountPointId, mountPoint);
+            checkState(prev == null, "Mount point %s already exists as %s", mountPointId, prev);
         }
-        notifyMountCreated(mountPoint.getIdentifier());
-
-        return new MountRegistration(mountPoint);
+        listeners.streamListeners().forEach(listener -> {
+            try {
+                listener.onMountPointCreated(mountPointId);
+            } catch (final Exception ex) {
+                LOG.error("Listener {} failed on mount point {} created event", listener, mountPoint, ex);
+            }
+        });
+
+        return new AbstractObjectRegistration<>(mountPoint) {
+            @Override
+            protected void removeRegistration() {
+                unregisterMountPoint(getInstance().getIdentifier());
+            }
+        };
     }
 
-    public void unregisterMountPoint(final YangInstanceIdentifier mountPointId) {
+    @SuppressWarnings("checkstyle:IllegalCatch")
+    private void unregisterMountPoint(final YangInstanceIdentifier mountPointId) {
         synchronized (mountPoints) {
-            Preconditions.checkState(mountPoints.containsKey(mountPointId), "Mount point does not exist");
-            mountPoints.remove(mountPointId);
+            if (mountPoints.remove(mountPointId) == null) {
+                LOG.warn("Removing non-existent mount point {} at", mountPointId, new Throwable());
+                return;
+            }
         }
-        notifyMountRemoved(mountPointId);
+
+        listeners.streamListeners().forEach(listener -> {
+            try {
+                listener.onMountPointRemoved(mountPointId);
+            } catch (final Exception ex) {
+                LOG.error("Listener {} failed on mount point {} removed event", listener, mountPointId, ex);
+            }
+        });
     }
 
-    public class DOMMountPointBuilderImpl implements DOMMountPointBuilder {
+    private final class DOMMountPointBuilderImpl implements DOMMountPointBuilder {
 
-        ClassToInstanceMap<DOMService> services = MutableClassToInstanceMap.create();
-        private SimpleDOMMountPoint mountPoint;
+        private final MutableClassToInstanceMap<DOMService> services = MutableClassToInstanceMap.create();
         private final YangInstanceIdentifier path;
-        private SchemaContext schemaContext;
 
-        public DOMMountPointBuilderImpl(final YangInstanceIdentifier path) {
-            this.path = path;
-        }
+        private SimpleDOMMountPoint mountPoint;
 
-        @Override
-        public <T extends DOMService> DOMMountPointBuilder addService(final Class<T> type, final T impl) {
-            services.putInstance(type, impl);
-            return this;
+        DOMMountPointBuilderImpl(final YangInstanceIdentifier path) {
+            this.path = requireNonNull(path);
         }
 
         @Override
-        public DOMMountPointBuilder addInitialSchemaContext(final SchemaContext ctx) {
-            schemaContext = ctx;
+        public <T extends DOMService> DOMMountPointBuilder addService(final Class<T> type, final T impl) {
+            services.putInstance(requireNonNull(type), requireNonNull(impl));
             return this;
         }
 
         @Override
         public ObjectRegistration<DOMMountPoint> register() {
-            Preconditions.checkState(mountPoint == null, "Mount point is already built.");
-            mountPoint = SimpleDOMMountPoint.create(path, services,schemaContext);
+            checkState(mountPoint == null, "Mount point is already built.");
+            mountPoint = SimpleDOMMountPoint.create(path, services);
             return registerMountPoint(mountPoint);
         }
     }
-
-    private final class MountRegistration implements ObjectRegistration<DOMMountPoint> {
-        private final DOMMountPoint mountPoint;
-
-        MountRegistration(final DOMMountPoint mountPoint) {
-            this.mountPoint = mountPoint;
-        }
-
-        @Override
-        public DOMMountPoint getInstance() {
-            return mountPoint;
-        }
-
-        @Override
-        public void close() throws Exception {
-            unregisterMountPoint(mountPoint.getIdentifier());
-        }
-    }
 }