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