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

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. 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
  12 import com.google.common.util.concurrent.AbstractFuture;
  13 import com.google.common.util.concurrent.ListenableFuture;
  14 import java.util.concurrent.ExecutionException;
  15 import java.util.concurrent.Executor;
  16 import java.util.concurrent.TimeUnit;
  17 import java.util.concurrent.TimeoutException;
  18 import org.eclipse.jdt.annotation.NonNull;
  19 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  20 import org.opendaylight.mdsal.dom.api.DOMRpcException;
  21 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
  22 import org.opendaylight.mdsal.dom.api.DefaultDOMRpcException;
  23 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
  24 import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
  25 import org.opendaylight.yangtools.yang.binding.DataContainer;
  26 import org.opendaylight.yangtools.yang.common.RpcResult;
  27
  28 final class LazyDOMRpcResultFuture extends AbstractFuture<DOMRpcResult> implements BindingRpcFutureAware {
  29     private static final ExceptionMapper<DOMRpcException> DOM_RPC_EX_MAPPER = new ExceptionMapper<>("rpc",
  30             DOMRpcException.class) {
  31         @Override
  32         protected DOMRpcException newWithCause(final String message, final Throwable cause) {
  33             return cause instanceof DOMRpcException ? (DOMRpcException)cause
  34                     : new DefaultDOMRpcException("RPC failed", cause);
  35         }
  36     };
  37
  38     private final ListenableFuture<RpcResult<?>> bindingFuture;
  39     private final BindingNormalizedNodeSerializer codec;
  40     private volatile DOMRpcResult result;
  41
  42     private LazyDOMRpcResultFuture(final ListenableFuture<RpcResult<?>> delegate,
  43             final BindingNormalizedNodeSerializer codec) {
  44         bindingFuture = requireNonNull(delegate, "delegate");
  45         this.codec = requireNonNull(codec, "codec");
  46     }
  47
  48     static @NonNull LazyDOMRpcResultFuture create(final BindingNormalizedNodeSerializer codec,
  49             final ListenableFuture<RpcResult<?>> bindingResult) {
  50         return new LazyDOMRpcResultFuture(bindingResult, codec);
  51     }
  52
  53     @Override
  54     public ListenableFuture<RpcResult<?>> getBindingFuture() {
  55         return bindingFuture;
  56     }
  57
  58     @Override
  59     public boolean cancel(final boolean mayInterruptIfRunning) {
  60         return bindingFuture.cancel(mayInterruptIfRunning);
  61     }
  62
  63     @Override
  64     public void addListener(final Runnable listener, final Executor executor) {
  65         bindingFuture.addListener(listener, executor);
  66     }
  67
  68     @Override
  69     public DOMRpcResult get() throws InterruptedException, ExecutionException {
  70         if (result != null) {
  71             return result;
  72         }
  73
  74         try {
  75             return transformIfNecessary(bindingFuture.get());
  76         } catch (ExecutionException e) {
  77             throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
  78         }
  79     }
  80
  81     @Override
  82     public DOMRpcResult get(final long timeout, final TimeUnit unit) throws InterruptedException, ExecutionException,
  83             TimeoutException {
  84         if (result != null) {
  85             return result;
  86         }
  87
  88         try {
  89             return transformIfNecessary(bindingFuture.get(timeout, unit));
  90         } catch (ExecutionException e) {
  91             throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
  92         }
  93     }
  94
  95     @Override
  96     public boolean isCancelled() {
  97         return bindingFuture.isCancelled();
  98     }
  99
 100     @Override
 101     public boolean isDone() {
 102         return bindingFuture.isDone();
 103     }
 104
 105     private synchronized DOMRpcResult transformIfNecessary(final RpcResult<?> input) {
 106         if (result == null) {
 107             result = transform(input);
 108         }
 109         return result;
 110     }
 111
 112     private DOMRpcResult transform(final RpcResult<?> input) {
 113         if (input.isSuccessful()) {
 114             final var value = input.getResult() instanceof DataContainer container
 115                 ? codec.toNormalizedNodeRpcData(container) : null;
 116             return new DefaultDOMRpcResult(value);
 117         }
 118         return new DefaultDOMRpcResult(input.getErrors());
 119     }
 120 }