opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/compat/LegacyDOMStoreAdapter.java

   1 /*
   2  * Copyright (c) 2016 Brocade Communications 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.controller.cluster.datastore.compat;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.collect.ForwardingObject;
  13 import com.google.common.util.concurrent.CheckedFuture;
  14 import com.google.common.util.concurrent.Futures;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import com.google.common.util.concurrent.MoreExecutors;
  17 import javax.annotation.Nonnull;
  18 import org.opendaylight.controller.cluster.datastore.DistributedDataStoreInterface;
  19 import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
  20 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  21 import org.opendaylight.controller.sal.core.compat.ReadFailedExceptionAdapter;
  22 import org.opendaylight.controller.sal.core.spi.data.DOMStore;
  23 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
  24 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
  25 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
  26 import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
  27 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  30
  31 /**
  32  * Adapter between the legacy controller API-based DOMStore and the mdsal API-based DOMStore.
  33  *
  34  * @author Thomas Pantelis
  35  */
  36 public class LegacyDOMStoreAdapter extends ForwardingObject implements DOMStore, AutoCloseable {
  37     private final DistributedDataStoreInterface delegate;
  38
  39     public LegacyDOMStoreAdapter(DistributedDataStoreInterface delegate) {
  40         this.delegate = delegate;
  41     }
  42
  43     @Override
  44     public DOMStoreReadTransaction newReadOnlyTransaction() {
  45         return new DOMStoreTransactionAdapter(delegate().newReadOnlyTransaction());
  46     }
  47
  48     @Override
  49     public DOMStoreWriteTransaction newWriteOnlyTransaction() {
  50         return new DOMStoreTransactionAdapter(delegate().newWriteOnlyTransaction());
  51     }
  52
  53     @Override
  54     public DOMStoreReadWriteTransaction newReadWriteTransaction() {
  55         return new DOMStoreTransactionAdapter(delegate().newReadWriteTransaction());
  56     }
  57
  58     @Override
  59     public DOMStoreTransactionChain createTransactionChain() {
  60         final org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain delegateChain =
  61                 delegate().createTransactionChain();
  62         return new DOMStoreTransactionChain() {
  63             @Override
  64             public DOMStoreReadTransaction newReadOnlyTransaction() {
  65                 return new DOMStoreTransactionAdapter(delegateChain.newReadOnlyTransaction());
  66             }
  67
  68             @Override
  69             public DOMStoreWriteTransaction newWriteOnlyTransaction() {
  70                 return new DOMStoreTransactionAdapter(delegateChain.newWriteOnlyTransaction());
  71             }
  72
  73             @Override
  74             public DOMStoreReadWriteTransaction newReadWriteTransaction() {
  75                 return new DOMStoreTransactionAdapter(delegateChain.newReadWriteTransaction());
  76             }
  77
  78             @Override
  79             public void close() {
  80                 delegateChain.close();
  81             }
  82         };
  83     }
  84
  85     @Override
  86     public void close() {
  87     }
  88
  89     @Override
  90     protected DistributedDataStoreInterface delegate() {
  91         return delegate;
  92     }
  93
  94     private static class DOMStoreTransactionAdapter implements DOMStoreReadWriteTransaction {
  95         private final org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction readDelegate;
  96         private final org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction writeDelegate;
  97         private final Object identifier;
  98
  99         DOMStoreTransactionAdapter(@Nonnull org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction readDelegate) {
 100             this.readDelegate = Preconditions.checkNotNull(readDelegate);
 101             this.identifier = readDelegate.getIdentifier();
 102             this.writeDelegate = null;
 103         }
 104
 105         DOMStoreTransactionAdapter(
 106                 @Nonnull org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction writeDelegate) {
 107             this.writeDelegate = Preconditions.checkNotNull(writeDelegate);
 108             this.identifier = writeDelegate.getIdentifier();
 109             this.readDelegate = null;
 110         }
 111
 112         DOMStoreTransactionAdapter(
 113                 @Nonnull org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction rwDelegate) {
 114             this.readDelegate = Preconditions.checkNotNull(rwDelegate);
 115             this.writeDelegate = rwDelegate;
 116             this.identifier = readDelegate.getIdentifier();
 117         }
 118
 119         @Override
 120         public Object getIdentifier() {
 121             return identifier;
 122         }
 123
 124         @Override
 125         public void close() {
 126             if (writeDelegate != null) {
 127                 writeDelegate.close();
 128             } else {
 129                 readDelegate.close();
 130             }
 131         }
 132
 133         @Override
 134         public void write(YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
 135             writeDelegate.write(path, data);
 136         }
 137
 138         @Override
 139         public void merge(YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
 140             writeDelegate.merge(path, data);
 141         }
 142
 143         @Override
 144         public void delete(YangInstanceIdentifier path) {
 145             writeDelegate.delete(path);
 146         }
 147
 148         @Override
 149         public DOMStoreThreePhaseCommitCohort ready() {
 150             final org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort cohort = writeDelegate.ready();
 151             return new DOMStoreThreePhaseCommitCohort() {
 152                 @Override
 153                 public ListenableFuture<Boolean> canCommit() {
 154                     return cohort.canCommit();
 155                 }
 156
 157                 @Override
 158                 public ListenableFuture<Void> preCommit() {
 159                     return cohort.preCommit();
 160                 }
 161
 162                 @Override
 163                 public ListenableFuture<Void> commit() {
 164                     return cohort.commit();
 165                 }
 166
 167                 @Override
 168                 public ListenableFuture<Void> abort() {
 169                     return cohort.abort();
 170                 }
 171             };
 172         }
 173
 174         @Override
 175         public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(YangInstanceIdentifier path) {
 176             return MappingCheckedFuture.create(readDelegate.read(path).transformAsync(optional ->
 177                 Futures.immediateFuture(Optional.fromJavaUtil(optional)), MoreExecutors.directExecutor()),
 178                 ReadFailedExceptionAdapter.INSTANCE);
 179         }
 180
 181         @Override
 182         public CheckedFuture<Boolean, ReadFailedException> exists(YangInstanceIdentifier path) {
 183             return MappingCheckedFuture.create(readDelegate.exists(path), ReadFailedExceptionAdapter.INSTANCE);
 184         }
 185     }
 186 }