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