import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return delegate.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- logOps();
- return delegate.commit();
- }
-
@Override
public Object getIdentifier() {
return delegate.getIdentifier();
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return super.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- closeTracker.removeFromTrackedRegistry();
- return super.commit();
- }
-
@Override
public boolean cancel() {
closeTracker.removeFromTrackedRegistry();
package org.opendaylight.controller.md.sal.trace.dom.impl;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;
-import org.opendaylight.yangtools.yang.common.RpcResult;
class TracingWriteTransaction extends AbstractTracingWriteTransaction
implements CloseTracked<TracingWriteTransaction> {
return super.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- closeTracker.removeFromTrackedRegistry();
- return super.commit();
- }
-
@Override
public boolean cancel() {
closeTracker.removeFromTrackedRegistry();
import com.google.common.base.Optional;
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
/**
* Utility {@link ReadWriteTransaction} implementation which forwards all interface method
public void delete(LogicalDatastoreType store, InstanceIdentifier<?> path) {
delegate.delete(store, path);
}
-
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegate.commit();
- }
}
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
/**
* Utility {@link WriteTransaction} implementation which forwards all interface method
return delegate.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegate.commit();
- }
-
@Override
public Object getIdentifier() {
return delegate.getIdentifier();
package org.opendaylight.controller.md.sal.binding.impl;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataTransaction;
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
doDelete(store, path);
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return AbstractDataTransaction.convertToLegacyCommitFuture(submit());
- }
-
@Override
public CheckedFuture<Void,TransactionCommitFailedException> submit() {
return doSubmit();
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.Map;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.MountPoint;
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
return false;
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return null;
- }
-
@Override
public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
throw new UnsupportedOperationException();
* For a detailed explanation of how transaction are isolated and how transaction-local
* changes are committed to global data tree, see
* {@link AsyncReadTransaction}, {@link AsyncWriteTransaction},
- * {@link AsyncReadWriteTransaction} and {@link AsyncWriteTransaction#commit()}.
+ * {@link AsyncReadWriteTransaction} and {@link AsyncWriteTransaction#submit()}.
*
*
* <p>
* For a detailed explanation of how transaction are isolated and how transaction-local
* changes are committed to global data tree, see
* {@link AsyncReadTransaction}, {@link AsyncWriteTransaction},
- * {@link AsyncReadWriteTransaction} and {@link AsyncWriteTransaction#commit()}.
+ * {@link AsyncReadWriteTransaction} and {@link AsyncWriteTransaction#submit()}.
*
* <p>
* It is strongly recommended to use the type of transaction, which
* Preconditions for mutation of data tree are captured from the snapshot of
* data tree state, when the transaction is allocated. If data was
* changed during transaction in an incompatible way then the commit of this transaction
- * will fail. See {@link AsyncWriteTransaction#commit()} for more
+ * will fail. See {@link AsyncWriteTransaction#submit()} for more
* details about conflicting and not-conflicting changes and
* failure scenarios.
*
* Preconditions for mutation of data tree are captured from the snapshot of
* data tree state, when the transaction is allocated. If data was
* changed during transaction in an incompatible way then the commit of this transaction
- * will fail. See {@link AsyncWriteTransaction#commit()} for more
+ * will fail. See {@link AsyncWriteTransaction#submit()} for more
* details about conflicting and not-conflicting changes and
* failure scenarios.
*
* Since this transaction does not provide a view of the data it SHOULD BE
* used only by callers which are exclusive writers (exporters of data)
* to the subtree they modify. This prevents optimistic
- * lock failures as described in {@link AsyncWriteTransaction#commit()}.
+ * lock failures as described in {@link AsyncWriteTransaction#submit()}.
*
* <p>
* Exclusivity of writers to particular subtree SHOULD BE enforced by
* Cancels the transaction.
*
* <p>
- * Transactions can only be cancelled if it's status is
- * {@link TransactionStatus#NEW} or {@link TransactionStatus#SUBMITED}
+ * Transactions can only be cancelled if it's state is new or submitted.
*
* <p>
- * Invoking cancel() on {@link TransactionStatus#FAILED} or
- * {@link TransactionStatus#CANCELED} will have no effect, and transaction
+ * Invoking cancel() on a failed or cancelled transaction will have no effect, and transaction
* is considered cancelled.
*
* <p>
- * Invoking cancel() on finished transaction (future returned by {@link #submit()}
- * already completed with {@link TransactionStatus#COMMITED}) will always
+ * Invoking cancel() on a finished transaction (future returned by {@link #submit()} already completed will always
* fail (return false).
*
* @return <tt>false</tt> if the task could not be cancelled, typically because it has already completed normally
* @param path
* Data object path
* @throws IllegalStateException
- * if the transaction is no longer {@link TransactionStatus#NEW}
+ * if the transaction as already been submitted or cancelled
*/
void delete(LogicalDatastoreType store, P path);
* {@link IllegalStateException}.
*
* <p>
- * The transaction is marked as {@link TransactionStatus#SUBMITED} and
- * enqueued into the data store back-end for processing.
+ * The transaction is marked as submitted and enqueued into the data store back-end for processing.
*
* <p>
* Whether or not the commit is successful is determined by versioning
* derived from TransactionCommitFailedException.
*
* @throws IllegalStateException
- * if the transaction is not {@link TransactionStatus#NEW}
+ * if the transaction is not new
*/
CheckedFuture<Void,TransactionCommitFailedException> submit();
* @deprecated Use {@link #submit()} instead.
*/
@Deprecated
- ListenableFuture<RpcResult<TransactionStatus>> commit();
-
+ default ListenableFuture<RpcResult<TransactionStatus>> commit() {
+ throw new UnsupportedOperationException("commit() is deprecated, use submit() instead");
+ }
}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.sal.common.api.data;
-
-import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.yangtools.concepts.Path;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-
-/**
- * Deprecated.
- *
- * @deprecated Replaced by {@link AsyncWriteTransaction}
- */
-@Deprecated
-public interface DataModification<P extends Path<P>, D> extends DataChange<P, D>, DataReader<P, D> {
- /**
- * Returns transaction identifier.
- *
- * @return Transaction identifier
- */
- Object getIdentifier();
-
- TransactionStatus getStatus();
-
- /**
- * Store a piece of data at specified path. This acts as a merge operation,
- * which is to say that any pre-existing data which is not explicitly
- * overwritten will be preserved. This means that if you store a container,
- * its child lists will be merged. Performing the following put operations:
- *
- * <p>
- * 1) container { list [ a ] }
- * 2) container { list [ b ] }
- *
- * <p>
- * will result in the following data being present:
- *
- * <p>
- * container { list [ a, b ] }
- *
- * <p>
- * This also means that storing the container will preserve any augmentations
- * which have been attached to it.
- *
- * <p>
- * If you require an explicit replace operation, perform
- * {@link removeOperationalData} first.
- */
- void putOperationalData(P path, D data);
-
- /**
- * Store a piece of data at specified path. This acts as a merge operation,
- * which is to say that any pre-existing data which is not explicitly
- * overwritten will be preserved. This means that if you store a container,
- * its child lists will be merged. Performing the following put operations:
- *
- * <p>
- * 1) container { list [ a ] }
- * 2) container { list [ b ] }
- *
- * <p>
- * will result in the following data being present:
- *
- * <p>
- * container { list [ a, b ] }
- *
- * <p>
- * This also means that storing the container will preserve any augmentations
- * which have been attached to it.
- *
- * <p>
- * If you require an explicit replace operation, perform
- * {@link removeConfigurationData} first.
- */
- void putConfigurationData(P path, D data);
-
- void removeOperationalData(P path);
-
- void removeConfigurationData(P path);
-
- /**
- * Initiates a two-phase commit of modification.
- *
- * <p>
- * The successful commit changes the state of the system and may affect
- * several components.
- *
- * <p>
- * The effects of successful commit of data are described in the
- * specifications and YANG models describing the Provider components of
- * controller. It is assumed that Consumer has an understanding of this
- * changes.
- *
- * @return Result of the Commit, containing success information or list of
- * encountered errors, if commit was not successful. The Future
- * blocks until {@link TransactionStatus#COMMITED} or
- * {@link TransactionStatus#FAILED} is reached.
- */
- Future<RpcResult<TransactionStatus>> commit();
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.sal.common.impl.service;
-
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Deprecated
-public abstract class AbstractDataTransaction {
- private static final Logger LOG = LoggerFactory.getLogger(AbstractDataTransaction.class);
- private static final ListenableFuture<RpcResult<TransactionStatus>> SUCCESS_FUTURE =
- Futures.immediateFuture(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
-
- public static ListenableFuture<RpcResult<TransactionStatus>> convertToLegacyCommitFuture(
- final CheckedFuture<Void,TransactionCommitFailedException> from) {
- return Futures.transformAsync(from, input -> SUCCESS_FUTURE);
- }
-}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;
import org.opendaylight.controller.cluster.databroker.AbstractDOMBroker;
import org.opendaylight.controller.cluster.datastore.DistributedDataStoreInterface;
import org.opendaylight.controller.cluster.datastore.compat.LegacyDOMStoreAdapter;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
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.common.impl.service.AbstractDataTransaction;
import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public CheckedFuture<Void, TransactionCommitFailedException> submit() {
return MappingCheckedFuture.create(writeDelegate().submit(), SUBMIT_EX_MAPPER);
}
-
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return AbstractDataTransaction.convertToLegacyCommitFuture(submit());
- }
}
private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
return future.cancel(false);
}
- @Deprecated
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return AbstractDataTransaction.convertToLegacyCommitFuture(submit());
- }
-
@Override
@SuppressWarnings("checkstyle:illegalcatch")
public CheckedFuture<Void, TransactionCommitFailedException> submit() {
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
/**
* Transaction context. Tracks the relationship with the backend transaction.
*/
final class PingPongTransaction implements FutureCallback<Void> {
private final CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
- private final ListenableFuture<RpcResult<TransactionStatus>> commitFuture;
private final DOMDataReadWriteTransaction delegate;
private final SettableFuture<Void> future;
private DOMDataReadWriteTransaction frontendTransaction;
this.delegate = Preconditions.checkNotNull(delegate);
future = SettableFuture.create();
submitFuture = new PingPongFuture(future);
- commitFuture = AbstractDataTransaction.convertToLegacyCommitFuture(submitFuture);
}
DOMDataReadWriteTransaction getTransaction() {
return submitFuture;
}
- ListenableFuture<RpcResult<TransactionStatus>> getCommitFuture() {
- return commitFuture;
- }
-
@Override
public void onSuccess(final Void result) {
future.set(result);
protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
return toStringHelper.add("delegate", delegate);
}
-}
\ No newline at end of file
+}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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.ReadFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.controller.md.sal.dom.spi.ForwardingDOMDataReadWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
return tx.getSubmitFuture();
}
- @Deprecated
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- readyTransaction(tx);
- isOpen = false;
- return tx.getCommitFuture();
- }
-
@Override
public boolean cancel() {
if (isOpen) {
import java.util.Queue;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
// FIXME explicitly enforce just one subtree requirement
@NotThreadSafe
class ShardedDOMDataBrokerDelegatingReadWriteTransaction implements DOMDataReadWriteTransaction {
- private static final ListenableFuture<RpcResult<TransactionStatus>> SUCCESS_FUTURE = Futures
- .immediateFuture(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
-
private final DOMDataReadOnlyTransaction readTxDelegate;
private final DOMDataWriteTransaction writeTxDelegate;
private final Object txIdentifier;
return writeTxDelegate.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return Futures.transformAsync(submit(), input -> SUCCESS_FUTURE, MoreExecutors.directExecutor());
- }
-
@Override
public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.broker.impl.TransactionCommitFailedExceptionMapper;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
class ShardedDOMDataBrokerDelegatingWriteTransaction implements DOMDataWriteTransaction {
- private static final ListenableFuture<RpcResult<TransactionStatus>> SUCCESS_FUTURE = Futures
- .immediateFuture(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
-
private final DOMDataTreeWriteTransaction delegateTx;
private final Object txIdentifier;
return Futures.makeChecked(delegateTx.submit(), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return Futures.transformAsync(submit(), input -> SUCCESS_FUTURE);
- }
-
@Override
public Object getIdentifier() {
return txIdentifier;
import com.google.common.base.Optional;
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public CheckedFuture<Void, TransactionCommitFailedException> submit() {
return delegate().submit();
}
-
- @Override
- @Deprecated
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegate().commit();
- }
}
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public CheckedFuture<Void, TransactionCommitFailedException> submit() {
return delegate().submit();
}
-
- @Override
- @Deprecated
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegate().commit();
- }
}