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