opendaylight/md-sal/sal-dom-compat/src/main/java/org/opendaylight/controller/sal/core/compat/AbstractLegacyDOMDataBrokerAdapter.java

   1 /*
   2  * Copyright (c) 2017 Inocybe Technologies 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.controller.sal.core.compat;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.base.Optional;
  13 import com.google.common.collect.ClassToInstanceMap;
  14 import com.google.common.collect.ForwardingObject;
  15 import com.google.common.collect.ImmutableClassToInstanceMap;
  16 import com.google.common.collect.ImmutableClassToInstanceMap.Builder;
  17 import com.google.common.util.concurrent.CheckedFuture;
  18 import com.google.common.util.concurrent.FluentFuture;
  19 import com.google.common.util.concurrent.FutureCallback;
  20 import com.google.common.util.concurrent.MoreExecutors;
  21 import com.google.common.util.concurrent.SettableFuture;
  22 import java.util.Collection;
  23 import java.util.Map;
  24 import java.util.concurrent.atomic.AtomicReference;
  25 import java.util.function.Supplier;
  26 import org.eclipse.jdt.annotation.NonNull;
  27 import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
  28 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
  30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  31 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
  32 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  33 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
  34 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  35 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  36 import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
  37 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  38 import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
  39 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
  40 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
  41 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
  42 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
  43 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry;
  44 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
  45 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  46 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  47 import org.opendaylight.mdsal.common.api.CommitInfo;
  48 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadOperations;
  49 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  50 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  51 import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
  52 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  53 import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
  54 import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
  55 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  56 import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
  57 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  58 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  59 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  60
  61 /**
  62  * Adapter between the legacy controller API-based DOMDataBroker and the mdsal API-based DOMDataBroker.
  63  *
  64  * @author Thomas Pantelis
  65  */
  66 public abstract class AbstractLegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMDataBroker {
  67     private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
  68             new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
  69         @Override
  70         protected TransactionCommitFailedException newWithCause(final String message, final Throwable cause) {
  71             if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
  72                 return new OptimisticLockFailedException(cause.getMessage(), cause.getCause());
  73             } else if (cause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
  74                 Throwable rootCause = cause.getCause();
  75                 if (rootCause instanceof org.opendaylight.mdsal.common.api.DataStoreUnavailableException) {
  76                     rootCause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause.getCause());
  77                 }
  78
  79                 return new TransactionCommitFailedException(cause.getMessage(), rootCause);
  80             }
  81
  82             return new TransactionCommitFailedException(message, cause);
  83         }
  84     };
  85
  86     private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate;
  87     private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
  88
  89     public AbstractLegacyDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
  90         this.delegate = delegate;
  91
  92         ClassToInstanceMap<org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension> delegateExtensions =
  93                 delegate.getExtensions();
  94
  95         Builder<DOMDataBrokerExtension> extBuilder = ImmutableClassToInstanceMap.builder();
  96         final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService delegateTreeChangeService =
  97                 (org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService) delegateExtensions.get(
  98                         org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService.class);
  99         if (delegateTreeChangeService != null) {
 100             extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
 101                 @Override
 102                 public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
 103                         final DOMDataTreeIdentifier treeId, final L listener) {
 104                     final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener delegateListener;
 105                     if (listener instanceof ClusteredDOMDataTreeChangeListener) {
 106                         delegateListener = new ClusteredProxyListener(listener);
 107                     } else {
 108                         delegateListener = new ProxyListener(listener);
 109                     }
 110
 111                     final ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> reg =
 112                         delegateTreeChangeService.registerDataTreeChangeListener(treeId.toMdsal(), delegateListener);
 113
 114                     return new ListenerRegistration<L>() {
 115                         @Override
 116                         public L getInstance() {
 117                             return listener;
 118                         }
 119
 120                         @Override
 121                         public void close() {
 122                             reg.close();
 123                         }
 124                     };
 125                 }
 126             });
 127         }
 128
 129         final org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry delegateCohortRegistry =
 130                 (org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry) delegateExtensions.get(
 131                         org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry.class);
 132         if (delegateCohortRegistry != null) {
 133             extBuilder.put(DOMDataTreeCommitCohortRegistry.class, delegateCohortRegistry::registerCommitCohort);
 134         }
 135
 136         extensions = extBuilder.build();
 137     }
 138
 139     @Override
 140     protected org.opendaylight.mdsal.dom.api.DOMDataBroker delegate() {
 141         return delegate;
 142     }
 143
 144     @Override
 145     public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
 146         return extensions;
 147     }
 148
 149     @Override
 150     public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
 151         return new DOMDataReadOnlyTransactionAdapter(delegate().newReadOnlyTransaction());
 152     }
 153
 154     @Override
 155     public DOMDataReadWriteTransaction newReadWriteTransaction() {
 156         return new DOMDataTransactionAdapter(delegate().newReadWriteTransaction());
 157     }
 158
 159     @Override
 160     public DOMDataWriteTransaction newWriteOnlyTransaction() {
 161         return new DOMDataTransactionAdapter(delegate().newWriteOnlyTransaction());
 162     }
 163
 164     @Override
 165     public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
 166         AtomicReference<DOMTransactionChain> legacyChain = new AtomicReference<>();
 167         DOMTransactionChainListener delegateListener =
 168                 new DOMTransactionChainListener() {
 169             @Override
 170             @SuppressWarnings("rawtypes")
 171             public void onTransactionChainFailed(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain,
 172                     final DOMDataTreeTransaction transaction, final Throwable cause) {
 173                 listener.onTransactionChainFailed(legacyChain.get(),
 174                     (AsyncTransaction) () -> transaction.getIdentifier(),
 175                         cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
 176             }
 177
 178             @Override
 179             public void onTransactionChainSuccessful(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain) {
 180                 listener.onTransactionChainSuccessful(legacyChain.get());
 181             }
 182         };
 183
 184         final org.opendaylight.mdsal.dom.api.DOMTransactionChain delegateChain =
 185                 delegate().createTransactionChain(delegateListener);
 186         legacyChain.set(new DOMTransactionChain() {
 187             @Override
 188             public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
 189                 return new DOMDataReadOnlyTransactionAdapter(wrapException(delegateChain::newReadOnlyTransaction));
 190             }
 191
 192             @Override
 193             public DOMDataReadWriteTransaction newReadWriteTransaction() {
 194                 return new DOMDataTransactionAdapter(wrapException(delegateChain::newReadWriteTransaction));
 195             }
 196
 197             @Override
 198             public DOMDataWriteTransaction newWriteOnlyTransaction() {
 199                 return new DOMDataTransactionAdapter(wrapException(delegateChain::newWriteOnlyTransaction));
 200             }
 201
 202             @Override
 203             public void close() {
 204                 delegateChain.close();
 205             }
 206         });
 207
 208         return legacyChain.get();
 209     }
 210
 211     abstract org.opendaylight.mdsal.dom.api.DOMTransactionChain createDelegateChain(
 212             DOMTransactionChainListener listener);
 213
 214     static <T> T wrapException(final Supplier<T> supplier) {
 215         try {
 216             return supplier.get();
 217         } catch (DOMTransactionChainClosedException e) {
 218             throw new TransactionChainClosedException("Transaction chain already closed", e);
 219         }
 220     }
 221
 222     private static class DOMDataTransactionAdapter implements DOMDataReadWriteTransaction {
 223         private final DOMDataTreeReadOperations readDelegate;
 224         private final DOMDataTreeWriteTransaction writeDelegate;
 225         private final Object identifier;
 226
 227         DOMDataTransactionAdapter(final @NonNull DOMDataTreeReadOperations readDelegate, final Object identifier) {
 228             this.readDelegate = requireNonNull(readDelegate);
 229             this.identifier = requireNonNull(identifier);
 230             this.writeDelegate = null;
 231         }
 232
 233         DOMDataTransactionAdapter(final @NonNull DOMDataTreeWriteTransaction writeDelegate) {
 234             this.writeDelegate = requireNonNull(writeDelegate);
 235             this.identifier = writeDelegate.getIdentifier();
 236             this.readDelegate = null;
 237         }
 238
 239         DOMDataTransactionAdapter(final @NonNull DOMDataTreeReadWriteTransaction rwDelegate) {
 240             this.readDelegate = requireNonNull(rwDelegate);
 241             this.writeDelegate = rwDelegate;
 242             this.identifier = rwDelegate.getIdentifier();
 243         }
 244
 245         DOMDataTreeReadOperations readDelegate() {
 246             return readDelegate;
 247         }
 248
 249         DOMDataTreeWriteTransaction writeDelegate() {
 250             return writeDelegate;
 251         }
 252
 253         @Override
 254         public Object getIdentifier() {
 255             return identifier;
 256         }
 257
 258         @Override
 259         public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
 260                 final YangInstanceIdentifier path) {
 261             return MappingCheckedFuture.create(readDelegate().read(store.toMdsal(), path).transform(
 262                 Optional::fromJavaUtil, MoreExecutors.directExecutor()), ReadFailedExceptionAdapter.INSTANCE);
 263         }
 264
 265         @Override
 266         public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
 267                 final YangInstanceIdentifier path) {
 268             return MappingCheckedFuture.create(readDelegate().exists(store.toMdsal(), path),
 269                     ReadFailedExceptionAdapter.INSTANCE);
 270         }
 271
 272         @Override
 273         public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
 274             writeDelegate().delete(store.toMdsal(), path);
 275         }
 276
 277         @Override
 278         public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
 279                 final NormalizedNode<?, ?> data) {
 280             writeDelegate().put(store.toMdsal(), path, data);
 281         }
 282
 283         @Override
 284         public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
 285                 final NormalizedNode<?, ?> data) {
 286             writeDelegate().merge(store.toMdsal(), path, data);
 287         }
 288
 289         @Override
 290         public boolean cancel() {
 291             return writeDelegate().cancel();
 292         }
 293
 294         @Override
 295         public FluentFuture<? extends CommitInfo> commit() {
 296             final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
 297             writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
 298                 @Override
 299                 public void onSuccess(final CommitInfo result) {
 300                     resultFuture.set(result);
 301                 }
 302
 303                 @Override
 304                 public void onFailure(final Throwable ex) {
 305                     if (ex instanceof Exception) {
 306                         resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
 307                     } else {
 308                         resultFuture.setException(ex);
 309                     }
 310                 }
 311             }, MoreExecutors.directExecutor());
 312
 313             return FluentFuture.from(resultFuture);
 314         }
 315     }
 316
 317     private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
 318         private final DOMDataTreeReadTransaction transaction;
 319         private final DOMDataTransactionAdapter adapter;
 320
 321         DOMDataReadOnlyTransactionAdapter(final DOMDataTreeReadTransaction delegateTx) {
 322             this.transaction = requireNonNull(delegateTx);
 323             adapter = new DOMDataTransactionAdapter(delegateTx, transaction.getIdentifier());
 324         }
 325
 326         @Override
 327         public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
 328                 final YangInstanceIdentifier path) {
 329             return adapter.read(store, path);
 330         }
 331
 332         @Override
 333         public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
 334                 final YangInstanceIdentifier path) {
 335             return adapter.exists(store, path);
 336         }
 337
 338         @Override
 339         public Object getIdentifier() {
 340             return adapter.getIdentifier();
 341         }
 342
 343         @Override
 344         public void close() {
 345             transaction.close();
 346         }
 347     }
 348
 349     private static class ProxyListener extends ForwardingObject
 350             implements org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener {
 351         private final DOMDataTreeChangeListener delegate;
 352
 353         ProxyListener(final DOMDataTreeChangeListener delegate) {
 354             this.delegate = requireNonNull(delegate);
 355         }
 356
 357         @Override
 358         public void onDataTreeChanged(Collection<DataTreeCandidate> changes) {
 359             delegate.onDataTreeChanged(changes);
 360         }
 361
 362         @Override
 363         protected DOMDataTreeChangeListener delegate() {
 364             return delegate;
 365         }
 366     }
 367
 368     private static final class ClusteredProxyListener extends ProxyListener
 369             implements org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener {
 370
 371         ClusteredProxyListener(DOMDataTreeChangeListener delegate) {
 372             super(delegate);
 373         }
 374     }
 375 }