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