binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcInvocationStrategy.java

   1 /*
   2  * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.dom.adapter;
   9
  10 import static java.util.Objects.requireNonNull;
  11 import static org.opendaylight.mdsal.binding.dom.adapter.StaticConfiguration.ENABLE_CODEC_SHORTCUT;
  12
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import com.google.common.util.concurrent.MoreExecutors;
  16 import org.eclipse.jdt.annotation.NonNull;
  17 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  18 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
  19 import org.opendaylight.yangtools.yang.binding.DataObject;
  20 import org.opendaylight.yangtools.yang.binding.RpcInput;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.common.RpcResult;
  23 import org.opendaylight.yangtools.yang.common.YangConstants;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  26 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
  28
  29 sealed class RpcInvocationStrategy {
  30     static final class ContentRouted extends RpcInvocationStrategy {
  31         private final ContextReferenceExtractor refExtractor;
  32         private final NodeIdentifier contextName;
  33
  34         ContentRouted(final RpcAdapter adapter, final QName rpcName, final QName leafName,
  35                 final ContextReferenceExtractor refExtractor) {
  36             super(adapter, rpcName);
  37             contextName = NodeIdentifier.create(leafName);
  38             this.refExtractor = requireNonNull(refExtractor);
  39         }
  40
  41         @Override
  42         ContainerNode serialize(final NodeIdentifier inputIdentifier, final CurrentAdapterSerializer serializer,
  43                 final RpcInput input) {
  44             final var bindingII = refExtractor.extract(input);
  45             if (bindingII == null) {
  46                 return super.serialize(inputIdentifier, serializer, input);
  47             }
  48
  49             final var yangII = serializer.toCachedYangInstanceIdentifier(bindingII);
  50             final var contextRef = ImmutableNodes.leafNode(contextName, yangII);
  51             return LazySerializedContainerNode.withContextRef(inputIdentifier, input, contextRef, serializer);
  52         }
  53     }
  54
  55     private final @NonNull RpcAdapter adapter;
  56     private final @NonNull NodeIdentifier inputIdentifier;
  57     private final @NonNull Absolute outputPath;
  58
  59     RpcInvocationStrategy(final RpcAdapter adapter, final QName rpcName) {
  60         this.adapter = requireNonNull(adapter);
  61         final var namespace = rpcName.getModule();
  62         outputPath = Absolute.of(rpcName, YangConstants.operationOutputQName(namespace).intern()).intern();
  63         inputIdentifier = NodeIdentifier.create(YangConstants.operationInputQName(namespace.intern()));
  64     }
  65
  66     final ListenableFuture<RpcResult<?>> invoke(final RpcInput input) {
  67         return invoke(serialize(inputIdentifier, adapter.currentSerializer(), input));
  68     }
  69
  70     private ListenableFuture<RpcResult<?>> invoke(final ContainerNode input) {
  71         final var domFuture = adapter.delegate().invokeRpc(outputPath.firstNodeIdentifier(), input);
  72         if (ENABLE_CODEC_SHORTCUT && domFuture instanceof BindingRpcFutureAware bindingAware) {
  73             return bindingAware.getBindingFuture();
  74         }
  75         return transformFuture(domFuture, adapter.currentSerializer());
  76     }
  77
  78     ContainerNode serialize(final @NonNull NodeIdentifier identifier,
  79             final @NonNull CurrentAdapterSerializer serializer, final RpcInput input) {
  80         return LazySerializedContainerNode.create(inputIdentifier, input, serializer);
  81     }
  82
  83     private ListenableFuture<RpcResult<?>> transformFuture(final ListenableFuture<? extends DOMRpcResult> domFuture,
  84             final BindingNormalizedNodeSerializer resultCodec) {
  85         return Futures.transform(domFuture, input -> {
  86             final ContainerNode domData = input.value();
  87             final DataObject bindingResult;
  88             if (domData != null) {
  89                 bindingResult = resultCodec.fromNormalizedNodeRpcData(outputPath, domData);
  90             } else {
  91                 bindingResult = null;
  92             }
  93
  94             return RpcResultUtil.rpcResultFromDOM(input.errors(), bindingResult);
  95         }, MoreExecutors.directExecutor());
  96     }
  97 }