Proxy MD-SAL interfaces in DOMMountPointServiceImpl

[controller.git] / opendaylight / md-sal / sal-dom-compat / src / main / java / org / opendaylight / controller / sal / core / compat / LegacyDOMDataBrokerAdapter.java

diff --git a/opendaylight/md-sal/sal-dom-compat/src/main/java/org/opendaylight/controller/sal/core/compat/LegacyDOMDataBrokerAdapter.java b/opendaylight/md-sal/sal-dom-compat/src/main/java/org/opendaylight/controller/sal/core/compat/LegacyDOMDataBrokerAdapter.java
index 8f4d8fe3b5a02fd07a1d9a9121e5be567fb0607b..b9cd447a9cc9a62b726bf95e56534fd7e66fd241 100644 (file)
--- a/opendaylight/md-sal/sal-dom-compat/src/main/java/org/opendaylight/controller/sal/core/compat/LegacyDOMDataBrokerAdapter.java
+++ b/opendaylight/md-sal/sal-dom-compat/src/main/java/org/opendaylight/controller/sal/core/compat/LegacyDOMDataBrokerAdapter.java
@@ -20,6 +20,7 @@ import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
@@ -27,6 +28,7 @@ import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableEx
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
@@ -43,7 +45,10 @@ import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.mdsal.common.api.CommitInfo;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@@ -58,7 +63,7 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
     private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
             new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
         @Override
-        protected TransactionCommitFailedException newWithCause(String message, Throwable cause) {
+        protected TransactionCommitFailedException newWithCause(final String message, final Throwable cause) {
             if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
                 return new OptimisticLockFailedException(cause.getMessage(), cause.getCause());
             } else if (cause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
@@ -77,7 +82,7 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
     private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate;
     private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
 
-    public LegacyDOMDataBrokerAdapter(org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
+    public LegacyDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
         this.delegate = delegate;
 
         ClassToInstanceMap<org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension> delegateExtensions =
@@ -91,7 +96,7 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
             extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
                 @Override
                 public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
-                        DOMDataTreeIdentifier treeId, final L listener) {
+                        final DOMDataTreeIdentifier treeId, final L listener) {
                     final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener delegateListener;
                     if (listener instanceof ClusteredDOMDataTreeChangeListener) {
                         delegateListener = (org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener)
@@ -101,9 +106,7 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
                     }
 
                     final ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> reg =
-                        delegateTreeChangeService.registerDataTreeChangeListener(
-                            new org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier(convert(treeId.getDatastoreType()),
-                                    treeId.getRootIdentifier()), delegateListener);
+                        delegateTreeChangeService.registerDataTreeChangeListener(treeId.toMdsal(), delegateListener);
 
                     return new ListenerRegistration<L>() {
                         @Override
@@ -158,19 +161,19 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
     @Override
     public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
         AtomicReference<DOMTransactionChain> legacyChain = new AtomicReference<>();
-        org.opendaylight.mdsal.common.api.TransactionChainListener delegateListener =
-                new org.opendaylight.mdsal.common.api.TransactionChainListener() {
-            @SuppressWarnings("rawtypes")
+        DOMTransactionChainListener delegateListener =
+                new DOMTransactionChainListener() {
             @Override
-            public void onTransactionChainFailed(final org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain,
-                    final org.opendaylight.mdsal.common.api.AsyncTransaction<?, ?> transaction, final Throwable cause) {
+            @SuppressWarnings("rawtypes")
+            public void onTransactionChainFailed(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain,
+                    final DOMDataTreeTransaction transaction, final Throwable cause) {
                 listener.onTransactionChainFailed(legacyChain.get(),
-                        (AsyncTransaction) () -> transaction.getIdentifier(),
-                            cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
+                    (AsyncTransaction) () -> transaction.getIdentifier(),
+                        cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
             }
 
             @Override
-            public void onTransactionChainSuccessful(org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain) {
+            public void onTransactionChainSuccessful(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain) {
                 listener.onTransactionChainSuccessful(legacyChain.get());
             }
         };
@@ -180,17 +183,17 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
         legacyChain.set(new DOMTransactionChain() {
             @Override
             public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
-                return new DOMDataReadOnlyTransactionAdapter(delegateChain.newReadOnlyTransaction());
+                return new DOMDataReadOnlyTransactionAdapter(wrapException(delegateChain::newReadOnlyTransaction));
             }
 
             @Override
             public DOMDataReadWriteTransaction newReadWriteTransaction() {
-                return new DOMDataTransactionAdapter(delegateChain.newReadWriteTransaction());
+                return new DOMDataTransactionAdapter(wrapException(delegateChain::newReadWriteTransaction));
             }
 
             @Override
             public DOMDataWriteTransaction newWriteOnlyTransaction() {
-                return new DOMDataTransactionAdapter(delegateChain.newWriteOnlyTransaction());
+                return new DOMDataTransactionAdapter(wrapException(delegateChain::newWriteOnlyTransaction));
             }
 
             @Override
@@ -202,8 +205,12 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
         return legacyChain.get();
     }
 
-    private static org.opendaylight.mdsal.common.api.LogicalDatastoreType convert(LogicalDatastoreType datastoreType) {
-        return org.opendaylight.mdsal.common.api.LogicalDatastoreType.valueOf(datastoreType.name());
+    static <T> T wrapException(final Supplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (DOMTransactionChainClosedException e) {
+            throw new TransactionChainClosedException("Transaction chain already closed", e);
+        }
     }
 
     private static class DOMDataTransactionAdapter implements DOMDataReadWriteTransaction {
@@ -211,19 +218,19 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
         private final DOMDataTreeWriteTransaction writeDelegate;
         private final Object identifier;
 
-        DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadTransaction readDelegate) {
+        DOMDataTransactionAdapter(@Nonnull final DOMDataTreeReadTransaction readDelegate) {
             this.readDelegate = Preconditions.checkNotNull(readDelegate);
             this.identifier = readDelegate.getIdentifier();
             this.writeDelegate = null;
         }
 
-        DOMDataTransactionAdapter(@Nonnull DOMDataTreeWriteTransaction writeDelegate) {
+        DOMDataTransactionAdapter(@Nonnull final DOMDataTreeWriteTransaction writeDelegate) {
             this.writeDelegate = Preconditions.checkNotNull(writeDelegate);
             this.identifier = writeDelegate.getIdentifier();
             this.readDelegate = null;
         }
 
-        DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadWriteTransaction rwDelegate) {
+        DOMDataTransactionAdapter(@Nonnull final DOMDataTreeReadWriteTransaction rwDelegate) {
             this.readDelegate = Preconditions.checkNotNull(rwDelegate);
             this.writeDelegate = rwDelegate;
             this.identifier = readDelegate.getIdentifier();
@@ -243,32 +250,34 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
         }
 
         @Override
-        public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
-                YangInstanceIdentifier path) {
-            return MappingCheckedFuture.create(readDelegate().read(convert(store), path).transform(
+        public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+                final YangInstanceIdentifier path) {
+            return MappingCheckedFuture.create(readDelegate().read(store.toMdsal(), path).transform(
                 Optional::fromJavaUtil, MoreExecutors.directExecutor()), ReadFailedExceptionAdapter.INSTANCE);
         }
 
         @Override
-        public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
-                YangInstanceIdentifier path) {
-            return MappingCheckedFuture.create(readDelegate().exists(convert(store), path),
+        public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+                final YangInstanceIdentifier path) {
+            return MappingCheckedFuture.create(readDelegate().exists(store.toMdsal(), path),
                     ReadFailedExceptionAdapter.INSTANCE);
         }
 
         @Override
-        public void delete(LogicalDatastoreType store, YangInstanceIdentifier path) {
-            writeDelegate().delete(convert(store), path);
+        public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+            writeDelegate().delete(store.toMdsal(), path);
         }
 
         @Override
-        public void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
-            writeDelegate().put(convert(store), path, data);
+        public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+                final NormalizedNode<?, ?> data) {
+            writeDelegate().put(store.toMdsal(), path, data);
         }
 
         @Override
-        public void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
-            writeDelegate().merge(convert(store), path, data);
+        public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+                final NormalizedNode<?, ?> data) {
+            writeDelegate().merge(store.toMdsal(), path, data);
         }
 
         @Override
@@ -281,12 +290,12 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
             final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
             writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
                 @Override
-                public void onSuccess(CommitInfo result) {
+                public void onSuccess(final CommitInfo result) {
                     resultFuture.set(result);
                 }
 
                 @Override
-                public void onFailure(Throwable ex) {
+                public void onFailure(final Throwable ex) {
                     if (ex instanceof Exception) {
                         resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
                     } else {
@@ -302,19 +311,19 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
     private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
         private final DOMDataTransactionAdapter adapter;
 
-        DOMDataReadOnlyTransactionAdapter(DOMDataTreeReadTransaction delegateTx) {
+        DOMDataReadOnlyTransactionAdapter(final DOMDataTreeReadTransaction delegateTx) {
             adapter = new DOMDataTransactionAdapter(delegateTx);
         }
 
         @Override
-        public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
-                YangInstanceIdentifier path) {
+        public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+                final YangInstanceIdentifier path) {
             return adapter.read(store, path);
         }
 
         @Override
-        public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
-                YangInstanceIdentifier path) {
+        public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+                final YangInstanceIdentifier path) {
             return adapter.exists(store, path);
         }