import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
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;
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;
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;
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) {
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 =
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)
}
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
@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());
}
};
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
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 {
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();
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
- YangInstanceIdentifier path) {
- return MappingCheckedFuture.create(readDelegate().read(convert(store), path).transformAsync(
- optional -> Futures.immediateFuture(Optional.fromJavaUtil(optional)), MoreExecutors.directExecutor()),
- ReadFailedExceptionAdapter.INSTANCE);
+ 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
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 {
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);
}