* 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.clustering.it.provider.impl;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.Futures;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.LinkedHashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicLong;
-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.TransactionChain;
-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.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.WriteTransactionsInput;
import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.WriteTransactionsOutput;
import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.WriteTransactionsOutputBuilder;
import org.slf4j.LoggerFactory;
public abstract class WriteTransactionsHandler extends AbstractTransactionHandler {
- private static final class Chained extends WriteTransactionsHandler implements TransactionChainListener {
+ private static final class Chained extends WriteTransactionsHandler implements DOMTransactionChainListener {
private final SplittableRandom random = new SplittableRandom();
private final DOMTransactionChain transactionChain;
}
@Override
- DOMDataWriteTransaction createTransaction() {
+ DOMDataTreeWriteTransaction createTransaction() {
return transactionChain.newWriteOnlyTransaction();
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final DOMTransactionChain chain, final DOMDataTreeTransaction transaction,
+ final Throwable cause) {
// This is expected to happen frequently in isolation testing.
LOG.debug("Transaction chain failed.", cause);
// Do not return RPC here, rely on transaction failure to call runFailed.
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
LOG.debug("Transaction chain closed successfully.");
}
}
Simple(final DOMDataBroker dataBroker, final YangInstanceIdentifier idListItem,
final WriteTransactionsInput input) {
super(idListItem, input);
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
}
@Override
- DOMDataWriteTransaction createTransaction() {
+ DOMDataTreeWriteTransaction createTransaction() {
return dataBroker.newWriteOnlyTransaction();
}
WriteTransactionsHandler(final YangInstanceIdentifier idListItem, final WriteTransactionsInput input) {
super(input);
- this.idListItem = Preconditions.checkNotNull(idListItem);
+ this.idListItem = requireNonNull(idListItem);
}
public static ListenableFuture<RpcResult<WriteTransactionsOutput>> start(final DOMDataBroker domDataBroker,
final WriteTransactionsInput input) {
- LOG.debug("Starting write-transactions.");
+ LOG.info("Starting write transactions with input {}", input);
final String id = input.getId();
final MapEntryNode entry = ImmutableNodes.mapEntryBuilder(ID_INT, ID, id)
.withChild(ImmutableNodes.mapNodeBuilder(ID_INT).build())
.build();
- DOMDataWriteTransaction tx = domDataBroker.newWriteOnlyTransaction();
+ DOMDataTreeWriteTransaction tx = domDataBroker.newWriteOnlyTransaction();
// write only the top list
tx.merge(LogicalDatastoreType.CONFIGURATION, ID_INTS_YID, containerNode);
try {
- tx.submit().checkedGet(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
- } catch (final OptimisticLockFailedException e) {
- // when multiple write-transactions are executed concurrently we need to ignore this.
- // If we get optimistic lock here it means id-ints already exists and we can continue.
- LOG.debug("Got an optimistic lock when writing initial top level list element.", e);
- } catch (final TransactionCommitFailedException | TimeoutException e) {
- LOG.warn("Unable to ensure IdInts list for id: {} exists.", id, e);
- return Futures.immediateFuture(RpcResultBuilder.<WriteTransactionsOutput>failed()
- .withError(RpcError.ErrorType.APPLICATION, "Unexpected-exception", e).build());
+ tx.commit().get(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+ } catch (InterruptedException | TimeoutException e) {
+ LOG.error("Error writing top-level path {}: {}", ID_INTS_YID, containerNode, e);
+ return RpcResultBuilder.<WriteTransactionsOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ String.format("Could not start write transactions - error writing top-level path %s: %s",
+ ID_INTS_YID, containerNode), e).buildFuture();
+ } catch (ExecutionException e) {
+ final Throwable cause = e.getCause();
+ if (cause instanceof OptimisticLockFailedException) {
+ // when multiple write-transactions are executed concurrently we need to ignore this.
+ // If we get optimistic lock here it means id-ints already exists and we can continue.
+ LOG.debug("Got an optimistic lock when writing initial top level list element.", e);
+ } else {
+ LOG.error("Error writing top-level path {}: {}", ID_INTS_YID, containerNode, e);
+ return RpcResultBuilder.<WriteTransactionsOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ String.format("Could not start write transactions - error writing top-level path %s: %s",
+ ID_INTS_YID, containerNode), e).buildFuture();
+ }
}
tx = domDataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.CONFIGURATION, idListItem, entry);
try {
- tx.submit().get(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+ tx.commit().get(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
- LOG.warn("Unable to ensure IdInts list for id: {} exists.", id, e);
- return Futures.immediateFuture(RpcResultBuilder.<WriteTransactionsOutput>failed()
- .withError(RpcError.ErrorType.APPLICATION, "Unexpected-exception", e).build());
+ LOG.error("Error writing top-level path {}: {}", idListItem, entry, e);
+ return RpcResultBuilder.<WriteTransactionsOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ String.format("Could not start write transactions - error writing list entry path %s: %s",
+ idListItem, entry), e).buildFuture();
}
LOG.debug("Filling the item list with initial values.");
final YangInstanceIdentifier itemListId = idListItem.node(ITEM);
tx = domDataBroker.newWriteOnlyTransaction();
- tx.put(LogicalDatastoreType.CONFIGURATION, itemListId, mapBuilder.build());
+ final MapNode itemListNode = mapBuilder.build();
+ tx.put(LogicalDatastoreType.CONFIGURATION, itemListId, itemListNode);
try {
- tx.submit().get(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+ tx.commit().get(INIT_TX_TIMEOUT_SECONDS, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
- LOG.warn("Unable to fill the initial item list.", e);
- return Futures.immediateFuture(RpcResultBuilder.<WriteTransactionsOutput>failed()
- .withError(RpcError.ErrorType.APPLICATION, "Unexpected-exception", e).build());
+ LOG.error("Error filling initial item list path {}: {}", itemListId, itemListNode, e);
+ return RpcResultBuilder.<WriteTransactionsOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ String.format("Could not start write transactions - error filling initial item list path %s: %s",
+ itemListId, itemListNode), e).buildFuture();
}
final WriteTransactionsHandler handler;
- if (input.isChainedTransactions()) {
+ if (input.getChainedTransactions()) {
handler = new Chained(domDataBroker, idListItem, input);
} else {
handler = new Simple(domDataBroker, idListItem, input);
}
handler.doStart();
+
+ LOG.info("Write transactions successfully started");
return handler.completionFuture;
}
@Override
- ListenableFuture<Void> execWrite(final long txId) {
+ FluentFuture<? extends @NonNull CommitInfo> execWrite(final long txId) {
final int i = nextInt(MAX_ITEM + 1);
final YangInstanceIdentifier entryId =
- idListItem.node(ITEM).node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(ITEM, NUMBER, i));
+ idListItem.node(ITEM).node(YangInstanceIdentifier.NodeIdentifierWithPredicates.of(ITEM, NUMBER, i));
- final DOMDataWriteTransaction tx = createTransaction();
+ final DOMDataTreeWriteTransaction tx = createTransaction();
if (usedValues.contains(i)) {
LOG.debug("Deleting item: {}", i);
usedValues.add(i);
}
- return tx.submit();
+ return tx.commit();
}
@Override
.withError(RpcError.ErrorType.APPLICATION, cause).build());
}
- abstract DOMDataWriteTransaction createTransaction();
+ abstract DOMDataTreeWriteTransaction createTransaction();
abstract int nextInt(int bound);
}