Bump upstream SNAPSHOTS

[controller.git] / opendaylight / blueprint / src / main / java / org / opendaylight / controller / blueprint / ext / AbstractInvokableServiceMetadata.java

diff --git a/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/ext/AbstractInvokableServiceMetadata.java b/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/ext/AbstractInvokableServiceMetadata.java
index 1c1f4cb8139ef9a4855d0a52a3a3759b44cab118..35f59f85c528b8bb9f7ccbd3d272427a2a7db224 100644 (file)
--- a/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/ext/AbstractInvokableServiceMetadata.java
+++ b/opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/ext/AbstractInvokableServiceMetadata.java
@@ -7,36 +7,37 @@
  */
 package org.opendaylight.controller.blueprint.ext;
 
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableSet;
 import java.util.Collection;
 import java.util.Set;
 import java.util.function.Predicate;
 import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.osgi.service.blueprint.container.ComponentDefinitionException;
 
 abstract class AbstractInvokableServiceMetadata extends AbstractDependentComponentFactoryMetadata {
     private final String interfaceName;
 
     private ListenerRegistration<DOMRpcAvailabilityListener> rpcListenerReg;
-    private RpcProviderRegistry rpcRegistry;
+    private RpcConsumerRegistry rpcRegistry;
     private Class<RpcService> rpcInterface;
-    private Set<SchemaPath> rpcSchemaPaths;
+    private Set<QName> rpcSchemaPaths;
 
     AbstractInvokableServiceMetadata(final String id, final String interfaceName) {
         super(id);
-        this.interfaceName = Preconditions.checkNotNull(interfaceName);
+        this.interfaceName = requireNonNull(interfaceName);
     }
 
     Class<RpcService> rpcInterface() {
@@ -51,7 +52,7 @@ abstract class AbstractInvokableServiceMetadata extends AbstractDependentCompone
         final Class<?> interfaceClass;
         try {
             interfaceClass = container().getBundleContext().getBundle().loadClass(interfaceName);
-        } catch (Exception e) {
+        } catch (final Exception e) {
             throw new ComponentDefinitionException(String.format("%s: Error obtaining interface class %s",
                     logName(), interfaceName), e);
         }
@@ -67,31 +68,31 @@ abstract class AbstractInvokableServiceMetadata extends AbstractDependentCompone
     @Override
     protected final void startTracking() {
         // Request RpcProviderRegistry first ...
-        retrieveService("RpcProviderRegistry", RpcProviderRegistry.class, this::onRpcRegistry);
+        retrieveService("RpcConsumerRegistry", RpcConsumerRegistry.class, this::onRpcRegistry);
     }
 
     private void onRpcRegistry(final Object service) {
         log.debug("{}: Retrieved RpcProviderRegistry {}", logName(), service);
-        rpcRegistry = (RpcProviderRegistry)service;
+        rpcRegistry = (RpcConsumerRegistry)service;
 
         // Now acquire SchemaService...
-        retrieveService("SchemaService", SchemaService.class, this::onSchemaService);
+        retrieveService("SchemaService", DOMSchemaService.class, this::onSchemaService);
     }
 
     private void onSchemaService(final Object service) {
         log.debug("{}: Retrieved SchemaService {}", logName(), service);
 
         // Now get the SchemaContext and trigger RPC resolution
-        retrievedSchemaContext(((SchemaService)service).getGlobalContext());
+        retrievedSchemaContext(((DOMSchemaService)service).getGlobalContext());
     }
 
     private void retrievedSchemaContext(final SchemaContext schemaContext) {
         log.debug("{}: retrievedSchemaContext", logName());
 
-        final Collection<SchemaPath> schemaPaths = RpcUtil.decomposeRpcService(rpcInterface, schemaContext,
+        final Collection<QName> schemaPaths = RpcUtil.decomposeRpcService(rpcInterface, schemaContext,
             rpcFilter());
         if (schemaPaths.isEmpty()) {
-            log.warn("{}: interface {} has no accptable entries, assuming it is satisfied");
+            log.debug("{}: interface {} has no acceptable entries, assuming it is satisfied", logName(), rpcInterface);
             setSatisfied();
             return;
         }
@@ -136,7 +137,7 @@ abstract class AbstractInvokableServiceMetadata extends AbstractDependentCompone
             log.debug("{}: create returning service {}", logName(), rpcService);
 
             return rpcService;
-        } catch (RuntimeException e) {
+        } catch (final RuntimeException e) {
             throw new ComponentDefinitionException("Error getting RPC service for " + interfaceName, e);
         }
     }