X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-dom-adapter%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fdom%2Fadapter%2FRpcServiceAdapter.java;h=12c604dcb3497a24446bcd94dc0cf72e4fc29240;hb=7c1493fd2f93985c4b9a45e214cf7a6df9e53cf9;hp=108e6e64c6c4137b577c0ba0be14a6e4be85eae6;hpb=44db2d6b33416f8dbd35e5ad989b3ff9083060a9;p=mdsal.git

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
index 108e6e64c6..12c604dcb3 100644
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
@@ -22,6 +22,7 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Map.Entry;
 import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
@@ -41,7 +42,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
 
 class RpcServiceAdapter implements InvocationHandler {
     private final ImmutableMap<Method, RpcInvocationStrategy> rpcNames;
@@ -54,7 +55,7 @@ class RpcServiceAdapter implements InvocationHandler {
             final DOMRpcService domService) {
         this.type = requireNonNull(type);
         this.adapterContext = requireNonNull(adapterContext);
-        this.delegate = requireNonNull(domService);
+        delegate = requireNonNull(domService);
 
         final ImmutableBiMap<Method, RpcDefinition> methods = adapterContext.currentSerializer()
                 .getRpcMethodToSchema(type);
@@ -67,11 +68,10 @@ class RpcServiceAdapter implements InvocationHandler {
     }
 
     private RpcInvocationStrategy createStrategy(final Method method, final RpcDefinition schema) {
+        final QName rpcType = schema.getQName();
         final RpcRoutingStrategy strategy = RpcRoutingStrategy.from(schema);
-        if (strategy.isContextBasedRouted()) {
-            return new RoutedStrategy(schema.getPath(), method, strategy.getLeaf());
-        }
-        return new NonRoutedStrategy(schema.getPath());
+        return strategy.isContextBasedRouted() ? new RoutedStrategy(rpcType, method, strategy.getLeaf())
+                : new NonRoutedStrategy(rpcType);
     }
 
     RpcService getProxy() {
@@ -114,41 +114,42 @@ class RpcServiceAdapter implements InvocationHandler {
     }
 
     private abstract class RpcInvocationStrategy {
-        private final SchemaPath rpcName;
+        private final @NonNull NodeIdentifier inputIdentifier;
+        private final @NonNull Absolute outputPath;
 
-        RpcInvocationStrategy(final SchemaPath path) {
-            rpcName = path;
+        RpcInvocationStrategy(final QName rpcName) {
+            final var namespace = rpcName.getModule();
+            outputPath = Absolute.of(rpcName, YangConstants.operationOutputQName(namespace).intern()).intern();
+            inputIdentifier = NodeIdentifier.create(YangConstants.operationInputQName(namespace.intern()));
         }
 
         final ListenableFuture<RpcResult<?>> invoke(final DataObject input) {
-            return invoke0(rpcName, serialize(input));
+            return invoke0(serialize(input));
         }
 
         abstract ContainerNode serialize(DataObject input);
 
-        final SchemaPath getRpcName() {
-            return rpcName;
+        final @NonNull NodeIdentifier inputIdentifier() {
+            return inputIdentifier;
         }
 
-        ListenableFuture<RpcResult<?>> invoke0(final SchemaPath schemaPath, final ContainerNode input) {
-            final ListenableFuture<? extends DOMRpcResult> result = delegate.invokeRpc(schemaPath, input);
+        private ListenableFuture<RpcResult<?>> invoke0(final ContainerNode input) {
+            final ListenableFuture<? extends DOMRpcResult> result =
+                    delegate.invokeRpc(outputPath.firstNodeIdentifier(), input);
             if (ENABLE_CODEC_SHORTCUT && result instanceof BindingRpcFutureAware) {
                 return ((BindingRpcFutureAware) result).getBindingFuture();
             }
 
-            return transformFuture(schemaPath, result, adapterContext.currentSerializer());
+            return transformFuture(result, adapterContext.currentSerializer());
         }
 
-        private ListenableFuture<RpcResult<?>> transformFuture(final SchemaPath rpc,
-                final ListenableFuture<? extends DOMRpcResult> domFuture,
+        private ListenableFuture<RpcResult<?>> transformFuture(final ListenableFuture<? extends DOMRpcResult> domFuture,
                 final BindingNormalizedNodeSerializer resultCodec) {
             return Futures.transform(domFuture, input -> {
-                final NormalizedNode<?, ?> domData = input.getResult();
+                final NormalizedNode domData = input.getResult();
                 final DataObject bindingResult;
                 if (domData != null) {
-                    final SchemaPath rpcOutput = rpc.createChild(YangConstants.operationOutputQName(
-                        rpc.getLastComponent().getModule()));
-                    bindingResult = resultCodec.fromNormalizedNodeRpcData(rpcOutput, (ContainerNode) domData);
+                    bindingResult = resultCodec.fromNormalizedNodeRpcData(outputPath, (ContainerNode) domData);
                 } else {
                     bindingResult = null;
                 }
@@ -159,13 +160,13 @@ class RpcServiceAdapter implements InvocationHandler {
     }
 
     private final class NonRoutedStrategy extends RpcInvocationStrategy {
-        NonRoutedStrategy(final SchemaPath path) {
-            super(path);
+        NonRoutedStrategy(final QName rpcName) {
+            super(rpcName);
         }
 
         @Override
         ContainerNode serialize(final DataObject input) {
-            return LazySerializedContainerNode.create(getRpcName(), input, adapterContext.currentSerializer());
+            return LazySerializedContainerNode.create(inputIdentifier(), input, adapterContext.currentSerializer());
         }
     }
 
@@ -173,14 +174,14 @@ class RpcServiceAdapter implements InvocationHandler {
         private final ContextReferenceExtractor refExtractor;
         private final NodeIdentifier contextName;
 
-        RoutedStrategy(final SchemaPath path, final Method rpcMethod, final QName leafName) {
-            super(path);
+        RoutedStrategy(final QName rpcName, final Method rpcMethod, final QName leafName) {
+            super(rpcName);
             final Optional<Class<? extends DataContainer>> maybeInputType =
                     BindingReflections.resolveRpcInputClass(rpcMethod);
             checkState(maybeInputType.isPresent(), "RPC method %s has no input", rpcMethod.getName());
             final Class<? extends DataContainer> inputType = maybeInputType.get();
             refExtractor = ContextReferenceExtractor.from(inputType);
-            this.contextName = new NodeIdentifier(leafName);
+            contextName = new NodeIdentifier(leafName);
         }
 
         @Override
@@ -191,9 +192,9 @@ class RpcServiceAdapter implements InvocationHandler {
             if (bindingII != null) {
                 final YangInstanceIdentifier yangII = serializer.toCachedYangInstanceIdentifier(bindingII);
                 final LeafNode<?> contextRef = ImmutableNodes.leafNode(contextName, yangII);
-                return LazySerializedContainerNode.withContextRef(getRpcName(), input, contextRef, serializer);
+                return LazySerializedContainerNode.withContextRef(inputIdentifier(), input, contextRef, serializer);
             }
-            return LazySerializedContainerNode.create(getRpcName(), input, serializer);
+            return LazySerializedContainerNode.create(inputIdentifier(), input, serializer);
         }
 
     }