</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-api</artifactId>
</dependency>
<dependency>
*/
package org.opendaylight.restconf.common.context;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
public SchemaContext getSchemaContext() {
return schemaContext;
}
-
}
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response.Status;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
+import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
status = null;
}
+ public static RestconfDocumentedException decodeAndThrow(final String message,
+ final OperationFailedException cause) {
+ for (final RpcError error : cause.getErrorList()) {
+ if (error.getErrorType() == RpcError.ErrorType.TRANSPORT
+ && error.getTag().equals(ErrorTag.RESOURCE_DENIED.getTagValue())) {
+ throw new RestconfDocumentedException(error.getMessage(), ErrorType.TRANSPORT,
+ ErrorTag.RESOURCE_DENIED_TRANSPORT, cause);
+ }
+ }
+ throw new RestconfDocumentedException(message, cause, cause.getErrorList());
+ }
+
private static List<RestconfError> convertToRestconfErrors(final Collection<? extends RpcError> rpcErrors) {
- final List<RestconfError> errorList = Lists.newArrayList();
+ final List<RestconfError> errorList = new ArrayList<>();
if (rpcErrors != null) {
for (RpcError rpcError : rpcErrors) {
errorList.add(new RestconfError(rpcError));
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-connector-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-spi</artifactId>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-common-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
<artifactId>jaxrs-api</artifactId>
<scope>provided</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-spi</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-codec-gson</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
import com.google.common.base.Optional;
import javax.annotation.Nonnull;
import javax.ws.rs.core.MultivaluedMap;
-
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
-
/**
* Provides restconf CRUD operations via code with input/output data in JSON format.
*
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import javax.annotation.Nonnull;
-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.DOMDataReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
this.outstanding = total;
}
- static BatchedExistenceCheck start(final DOMDataReadTransaction readTx,
+ static BatchedExistenceCheck start(final DOMDataTreeReadTransaction readTx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier parentPath,
final Collection<? extends NormalizedNode<?, ?>> children) {
final BatchedExistenceCheck ret = new BatchedExistenceCheck(children.size());
*/
package org.opendaylight.netconf.sal.restconf.impl;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
-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 java.io.Closeable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.CountDownLatch;
-import javax.annotation.Nullable;
+import java.util.concurrent.ExecutionException;
import javax.ws.rs.core.Response.Status;
-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.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.streams.listeners.ListenerAdapter;
import org.opendaylight.netconf.sal.streams.listeners.NotificationListenerAdapter;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.util.DataChangeScope;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
* @return read date
*/
public NormalizedNode<?, ?> readConfigurationData(final YangInstanceIdentifier path, final String withDefa) {
- try (DOMDataReadOnlyTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
return readDataViaTransaction(tx, CONFIGURATION, path, withDefa);
}
}
final String withDefa) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
- try (DOMDataReadOnlyTransaction tx = domDataBrokerService.get().newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = domDataBrokerService.get().newReadOnlyTransaction()) {
return readDataViaTransaction(tx, CONFIGURATION, path, withDefa);
}
}
* @return read data
*/
public NormalizedNode<?, ?> readOperationalData(final YangInstanceIdentifier path) {
- try (DOMDataReadOnlyTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
return readDataViaTransaction(tx, OPERATIONAL, path);
}
}
public NormalizedNode<?, ?> readOperationalData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
- try (DOMDataReadOnlyTransaction tx = domDataBrokerService.get().newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = domDataBrokerService.get().newReadOnlyTransaction()) {
return readDataViaTransaction(tx, OPERATIONAL, path);
}
}
Preconditions.checkNotNull(path);
Preconditions.checkNotNull(payload);
- final DOMDataReadWriteTransaction newReadWriteTransaction = this.domDataBroker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction newReadWriteTransaction = this.domDataBroker.newReadWriteTransaction();
final Status status = readDataViaTransaction(newReadWriteTransaction, CONFIGURATION, path) != null ? Status.OK
: Status.CREATED;
- final CheckedFuture<Void, TransactionCommitFailedException> future = putDataViaTransaction(
+ final FluentFuture<? extends CommitInfo> future = putDataViaTransaction(
newReadWriteTransaction, CONFIGURATION, path, payload, globalSchema, insert, point);
return new PutResult(status, future);
}
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
- final DOMDataReadWriteTransaction newReadWriteTransaction =
+ final DOMDataTreeReadWriteTransaction newReadWriteTransaction =
domDataBrokerService.get().newReadWriteTransaction();
final Status status = readDataViaTransaction(newReadWriteTransaction, CONFIGURATION, path) != null
? Status.OK : Status.CREATED;
- final CheckedFuture<Void, TransactionCommitFailedException> future = putDataViaTransaction(
+ final FluentFuture<? extends CommitInfo> future = putDataViaTransaction(
newReadWriteTransaction, CONFIGURATION, path, payload, mountPoint.getSchemaContext(), insert,
point);
return new PutResult(status, future);
// get new transaction and schema context on server or on mounted device
final SchemaContext schemaContext;
- final DOMDataReadWriteTransaction patchTransaction;
+ final DOMDataTreeReadWriteTransaction patchTransaction;
if (mountPoint == null) {
schemaContext = patchContext.getInstanceIdentifierContext().getSchemaContext();
patchTransaction = this.domDataBroker.newReadWriteTransaction();
// if no errors commit transaction
final CountDownLatch waiter = new CountDownLatch(1);
- final CheckedFuture<Void, TransactionCommitFailedException> future = patchTransaction.submit();
+ final FluentFuture<? extends CommitInfo> future = patchTransaction.commit();
final PatchStatusContextHelper status = new PatchStatusContextHelper();
- Futures.addCallback(future, new FutureCallback<Void>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
status.setStatus(new PatchStatusContext(patchContext.getPatchId(), ImmutableList.copyOf(editCollection),
true, null));
waiter.countDown();
}
// POST configuration
- public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPost(
+ public FluentFuture<? extends CommitInfo> commitConfigurationDataPost(
final SchemaContext globalSchema, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final String insert, final String point) {
return postDataViaTransaction(this.domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload,
globalSchema, insert, point);
}
- public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPost(
+ public FluentFuture<? extends CommitInfo> commitConfigurationDataPost(
final DOMMountPoint mountPoint, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final String insert, final String point) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
}
// DELETE configuration
- public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataDelete(
- final YangInstanceIdentifier path) {
+ public FluentFuture<? extends CommitInfo> commitConfigurationDataDelete(final YangInstanceIdentifier path) {
return deleteDataViaTransaction(this.domDataBroker.newReadWriteTransaction(), CONFIGURATION, path);
}
- public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataDelete(
+ public FluentFuture<? extends CommitInfo> commitConfigurationDataDelete(
final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
}
// RPC
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type,
- final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
if (this.rpcService == null) {
throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
}
}
final YangInstanceIdentifier path = listener.getPath();
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- this.domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = this.domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
if (changeService == null) {
throw new UnsupportedOperationException("DOMDataBroker does not support the DOMDataTreeChangeService"
+ this.domDataBroker);
listener.setRegistration(registration);
}
- private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
+ private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataTreeReadTransaction transaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
return readDataViaTransaction(transaction, datastore, path, null);
}
- private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
+ private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataTreeReadTransaction transaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final String withDefa) {
LOG.trace("Read {} via Restconf: {}", datastore.name(), path);
try {
- final Optional<NormalizedNode<?, ?>> optional = transaction.read(datastore, path).checkedGet();
+ final Optional<NormalizedNode<?, ?>> optional = transaction.read(datastore, path).get();
return !optional.isPresent() ? null : withDefa == null ? optional.get() :
prepareDataByParamWithDef(optional.get(), path, withDefa);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException e) {
LOG.warn("Error reading {} from datastore {}", path, datastore.name(), e);
- for (final RpcError error : e.getErrorList()) {
- if (error.getErrorType() == RpcError.ErrorType.TRANSPORT
- && error.getTag().equals(ErrorTag.RESOURCE_DENIED.getTagValue())) {
- throw new RestconfDocumentedException(
- error.getMessage(),
- ErrorType.TRANSPORT,
- ErrorTag.RESOURCE_DENIED_TRANSPORT, e);
- }
- }
- throw new RestconfDocumentedException("Error reading data.", e, e.getErrorList());
+ throw new RestconfDocumentedException("Error reading data.", e);
+ } catch (ExecutionException e) {
+ LOG.warn("Error reading {} from datastore {}", path, datastore.name(), e);
+ throw RestconfDocumentedException.decodeAndThrow("Error reading data.", Throwables.getCauseAs(e,
+ ReadFailedException.class));
}
}
/**
* POST data and submit transaction {@link DOMDataReadWriteTransaction}.
*/
- private CheckedFuture<Void, TransactionCommitFailedException> postDataViaTransaction(
- final DOMDataReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
+ private FluentFuture<? extends CommitInfo> postDataViaTransaction(
+ final DOMDataTreeReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String insert, final String point) {
LOG.trace("POST {} via Restconf: {} with payload {}", datastore.name(), path, payload);
postData(rwTransaction, datastore, path, payload, schemaContext, insert, point);
- return rwTransaction.submit();
+ return rwTransaction.commit();
}
/**
* POST data and do NOT submit transaction {@link DOMDataReadWriteTransaction}.
*/
private void postDataWithinTransaction(
- final DOMDataReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
+ final DOMDataTreeReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
LOG.trace("POST {} within Restconf Patch: {} with payload {}", datastore.name(), path, payload);
postData(rwTransaction, datastore, path, payload, schemaContext, null, null);
}
- private void postData(final DOMDataReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
+ private void postData(final DOMDataTreeReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String insert, final String point) {
if (insert == null) {
}
}
- private void insertWithPointLeafListPost(final DOMDataReadWriteTransaction rwTransaction,
+ private void insertWithPointLeafListPost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String point, final OrderedLeafSetNode<?> readLeafList,
final boolean before) {
}
}
- private void insertWithPointListPost(final DOMDataReadWriteTransaction rwTransaction,
+ private void insertWithPointListPost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String point, final MapNode readList, final boolean before) {
throw new RestconfDocumentedException("Insert parameter can be used only with list or leaf-list");
}
- private static void makeNormalPost(final DOMDataReadWriteTransaction rwTransaction,
+ private static void makeNormalPost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext) {
final Collection<? extends NormalizedNode<?, ?>> children;
}
}
- private static void simplePostPut(final DOMDataReadWriteTransaction rwTransaction,
+ private static void simplePostPut(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext) {
checkItemDoesNotExists(rwTransaction, datastore, path);
rwTransaction.put(datastore, path, payload);
}
- private static boolean doesItemExist(final DOMDataReadWriteTransaction rwTransaction,
+ private static boolean doesItemExist(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
try {
- return rwTransaction.exists(store, path).checkedGet();
- } catch (ReadFailedException e) {
+ return rwTransaction.exists(store, path).get();
+ } catch (InterruptedException e) {
+ rwTransaction.cancel();
+ throw new RestconfDocumentedException("Could not determine the existence of path " + path, e);
+ } catch (ExecutionException e) {
rwTransaction.cancel();
- throw new RestconfDocumentedException("Could not determine the existence of path " + path,
- e, e.getErrorList());
+ throw RestconfDocumentedException.decodeAndThrow("Could not determine the existence of path " + path,
+ Throwables.getCauseAs(e, ReadFailedException.class));
}
}
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private static void checkItemExists(final DOMDataReadWriteTransaction rwTransaction,
+ private static void checkItemExists(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
if (!doesItemExist(rwTransaction, store, path)) {
LOG.trace("Operation via Restconf was not executed because data at {} does not exist", path);
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private static void checkItemDoesNotExists(final DOMDataReadWriteTransaction rwTransaction,
+ private static void checkItemDoesNotExists(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
if (doesItemExist(rwTransaction, store, path)) {
LOG.trace("Operation via Restconf was not executed because data at {} already exists", path);
* @param insert
* insert
*/
- private CheckedFuture<Void, TransactionCommitFailedException> putDataViaTransaction(
- final DOMDataReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
+ private FluentFuture<? extends CommitInfo> putDataViaTransaction(
+ final DOMDataTreeReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String insert, final String point) {
LOG.trace("Put {} via Restconf: {} with payload {}", datastore.name(), path, payload);
putData(readWriteTransaction, datastore, path, payload, schemaContext, insert, point);
- return readWriteTransaction.submit();
+ return readWriteTransaction.commit();
}
/**
* PUT data and do NOT submit {@link DOMDataReadWriteTransaction}.
*/
private void putDataWithinTransaction(
- final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
+ final DOMDataTreeReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
LOG.trace("Put {} within Restconf Patch: {} with payload {}", datastore.name(), path, payload);
putData(writeTransaction, datastore, path, payload, schemaContext, null, null);
}
// FIXME: This is doing correct put for container and list children, not sure if this will work for choice case
- private void putData(final DOMDataReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
+ private void putData(final DOMDataTreeReadWriteTransaction rwTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String insert, final String point) {
if (insert == null) {
}
}
- private void insertWithPointLeafListPut(final DOMDataWriteTransaction tx,
+ private void insertWithPointLeafListPut(final DOMDataTreeWriteTransaction tx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String point, final OrderedLeafSetNode<?> readLeafList,
final boolean before) {
}
}
- private void insertWithPointListPut(final DOMDataWriteTransaction tx, final LogicalDatastoreType datastore,
+ private void insertWithPointListPut(final DOMDataTreeWriteTransaction tx, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String point, final OrderedMapNode readList, final boolean before) {
tx.delete(datastore, path.getParent());
}
}
- private static void makePut(final DOMDataWriteTransaction tx, final LogicalDatastoreType datastore,
+ private static void makePut(final DOMDataTreeWriteTransaction tx, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
if (payload instanceof MapNode) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
}
private static void simplePut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
- final DOMDataWriteTransaction tx, final SchemaContext schemaContext, final NormalizedNode<?, ?> payload) {
+ final DOMDataTreeWriteTransaction tx, final SchemaContext schemaContext,
+ final NormalizedNode<?, ?> payload) {
ensureParentsByMerge(datastore, path, tx, schemaContext);
tx.put(datastore, path, payload);
}
- private static CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
- final DOMDataReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
+ private static FluentFuture<? extends CommitInfo> deleteDataViaTransaction(
+ final DOMDataTreeReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path) {
LOG.trace("Delete {} via Restconf: {}", datastore.name(), path);
checkItemExists(readWriteTransaction, datastore, path);
readWriteTransaction.delete(datastore, path);
- return readWriteTransaction.submit();
+ return readWriteTransaction.commit();
}
- private static void deleteDataWithinTransaction(final DOMDataWriteTransaction tx,
+ private static void deleteDataWithinTransaction(final DOMDataTreeWriteTransaction tx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
LOG.trace("Delete {} within Restconf Patch: {}", datastore.name(), path);
tx.delete(datastore, path);
}
- private static void mergeDataWithinTransaction(final DOMDataWriteTransaction tx,
+ private static void mergeDataWithinTransaction(final DOMDataTreeWriteTransaction tx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext) {
LOG.trace("Merge {} within Restconf Patch: {} with payload {}", datastore.name(), path, payload);
}
private static void ensureParentsByMerge(final LogicalDatastoreType store,
- final YangInstanceIdentifier normalizedPath, final DOMDataWriteTransaction tx,
+ final YangInstanceIdentifier normalizedPath, final DOMDataTreeWriteTransaction tx,
final SchemaContext schemaContext) {
final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
YangInstanceIdentifier rootNormalizedPath = null;
*/
package org.opendaylight.netconf.sal.restconf.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import javax.ws.rs.core.Response.Status;
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.common.impl.util.compat.DataNormalizer;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.netconf.sal.rest.api.Draft02;
private volatile SchemaContext globalSchema;
private volatile DataNormalizer dataNormalizer;
- private ControllerContext(DOMSchemaService schemaService, DOMMountPointService mountService,
- DOMYangTextSourceProvider yangTextSourceProvider) {
+ private ControllerContext(final DOMSchemaService schemaService, final DOMMountPointService mountService,
+ final DOMYangTextSourceProvider yangTextSourceProvider) {
this.mountService = mountService;
this.yangTextSourceProvider = yangTextSourceProvider;
listenerRegistration = schemaService.registerSchemaContextListener(this);
}
- public static ControllerContext newInstance(DOMSchemaService schemaService, DOMMountPointService mountService,
- DOMSchemaService domSchemaService) {
+ public static ControllerContext newInstance(final DOMSchemaService schemaService,
+ final DOMMountPointService mountService, final DOMSchemaService domSchemaService) {
final DOMYangTextSourceProvider yangTextSourceProvider = domSchemaService.getExtensions()
.getInstance(DOMYangTextSourceProvider.class);
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.UriInfo;
-
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.netconf.sal.rest.impl.JsonToPatchBodyReader;
private final ControllerContext controllerContext;
private final RestconfService restconfService;
- public JSONRestconfServiceImpl(ControllerContext controllerContext, RestconfService restconfService) {
+ public JSONRestconfServiceImpl(final ControllerContext controllerContext, final RestconfService restconfService) {
this.controllerContext = controllerContext;
this.restconfService = restconfService;
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Optional<String> subscribeToStream(@Nonnull String identifier,
- MultivaluedMap<String, String> params) throws OperationFailedException {
+ public Optional<String> subscribeToStream(@Nonnull final String identifier,
+ final MultivaluedMap<String, String> params) throws OperationFailedException {
//Note: We use http://127.0.0.1 because the Uri parser requires something there though it does nothing
String uri = new StringBuilder("http://127.0.0.1:8081/restconf/streams/stream/").append(identifier).toString();
- MultivaluedMap queryParams = (params != null) ? params : new MultivaluedHashMap<String, String>();
+ MultivaluedMap queryParams = params != null ? params : new MultivaluedHashMap<String, String>();
UriInfo uriInfo = new SimpleUriInfo(uri, queryParams);
String jsonRes = null;
*/
package org.opendaylight.netconf.sal.restconf.impl;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import javax.ws.rs.core.Response.Status;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
/**
* Wrapper for status and future of PUT operation.
- *
*/
public class PutResult {
private final Status status;
- private final CheckedFuture<Void, TransactionCommitFailedException> future;
+ private final FluentFuture<? extends CommitInfo> future;
/**
* Wrap status and future by constructor - make this immutable.
* @param future
* result of submit of PUT operation
*/
- public PutResult(final Status status, final CheckedFuture<Void, TransactionCommitFailedException> future) {
+ public PutResult(final Status status, final FluentFuture<? extends CommitInfo> future) {
this.status = status;
this.future = future;
}
/**
* Get future.
*
- * @return {@link CheckedFuture} result
+ * @return {@link FluentFuture} result
*/
- public CheckedFuture<Void, TransactionCommitFailedException> getFutureOfPutData() {
+ public FluentFuture<? extends CommitInfo> getFutureOfPutData() {
return this.future;
}
}
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.StringModuleInstanceIdentifierCodec;
import org.opendaylight.restconf.common.util.IdentityValuesDTO;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.IdentityValue;
identityValue.setPredicates(predicates);
} else if (pathArgument instanceof NodeWithValue && identityValue != null) {
final List<Predicate> predicates = new ArrayList<>();
- final String value = String.valueOf(((NodeWithValue) pathArgument).getValue());
+ final String value = String.valueOf(((NodeWithValue<?>) pathArgument).getValue());
predicates.add(new Predicate(null, value));
identityValue.setPredicates(predicates);
}
* 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.netconf.sal.restconf.impl;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.CharMatcher;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.net.URI;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-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.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+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.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
import org.opendaylight.netconf.sal.streams.listeners.ListenerAdapter;
}
try {
- result.getFutureOfPutData().checkedGet();
- return Response.status(result.getStatus()).build();
- } catch (final TransactionCommitFailedException e) {
- if (e instanceof OptimisticLockFailedException) {
+ result.getFutureOfPutData().get();
+ } catch (final InterruptedException e) {
+ LOG.debug("Update failed for {}", identifier, e);
+ throw new RestconfDocumentedException(e.getMessage(), e);
+ } catch (final ExecutionException e) {
+ final TransactionCommitFailedException failure = Throwables.getCauseAs(e,
+ TransactionCommitFailedException.class);
+ if (failure instanceof OptimisticLockFailedException) {
if (--tries <= 0) {
LOG.debug("Got OptimisticLockFailedException on last try - failing {}", identifier);
- throw new RestconfDocumentedException(e.getMessage(), e, e.getErrorList());
+ throw new RestconfDocumentedException(e.getMessage(), e, failure.getErrorList());
}
LOG.debug("Got OptimisticLockFailedException - trying again {}", identifier);
- } else {
- LOG.debug("Update failed for {}", identifier, e);
- throw new RestconfDocumentedException(e.getMessage(), e, e.getErrorList());
+ continue;
}
+
+ LOG.debug("Update failed for {}", identifier, e);
+ throw RestconfDocumentedException.decodeAndThrow(e.getMessage(), failure);
}
+
+ return Response.status(result.getStatus()).build();
}
}
"Point parameter can be used only with 'after' or 'before' values of Insert parameter.");
}
- CheckedFuture<Void, TransactionCommitFailedException> future;
+ FluentFuture<? extends CommitInfo> future;
if (mountPoint != null) {
future = this.broker.commitConfigurationDataPost(mountPoint, normalizedII, payload.getData(), insert,
point);
}
try {
- future.checkedGet();
- } catch (final RestconfDocumentedException e) {
- throw e;
- } catch (final TransactionCommitFailedException e) {
+ future.get();
+ } catch (final InterruptedException e) {
LOG.info("Error creating data {}", uriInfo != null ? uriInfo.getPath() : "", e);
- throw new RestconfDocumentedException(e.getMessage(), e, e.getErrorList());
+ throw new RestconfDocumentedException(e.getMessage(), e);
+ } catch (final ExecutionException e) {
+ LOG.info("Error creating data {}", uriInfo != null ? uriInfo.getPath() : "", e);
+ throw RestconfDocumentedException.decodeAndThrow(e.getMessage(), Throwables.getCauseAs(e,
+ TransactionCommitFailedException.class));
}
LOG.trace("Successfuly created data.");
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
- final CheckedFuture<Void, TransactionCommitFailedException> future;
+ final FluentFuture<? extends CommitInfo> future;
if (mountPoint != null) {
future = this.broker.commitConfigurationDataDelete(mountPoint, normalizedII);
} else {
}
try {
- future.checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ future.get();
+ } catch (final InterruptedException e) {
+ throw new RestconfDocumentedException(e.getMessage(), e);
+ } catch (final ExecutionException e) {
final Optional<Throwable> searchedException = Iterables.tryFind(Throwables.getCausalChain(e),
- Predicates.instanceOf(ModifiedNodeDoesNotExistException.class));
+ Predicates.instanceOf(ModifiedNodeDoesNotExistException.class)).toJavaUtil();
if (searchedException.isPresent()) {
- throw new RestconfDocumentedException("Data specified for delete doesn't exist.",
- ErrorType.APPLICATION, ErrorTag.DATA_MISSING, e);
+ throw new RestconfDocumentedException("Data specified for delete doesn't exist.", ErrorType.APPLICATION,
+ ErrorTag.DATA_MISSING, e);
}
- final String errMsg = "Error while deleting data";
- LOG.info(errMsg, e);
- throw new RestconfDocumentedException(e.getMessage(), e, e.getErrorList());
+ throw RestconfDocumentedException.decodeAndThrow(e.getMessage(), Throwables.getCauseAs(e,
+ TransactionCommitFailedException.class));
}
return Response.status(Status.OK).build();
return uriToWebsocketServerBuilder.replacePath(streamName).build();
}
- private String getWsScheme(final UriInfo uriInfo) {
+ private static String getWsScheme(final UriInfo uriInfo) {
URI uri = uriInfo.getAbsolutePath();
if (uri == null) {
return "ws";
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import org.json.XML;
-import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
+import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.yang.common.QName;
import java.util.Collection;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
</cm:property-placeholder>
<reference id="schemaService" interface="org.opendaylight.mdsal.dom.api.DOMSchemaService"/>
- <reference id="domRpcService" interface="org.opendaylight.controller.md.sal.dom.api.DOMRpcService"/>
- <reference id="domMountPointService" interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"/>
- <reference id="domNotificationService" interface="org.opendaylight.controller.md.sal.dom.api.DOMNotificationService"/>
- <reference id="domDataBroker" interface="org.opendaylight.controller.md.sal.dom.api.DOMDataBroker"
+ <reference id="domRpcService" interface="org.opendaylight.mdsal.dom.api.DOMRpcService"/>
+ <reference id="domMountPointService" interface="org.opendaylight.mdsal.dom.api.DOMMountPointService"/>
+ <reference id="domNotificationService" interface="org.opendaylight.mdsal.dom.api.DOMNotificationService"/>
+ <reference id="domDataBroker" interface="org.opendaylight.mdsal.dom.api.DOMDataBroker"
ext:filter="(type=@{databroker-service-type})"/>
<reference id="domSchemaService" interface="org.opendaylight.mdsal.dom.api.DOMSchemaService"/>
* 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.rest.common;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableClassToInstanceMap;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.rest.impl.test.providers.TestJsonBodyWriter;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
throw new UnsupportedOperationException("Test utility class");
}
- public static ControllerContext newControllerContext(SchemaContext schemaContext) {
+ public static ControllerContext newControllerContext(final SchemaContext schemaContext) {
return newControllerContext(schemaContext, null);
}
- public static ControllerContext newControllerContext(SchemaContext schemaContext, DOMMountPoint mountInstance) {
+ public static ControllerContext newControllerContext(final SchemaContext schemaContext,
+ final DOMMountPoint mountInstance) {
final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
if (mountInstance != null) {
doReturn(schemaContext).when(mountInstance).getSchemaContext();
- doReturn(Optional.fromNullable(mountInstance)).when(mockMountService)
- .getMountPoint(any(YangInstanceIdentifier.class));
+ doReturn(Optional.ofNullable(mountInstance)).when(mockMountService).getMountPoint(
+ any(YangInstanceIdentifier.class));
}
DOMSchemaService mockSchemaService = mock(DOMSchemaService.class);
* 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.sal.rest.impl.test.providers;
import static org.junit.Assert.assertNotNull;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.api.RestconfConstants;
import org.opendaylight.netconf.sal.rest.impl.AbstractIdentifierAwareJaxRsProvider;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
protected final ControllerContext controllerContext;
protected final MediaType mediaType;
- protected AbstractBodyReaderTest(SchemaContext schemaContext, DOMMountPoint mountInstance) {
+ protected AbstractBodyReaderTest(final SchemaContext schemaContext, final DOMMountPoint mountInstance) {
this.mediaType = getMediaType();
controllerContext = TestRestconfUtils.newControllerContext(schemaContext, mountInstance);
* 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.sal.rest.impl.test.providers;
import static org.junit.Assert.assertNotNull;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.yangtools.yang.common.QName;
* 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.sal.rest.impl.test.providers;
import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.JsonToPatchBodyReader;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.patch.PatchContext;
* 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.sal.rest.impl.test.providers;
import static org.junit.Assert.assertEquals;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.XmlNormalizedNodeBodyReader;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
* 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.sal.rest.impl.test.providers;
import static org.junit.Assert.assertEquals;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.XmlToPatchBodyReader;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.patch.PatchContext;
import static org.mockito.Mockito.when;
import com.google.common.collect.Iterables;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.io.FileNotFoundException;
import java.util.List;
import javax.ws.rs.core.Response.Status;
when(brokerFacade.commitConfigurationDataPut(any(SchemaContext.class), any(YangInstanceIdentifier.class),
any(NormalizedNode.class), Mockito.anyString(), Mockito.anyString()))
.thenReturn(result);
- when(result.getFutureOfPutData()).thenReturn(mock(CheckedFuture.class));
+ when(result.getFutureOfPutData()).thenReturn(mock(FluentFuture.class));
when(result.getStatus()).thenReturn(Status.OK);
}
* 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.sal.restconf.impl.test;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateBooleanFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import java.util.HashMap;
-import java.util.concurrent.Future;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-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.DOMDataBroker;
-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.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.PutResult;
@Mock
private DOMMountPoint mockMountInstance;
@Mock
- private DOMDataReadOnlyTransaction readTransaction;
+ private DOMDataTreeReadTransaction readTransaction;
@Mock
- private DOMDataWriteTransaction writeTransaction;
+ private DOMDataTreeWriteTransaction writeTransaction;
@Mock
- private DOMDataReadWriteTransaction rwTransaction;
+ private DOMDataTreeReadWriteTransaction rwTransaction;
private BrokerFacade brokerFacade;
private final NormalizedNode<?, ?> dummyNode = createDummyNode("test:module", "2014-01-09", "interfaces");
- private final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> dummyNodeInFuture =
- wrapDummyNode(this.dummyNode);
+ private final FluentFuture<Optional<NormalizedNode<?, ?>>> dummyNodeInFuture = wrapDummyNode(this.dummyNode);
private final QName qname = TestUtils.buildQName("interfaces","test:module", "2014-01-09");
private final SchemaPath type = SchemaPath.create(true, this.qname);
private final YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(this.qname).build();
when(this.domDataBroker.newReadOnlyTransaction()).thenReturn(this.readTransaction);
when(this.domDataBroker.newWriteOnlyTransaction()).thenReturn(this.writeTransaction);
when(this.domDataBroker.newReadWriteTransaction()).thenReturn(this.rwTransaction);
- HashMap extensions = new HashMap();
- extensions.put(DOMDataTreeChangeService.class, Mockito.mock(DOMDataTreeChangeService.class));
- when(this.domDataBroker.getSupportedExtensions()).thenReturn(extensions);
+ when(this.domDataBroker.getExtensions()).thenReturn(ImmutableClassToInstanceMap.of(
+ DOMDataTreeChangeService.class, Mockito.mock(DOMDataTreeChangeService.class)));
}
- private static CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> wrapDummyNode(
- final NormalizedNode<?, ?> dummyNode) {
- return Futures.immediateCheckedFuture(Optional.<NormalizedNode<?, ?>>of(dummyNode));
+ private static FluentFuture<Optional<NormalizedNode<?, ?>>> wrapDummyNode(final NormalizedNode<?, ?> dummyNode) {
+ return immediateFluentFuture(Optional.of(dummyNode));
}
- private static CheckedFuture<Boolean, ReadFailedException> wrapExistence(final Boolean exists) {
- return Futures.immediateCheckedFuture(exists);
+ private static FluentFuture<Boolean> wrapExistence(final boolean exists) {
+ return immediateBooleanFluentFuture(exists);
}
/**
RpcError.ErrorType.TRANSPORT,
ErrorTag.RESOURCE_DENIED.getTagValue(),
"Master is down. Please try again.");
- final ReadFailedException exception503 = new ReadFailedException("Read from transaction failed", error);
- doReturn(Futures.immediateFailedCheckedFuture(exception503))
+ doReturn(immediateFailedFluentFuture(new ReadFailedException("Read from transaction failed", error)))
.when(readTransaction).read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class));
try {
brokerFacade.readConfigurationData(this.instanceID, "explicit");
@Test
public void testInvokeRpc() throws Exception {
final DOMRpcResult expResult = mock(DOMRpcResult.class);
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(expResult);
- when(this.mockRpcService.invokeRpc(this.type, this.dummyNode)).thenReturn(future);
+ doReturn(immediateFluentFuture(expResult)).when(this.mockRpcService).invokeRpc(this.type, this.dummyNode);
- final CheckedFuture<DOMRpcResult, DOMRpcException> actualFuture = this.brokerFacade
- .invokeRpc(this.type, this.dummyNode);
+ final FluentFuture<DOMRpcResult> actualFuture = this.brokerFacade.invokeRpc(this.type, this.dummyNode);
assertNotNull("Future is null", actualFuture);
final DOMRpcResult actualResult = actualFuture.get();
assertSame("invokeRpc", expResult, actualResult);
@Test
public void testCommitConfigurationDataPut() throws Exception {
- @SuppressWarnings("unchecked")
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
- when(this.rwTransaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
- final Optional<NormalizedNode<?, ?>> optionalMock = mock(Optional.class);
- when(optionalMock.get()).thenReturn(null);
-
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture = Futures
- .immediateCheckedFuture(optionalMock);
- when(this.rwTransaction.read(LogicalDatastoreType.CONFIGURATION, this.instanceID)).thenReturn(readFuture);
+ doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(this.rwTransaction)
+ .read(LogicalDatastoreType.CONFIGURATION, this.instanceID);
final PutResult result = this.brokerFacade.commitConfigurationDataPut(mock(SchemaContext.class),
this.instanceID, this.dummyNode, null, null);
- final Future<Void> actualFuture = result.getFutureOfPutData();
-
- assertSame("commitConfigurationDataPut", expFuture, actualFuture);
+ assertSame("commitConfigurationDataPut", CommitInfo.emptyFluentFuture(), result.getFutureOfPutData());
final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
inOrder.verify(this.domDataBroker).newReadWriteTransaction();
inOrder.verify(this.rwTransaction).put(LogicalDatastoreType.CONFIGURATION, this.instanceID, this.dummyNode);
- inOrder.verify(this.rwTransaction).submit();
+ inOrder.verify(this.rwTransaction).commit();
}
@Test
public void testCommitConfigurationDataPost() {
- @SuppressWarnings("unchecked")
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
-
when(this.rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, this.instanceID))
.thenReturn(wrapExistence(false));
- when(this.rwTransaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
- final CheckedFuture<Void, TransactionCommitFailedException> actualFuture = this.brokerFacade
+ final FluentFuture<? extends CommitInfo> actualFuture = this.brokerFacade
.commitConfigurationDataPost(mock(SchemaContext.class), this.instanceID, this.dummyNode, null, null);
- assertSame("commitConfigurationDataPost", expFuture, actualFuture);
+ assertSame("commitConfigurationDataPost", CommitInfo.emptyFluentFuture(), actualFuture);
final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
inOrder.verify(this.domDataBroker).newReadWriteTransaction();
inOrder.verify(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.instanceID);
inOrder.verify(this.rwTransaction).put(LogicalDatastoreType.CONFIGURATION, this.instanceID, this.dummyNode);
- inOrder.verify(this.rwTransaction).submit();
+ inOrder.verify(this.rwTransaction).commit();
}
@Test(expected = RestconfDocumentedException.class)
public void testCommitConfigurationDataPostAlreadyExists() {
- final CheckedFuture<Boolean, ReadFailedException> successFuture = Futures.immediateCheckedFuture(Boolean.TRUE);
when(this.rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class)))
- .thenReturn(successFuture);
+ .thenReturn(immediateTrueFluentFuture());
try {
// Schema context is only necessary for ensuring parent structure
this.brokerFacade.commitConfigurationDataPost((SchemaContext) null, this.instanceID, this.dummyNode, null,
prepareDataForDelete(true);
// expected result
- @SuppressWarnings("unchecked")
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
- when(this.rwTransaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
// test
- final CheckedFuture<Void, TransactionCommitFailedException> actualFuture = this.brokerFacade
+ final FluentFuture<? extends CommitInfo> actualFuture = this.brokerFacade
.commitConfigurationDataDelete(this.instanceID);
// verify result and interactions
- assertSame("commitConfigurationDataDelete", expFuture, actualFuture);
+ assertSame("commitConfigurationDataDelete", CommitInfo.emptyFluentFuture(), actualFuture);
// check exists, delete, submit
final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
inOrder.verify(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.instanceID);
inOrder.verify(this.rwTransaction).delete(LogicalDatastoreType.CONFIGURATION, this.instanceID);
- inOrder.verify(this.rwTransaction).submit();
+ inOrder.verify(this.rwTransaction).commit();
}
/**
*/
private void prepareDataForDelete(final boolean assumeDataExists) {
when(this.rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, this.instanceID))
- .thenReturn(Futures.immediateCheckedFuture(new Boolean(assumeDataExists)));
+ .thenReturn(immediateBooleanFluentFuture(assumeDataExists));
}
@Test
@SuppressWarnings("unchecked")
final ListenerRegistration<ListenerAdapter> mockRegistration = mock(ListenerRegistration.class);
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- this.domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = this.domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
DOMDataTreeIdentifier loc = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, this.instanceID);
when(changeService.registerDataTreeChangeListener(eq(loc), eq(listener))).thenReturn(mockRegistration);
verify(this.domNotification, times(1)).registerNotificationListener(listener, listener.getSchemaPath());
final DOMTransactionChain transactionChain = mock(DOMTransactionChain.class);
- final DOMDataWriteTransaction wTx = mock(DOMDataWriteTransaction.class);
- final CheckedFuture<Void, TransactionCommitFailedException> checked = Futures.immediateCheckedFuture(null);
- when(wTx.submit()).thenReturn(checked);
+ final DOMDataTreeWriteTransaction wTx = mock(DOMDataTreeWriteTransaction.class);
+ doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
when(transactionChain.newWriteOnlyTransaction()).thenReturn(wTx);
// close and remove test notification listener
listener.close();
* Test Patch method on the server with no data.
*/
@Test
- @SuppressWarnings("unchecked")
public void testPatchConfigurationDataWithinTransactionServer() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = Futures.immediateCheckedFuture(null);
+ final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
when(patchContext.getData()).thenReturn(Lists.newArrayList());
- when(patchContext.getInstanceIdentifierContext()).thenReturn(identifierContext);
+ doReturn(identifierContext).when(patchContext).getInstanceIdentifierContext();
// no mount point
when(identifierContext.getMountPoint()).thenReturn(null);
- when(this.rwTransaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
* Test Patch method on mounted device with no data.
*/
@Test
- @SuppressWarnings("unchecked")
public void testPatchConfigurationDataWithinTransactionMount() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
final DOMMountPoint mountPoint = mock(DOMMountPoint.class);
final DOMDataBroker mountDataBroker = mock(DOMDataBroker.class);
- final DOMDataReadWriteTransaction transaction = mock(DOMDataReadWriteTransaction.class);
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = Futures.immediateCheckedFuture(null);
+ final DOMDataTreeReadWriteTransaction transaction = mock(DOMDataTreeReadWriteTransaction.class);
when(patchContext.getData()).thenReturn(Lists.newArrayList());
- when(patchContext.getInstanceIdentifierContext()).thenReturn(identifierContext);
+ doReturn(identifierContext).when(patchContext).getInstanceIdentifierContext();
// return mount point with broker
when(identifierContext.getMountPoint()).thenReturn(mountPoint);
when(mountPoint.getService(DOMDataBroker.class)).thenReturn(Optional.of(mountDataBroker));
when(mountDataBroker.newReadWriteTransaction()).thenReturn(transaction);
- when(transaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(transaction).commit();
final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
* Patch operation should fail with global error.
*/
@Test
- @SuppressWarnings("unchecked")
public void testPatchConfigurationDataWithinTransactionMountFail() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
final DOMMountPoint mountPoint = mock(DOMMountPoint.class);
final DOMDataBroker mountDataBroker = mock(DOMDataBroker.class);
- final DOMDataReadWriteTransaction transaction = mock(DOMDataReadWriteTransaction.class);
- final CheckedFuture<Void, TransactionCommitFailedException> expFuture = Futures.immediateCheckedFuture(null);
+ final DOMDataTreeReadWriteTransaction transaction = mock(DOMDataTreeReadWriteTransaction.class);
when(patchContext.getData()).thenReturn(Lists.newArrayList());
- when(patchContext.getInstanceIdentifierContext()).thenReturn(identifierContext);
+ doReturn(identifierContext).when(patchContext).getInstanceIdentifierContext();
when(identifierContext.getMountPoint()).thenReturn(mountPoint);
// missing broker on mounted device
- when(mountPoint.getService(DOMDataBroker.class)).thenReturn(Optional.absent());
+ when(mountPoint.getService(DOMDataBroker.class)).thenReturn(Optional.empty());
when(mountDataBroker.newReadWriteTransaction()).thenReturn(transaction);
- when(transaction.submit()).thenReturn(expFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(transaction).commit();
final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
import java.util.Set;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.common.QName;
}
public Future<RpcResult<T>> build() {
- return new DummyFuture<T>(this);
+ return new DummyFuture<>(this);
}
}
}
}
public RpcResult<T> build() {
- return new DummyRpcResult<T>(this);
+ return new DummyRpcResult<>(this);
}
-
}
-
}
* 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.sal.restconf.impl.test;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.net.URI;
import java.net.URISyntaxException;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfImpl;
@Test
public void testInvokeRpcWithNoPayloadRpc_FailNoErrors() {
- final DOMRpcException exception = new DOMRpcImplementationNotAvailableException("testExeption");
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateFailedCheckedFuture(exception);
-
final QName qname = QName.create("(http://netconfcentral.org/ns/toaster?revision=2009-11-20)cancel-toast");
final SchemaPath type = SchemaPath.create(true, qname);
- when(brokerFacade.invokeRpc(eq(type), isNull())).thenReturn(future);
+ doReturn(immediateFailedFluentFuture(new DOMRpcImplementationNotAvailableException("testExeption")))
+ .when(brokerFacade).invokeRpc(eq(type), isNull());
try {
this.restconfImpl.invokeRpc("toaster:cancel-toast", "", uriInfo);
RpcResultBuilder.newWarning(RpcError.ErrorType.RPC, "in-use", "bar",
"app-tag", null, null));
- final DOMRpcResult resutl = new DefaultDOMRpcResult(rpcErrors);
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(resutl);
-
+ final DOMRpcResult result = new DefaultDOMRpcResult(rpcErrors);
final SchemaPath path = SchemaPath.create(true,
QName.create("(http://netconfcentral.org/ns/toaster?revision=2009-11-20)cancel-toast"));
-
- when(brokerFacade.invokeRpc(eq(path), isNull())).thenReturn(future);
+ doReturn(immediateFluentFuture(result)).when(brokerFacade).invokeRpc(eq(path), isNull());
try {
this.restconfImpl.invokeRpc("toaster:cancel-toast", "", uriInfo);
public void testInvokeRpcWithNoPayload_Success() {
final NormalizedNode<?, ?> resultObj = null;
final DOMRpcResult expResult = new DefaultDOMRpcResult(resultObj);
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(expResult);
final QName qname = QName.create("(http://netconfcentral.org/ns/toaster?revision=2009-11-20)cancel-toast");
final SchemaPath path = SchemaPath.create(true, qname);
- when(brokerFacade.invokeRpc(eq(path), isNull())).thenReturn(future);
+ doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(path), isNull());
final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:cancel-toast", "", uriInfo);
assertNotNull(output);
@Ignore
public void testInvokeRpcMethodWithInput() {
final DOMRpcResult expResult = mock(DOMRpcResult.class);
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(expResult);
final SchemaPath path = SchemaPath.create(true,
QName.create("(http://netconfcentral.org/ns/toaster?revision=2009-11-20)make-toast"));
new NormalizedNodeContext(new InstanceIdentifierContext<>(null, rpcInputSchemaNode,
null, schemaContext), containerBuilder.build());
- when(brokerFacade.invokeRpc(eq(path), any(NormalizedNode.class))).thenReturn(future);
+ doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(path), any(NormalizedNode.class));
final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:make-toast", payload, uriInfo);
assertNotNull(output);
final ContainerNode container = containerBuilder.build();
final DOMRpcResult result = new DefaultDOMRpcResult(container);
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(result);
- when(brokerFacade.invokeRpc(eq(rpcDef.getPath()), isNull())).thenReturn(future);
+ doReturn(immediateFluentFuture(result)).when(brokerFacade).invokeRpc(eq(rpcDef.getPath()), isNull());
final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:testOutput", "", uriInfo);
assertNotNull(output);
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import com.google.common.base.Optional;
import com.google.common.io.Resources;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-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.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.JSONRestconfServiceImpl;
when(brokerFacade.commitConfigurationDataPut(notNull(SchemaContext.class),
notNull(YangInstanceIdentifier.class), notNull(NormalizedNode.class), isNull(), isNull()))
.thenReturn(result);
- when(result.getFutureOfPutData())
- .thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
when(result.getStatus()).thenReturn(Status.OK);
final String uriPath = "ietf-interfaces:interfaces/interface/eth0";
final String payload = loadData("/parts/ietf-interfaces_interfaces.json");
when(brokerFacade.commitMountPointDataPut(notNull(DOMMountPoint.class),
notNull(YangInstanceIdentifier.class), notNull(NormalizedNode.class), isNull(), isNull()))
.thenReturn(result);
- when(result.getFutureOfPutData()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
when(result.getStatus()).thenReturn(Status.OK);
final String uriPath = "ietf-interfaces:interfaces/yang-ext:mount/test-module:cont/cont1";
final String payload = loadData("/full-versions/testCont1Data.json");
public void testPutFailure() throws Throwable {
final PutResult result = mock(PutResult.class);
- when(result.getFutureOfPutData())
- .thenReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")));
+ doReturn(immediateFailedFluentFuture(new TransactionCommitFailedException("mock"))).when(result)
+ .getFutureOfPutData();
when(result.getStatus()).thenReturn(Status.OK);
when(brokerFacade.commitConfigurationDataPut(notNull(SchemaContext.class),
notNull(YangInstanceIdentifier.class), notNull(NormalizedNode.class), Mockito.anyString(),
@SuppressWarnings("rawtypes")
@Test
public void testPost() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(brokerFacade).commitConfigurationDataPost(
+ doReturn(CommitInfo.emptyFluentFuture()).when(brokerFacade).commitConfigurationDataPost(
any(SchemaContext.class), any(YangInstanceIdentifier.class), any(NormalizedNode.class),
isNull(), isNull());
@SuppressWarnings("rawtypes")
@Test
public void testPostBehindMountPoint() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(brokerFacade).commitConfigurationDataPost(
+ doReturn(CommitInfo.emptyFluentFuture()).when(brokerFacade).commitConfigurationDataPost(
notNull(DOMMountPoint.class), notNull(YangInstanceIdentifier.class), notNull(NormalizedNode.class),
isNull(), isNull());
@Test(expected = TransactionCommitFailedException.class)
@SuppressWarnings({ "checkstyle:IllegalThrows", "checkstyle:avoidHidingCauseException" })
public void testPostFailure() throws Throwable {
- doReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock"))).when(brokerFacade)
+ doReturn(immediateFailedFluentFuture(new TransactionCommitFailedException("mock"))).when(brokerFacade)
.commitConfigurationDataPost(any(SchemaContext.class), any(YangInstanceIdentifier.class),
any(NormalizedNode.class), isNull(), isNull());
}
}
- @SuppressWarnings("rawtypes")
@Test
public void testPatch() throws Exception {
final PatchStatusContext result = mock(PatchStatusContext.class);
assertTrue(patchResult.get().contains("\"ok\":[null]"));
}
- @SuppressWarnings("rawtypes")
@Test
public void testPatchBehindMountPoint() throws Exception {
final PatchStatusContext result = mock(PatchStatusContext.class);
@Test
public void testDelete() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(brokerFacade)
+ doReturn(CommitInfo.emptyFluentFuture()).when(brokerFacade)
.commitConfigurationDataDelete(notNull(YangInstanceIdentifier.class));
final String uriPath = "ietf-interfaces:interfaces/interface/eth0";
final SchemaPath path = SchemaPath.create(true, MAKE_TOAST_QNAME);
final DOMRpcResult expResult = new DefaultDOMRpcResult((NormalizedNode<?, ?>)null);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(brokerFacade).invokeRpc(eq(path),
- any(NormalizedNode.class));
+ doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(path), any(NormalizedNode.class));
final String uriPath = "toaster:make-toast";
final String input = loadData("/full-versions/make-toast-rpc-input.json");
final SchemaPath path = SchemaPath.create(true, CANCEL_TOAST_QNAME);
final DOMRpcResult expResult = new DefaultDOMRpcResult((NormalizedNode<?, ?>)null);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(brokerFacade).invokeRpc(any(SchemaPath.class),
- isNull());
+ doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(any(SchemaPath.class), isNull());
final String uriPath = "toaster:cancel-toast";
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_OUTPUT_QNAME))
.withChild(ImmutableNodes.leafNode(TEXT_OUT_QNAME, "foo")).build();
final DOMRpcResult expResult = new DefaultDOMRpcResult(outputNode);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(brokerFacade).invokeRpc(any(SchemaPath.class),
- isNull());
+ doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(any(SchemaPath.class), isNull());
final String uriPath = "toaster:testOutput";
@Test(expected = OperationFailedException.class)
public void testInvokeRpcFailure() throws Exception {
final DOMRpcException exception = new DOMRpcImplementationNotAvailableException("testExeption");
- doReturn(Futures.immediateFailedCheckedFuture(exception)).when(brokerFacade).invokeRpc(any(SchemaPath.class),
+ doReturn(immediateFailedFluentFuture(exception)).when(brokerFacade).invokeRpc(any(SchemaPath.class),
any(NormalizedNode.class));
final String uriPath = "toaster:cancel-toast";
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
@Test
public void deleteConfigStatusCodes() throws UnsupportedEncodingException {
final String uri = "/config/test-interface:interfaces";
- when(brokerFacade.commitConfigurationDataDelete(any(YangInstanceIdentifier.class))).thenReturn(
- Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(brokerFacade)
+ .commitConfigurationDataDelete(any(YangInstanceIdentifier.class));
Response response = target(uri).request(MediaType.APPLICATION_XML).delete();
assertEquals(200, response.getStatus());
@Test
public void deleteFailTest() throws Exception {
final String uri = "/config/test-interface:interfaces";
- final CheckedFuture<Void, TransactionCommitFailedException> future =
- Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("failed test"));
- when(brokerFacade.commitConfigurationDataDelete(any(YangInstanceIdentifier.class))).thenReturn(future);
+ doReturn(immediateFailedFluentFuture(new TransactionCommitFailedException("failed test"))).when(brokerFacade)
+ .commitConfigurationDataDelete(any(YangInstanceIdentifier.class));
final Response response = target(uri).request(MediaType.APPLICATION_XML).delete();
assertEquals(500, response.getStatus());
}
* 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.sal.restconf.impl.test;
import static org.junit.Assert.assertEquals;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.sal.restconf.impl.test.RestOperationUtils.XML;
import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
public void postDataViaUrlMountPoint() throws UnsupportedEncodingException {
setSchemaControllerContext(schemaContextYangsIetf);
when(brokerFacade.commitConfigurationDataPost(any(DOMMountPoint.class), any(YangInstanceIdentifier.class),
- any(NormalizedNode.class), null, null)).thenReturn(mock(CheckedFuture.class));
+ any(NormalizedNode.class), null, null)).thenReturn(mock(FluentFuture.class));
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
public void createConfigurationDataTest() throws UnsupportedEncodingException, ParseException {
when(brokerFacade.commitConfigurationDataPost((SchemaContext) null, any(YangInstanceIdentifier.class),
any(NormalizedNode.class), null, null))
- .thenReturn(mock(CheckedFuture.class));
+ .thenReturn(mock(FluentFuture.class));
final ArgumentCaptor<YangInstanceIdentifier> instanceIdCaptor =
ArgumentCaptor.forClass(YangInstanceIdentifier.class);
@Test
public void createConfigurationDataNullTest() throws UnsupportedEncodingException {
- when(brokerFacade.commitConfigurationDataPost(any(SchemaContext.class), any(YangInstanceIdentifier.class),
- any(NormalizedNode.class), isNull(), isNull()))
- .thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(brokerFacade).commitConfigurationDataPost(
+ any(SchemaContext.class), any(YangInstanceIdentifier.class), any(NormalizedNode.class), isNull(),
+ isNull());
//FIXME : find who is set schemaContext
// final String URI_1 = "/config";
* 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.sal.restconf.impl.test;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.util.HashSet;
import javax.ws.rs.core.MultivaluedMap;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.PutResult;
private void mockingBrokerPut(final YangInstanceIdentifier yii, final NormalizedNode<?, ?> data) {
final PutResult result = Mockito.mock(PutResult.class);
- final CheckedFuture<Void, TransactionCommitFailedException> checkedFuture =
- Futures.immediateCheckedFuture(null);
Mockito.when(this.brokerFacade.commitConfigurationDataPut(schemaContext, yii, data, null, null))
.thenReturn(result);
- Mockito.when(result.getFutureOfPutData()).thenReturn(checkedFuture);
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
Mockito.when(result.getStatus()).thenReturn(Status.OK);
}
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
@Test
public void testRpcResultCommitedToStatusCodesWithMountPoint() throws UnsupportedEncodingException,
FileNotFoundException, URISyntaxException {
- final CheckedFuture<Void, TransactionCommitFailedException> dummyFuture = Futures.immediateCheckedFuture(null);
final PutResult result = mock(PutResult.class);
- when(
- brokerFacade.commitMountPointDataPut(any(DOMMountPoint.class), any(YangInstanceIdentifier.class),
- any(NormalizedNode.class), null, null)).thenReturn(result);
- when(result.getFutureOfPutData()).thenReturn(dummyFuture);
+ when(brokerFacade.commitMountPointDataPut(any(DOMMountPoint.class), any(YangInstanceIdentifier.class),
+ any(NormalizedNode.class), null, null)).thenReturn(result);
+ doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
when(result.getStatus()).thenReturn(Status.OK);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
@Test
public void putDataMountPointIntoHighestElement() throws UnsupportedEncodingException, URISyntaxException {
- final CheckedFuture<Void, TransactionCommitFailedException> dummyFuture = Futures.immediateCheckedFuture(null);
final PutResult result = mock(PutResult.class);
doReturn(result).when(brokerFacade).commitMountPointDataPut(any(DOMMountPoint.class),
any(YangInstanceIdentifier.class), any(NormalizedNode.class), null, null);
- when(result.getFutureOfPutData()).thenReturn(dummyFuture);
+ doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
when(result.getStatus()).thenReturn(Status.OK);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfImpl;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.net.URI;
import java.text.ParseException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfImpl;
binaryKeyTest(al, al);
}
- private void binaryKeyTest(final List<Byte> al, final List<Byte> al2) {
+ private static void binaryKeyTest(final List<Byte> al, final List<Byte> al2) {
final QName keyDef = QName.create("test:key:binary", "2017-08-14", "b1");
doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters(anyBoolean());
final NormalizedNodeContext ctx = mock(NormalizedNodeContext.class);
- final InstanceIdentifierContext iiCtx = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext<?> iiCtx = mock(InstanceIdentifierContext.class);
doReturn(iiCtx).when(ctx).getInstanceIdentifierContext();
final SchemaNode schemaNode = mock(SchemaNode.class);
doReturn(schemaNode).when(iiCtx).getSchemaNode();
doReturn(mount).when(iiCtx).getMountPoint();
final DOMRpcService rpcService = mock(DOMRpcService.class);
doReturn(Optional.of(rpcService)).when(mount).getService(DOMRpcService.class);
- doReturn(Futures.immediateCheckedFuture(mock(DOMRpcResult.class))).when(rpcService)
+ doReturn(immediateFluentFuture(mock(DOMRpcResult.class))).when(rpcService)
.invokeRpc(any(SchemaPath.class), any(NormalizedNode.class));
this.restconfImpl.invokeRpc("randomId", ctx, uriInfo);
this.restconfImpl.invokeRpc("ietf-netconf", ctx, uriInfo);
@Test
public void createNotificationStreamTest() {
final NormalizedNodeContext payload = mock(NormalizedNodeContext.class);
- final InstanceIdentifierContext iiCtx = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext<?> iiCtx = mock(InstanceIdentifierContext.class);
doReturn(iiCtx).when(payload).getInstanceIdentifierContext();
final SchemaNode schemaNode = mock(SchemaNode.class,
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
* 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.netconf.sal.streams.listeners;
import static java.time.Instant.EPOCH;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.yang.gen.v1.instance.identifier.patch.module.rev151121.PatchCont;
import org.opendaylight.yang.gen.v1.instance.identifier.patch.module.rev151121.patch.cont.MyList1;
private static final String JSON_NOTIF_UPDATE = "/listener-adapter-test/notif-update.json";
private static final String JSON_NOTIF_DEL = "/listener-adapter-test/notif-del.json";
- private static YangInstanceIdentifier PATCH_CONT_YIID =
+ private static final YangInstanceIdentifier PATCH_CONT_YIID =
YangInstanceIdentifier.create(new YangInstanceIdentifier.NodeIdentifier(PatchCont.QNAME));
private static SchemaContext schemaContext;
public void testJsonNotifsLeaves() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey",
NotificationOutputTypeGrouping.NotificationOutputType.JSON, true);
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
DOMDataTreeIdentifier root = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, PATCH_CONT_YIID);
changeService.registerDataTreeChangeListener(root, adapter);
InstanceIdentifier<MyList1> iid = InstanceIdentifier.create(PatchCont.class)
.child(MyList1.class, new MyList1Key("Althea"));
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_CREATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
builder = new MyList1Builder().withKey(new MyList1Key("Althea")).setMyLeaf12("Bertha");
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_UPDATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_DEL));
}
public void testJsonNotifs() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey",
NotificationOutputTypeGrouping.NotificationOutputType.JSON, false);
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
DOMDataTreeIdentifier root = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, PATCH_CONT_YIID);
changeService.registerDataTreeChangeListener(root, adapter);
InstanceIdentifier<MyList1> iid = InstanceIdentifier.create(PatchCont.class)
.child(MyList1.class, new MyList1Key("Althea"));
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_CREATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
builder = new MyList1Builder().withKey(new MyList1Key("Althea")).setMyLeaf12("Bertha");
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_UPDATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_DEL));
}
}
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.util.SingletonSet;
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-spi</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-spi</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-common-util</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-broker-impl</artifactId>
- </dependency>
<dependency>
<groupId>io.netty</groupId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <type>test-jar</type>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <type>test-jar</type>
<scope>test</scope>
</dependency>
<dependency>
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.common.util.IdentityValuesDTO;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.IdentityValue;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.Predicate;
identityValue.setPredicates(predicates);
} else if (pathArgument instanceof NodeWithValue && identityValue != null) {
final List<Predicate> predicates = new ArrayList<>();
- final String value = String.valueOf(((NodeWithValue) pathArgument).getValue());
+ final String value = String.valueOf(((NodeWithValue<?>) pathArgument).getValue());
predicates.add(new Predicate(null, value));
identityValue.setPredicates(predicates);
}
*/
package org.opendaylight.restconf.nb.rfc8040.handlers;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
/**
* Implementation of {@link DOMDataBrokerHandler}.
- *
*/
public class DOMDataBrokerHandler implements Handler<DOMDataBroker> {
*/
package org.opendaylight.restconf.nb.rfc8040.handlers;
-import java.util.Objects;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import static java.util.Objects.requireNonNull;
+
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
/**
* Implementation of {@link DOMMountPointServiceHandler}.
* mount point service
*/
private DOMMountPointServiceHandler(final DOMMountPointService domMountPointService) {
- this.domMountPointService = Objects.requireNonNull(domMountPointService);
+ this.domMountPointService = requireNonNull(domMountPointService);
}
- public static DOMMountPointServiceHandler newInstance(DOMMountPointService domMountPointService) {
+ public static DOMMountPointServiceHandler newInstance(final DOMMountPointService domMountPointService) {
return new DOMMountPointServiceHandler(domMountPointService);
}
*/
package org.opendaylight.restconf.nb.rfc8040.handlers;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
public class NotificationServiceHandler implements Handler<DOMNotificationService> {
*/
package org.opendaylight.restconf.nb.rfc8040.handlers;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
/**
* Implementation of {@link RpcServiceHandler}.
- *
*/
public class RpcServiceHandler implements Handler<DOMRpcService> {
-
private final DOMRpcService rpcService;
public RpcServiceHandler(final DOMRpcService rpcService) {
package org.opendaylight.restconf.nb.rfc8040.handlers;
import com.google.common.base.Preconditions;
+import com.google.common.base.Throwables;
import java.util.Collection;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
-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.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary;
this.domSchemaService = domSchemaService;
}
- public static SchemaContextHandler newInstance(TransactionChainHandler transactionChainHandler,
- DOMSchemaService domSchemaService) {
+ public static SchemaContextHandler newInstance(final TransactionChainHandler transactionChainHandler,
+ final DOMSchemaService domSchemaService) {
return new SchemaContextHandler(transactionChainHandler, domSchemaService);
}
private void putData(
final NormalizedNode<NodeIdentifier, Collection<DataContainerChild<? extends PathArgument, ?>>> normNode) {
- final DOMDataWriteTransaction wTx = this.transactionChainHandler.get().newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction wTx = this.transactionChainHandler.get().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL,
YangInstanceIdentifier.create(NodeIdentifier.create(normNode.getNodeType())), normNode);
try {
- wTx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
- if (!(e.getCause() instanceof ConflictingModificationAppliedException)) {
- throw new RestconfDocumentedException("Problem occurred while putting data to DS.", e);
+ wTx.commit().get();
+ } catch (InterruptedException e) {
+ throw new RestconfDocumentedException("Problem occurred while putting data to DS.", e);
+ } catch (ExecutionException e) {
+ final TransactionCommitFailedException failure = Throwables.getCauseAs(e,
+ TransactionCommitFailedException.class);
+ if (failure.getCause() instanceof ConflictingModificationAppliedException) {
+ /*
+ * Ignore error when another cluster node is already putting the same data to DS.
+ * We expect that cluster is homogeneous and that node was going to write the same data
+ * (that means no retry is needed). Transaction chain reset must be invoked to be able
+ * to continue writing data with another transaction after failed transaction.
+ * This is workaround for bug https://bugs.opendaylight.org/show_bug.cgi?id=7728
+ */
+ LOG.warn("Ignoring that another cluster node is already putting the same data to DS.", e);
+ this.transactionChainHandler.reset();
+ } else {
+ throw new RestconfDocumentedException("Problem occurred while putting data to DS.", failure);
}
-
- /*
- Ignore error when another cluster node is already putting the same data to DS.
- We expect that cluster is homogeneous and that node was going to write the same data
- (that means no retry is needed). Transaction chain reset must be invoked to be able
- to continue writing data with another transaction after failed transaction.
- This is workaround for bug:
- https://bugs.opendaylight.org/show_bug.cgi?id=7728
- */
- LOG.warn("Ignoring that another cluster node is already putting the same data to DS.", e);
- this.transactionChainHandler.reset();
}
}
}
* 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.restconf.nb.rfc8040.handlers;
import java.util.Objects;
-import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-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.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
/**
* Implementation of {@link TransactionChainHandler}.
*
public class TransactionChainHandler implements Handler<DOMTransactionChain>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TransactionChainHandler.class);
- private final TransactionChainListener transactionChainListener = new TransactionChainListener() {
+ private final DOMTransactionChainListener transactionChainListener = new DOMTransactionChainListener() {
@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) {
LOG.warn("TransactionChain({}) {} FAILED!", chain, transaction.getIdentifier(), cause);
reset();
throw new RestconfDocumentedException("TransactionChain(" + chain + ") not committed correctly", cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
LOG.trace("TransactionChain({}) SUCCESSFUL", chain);
}
};
- @Nullable
private final DOMDataBroker dataBroker;
+
private volatile DOMTransactionChain transactionChain;
/**
* 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.restconf.nb.rfc8040.jersey.providers.patch;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.gson.stream.JsonReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;
import javax.ws.rs.Consumes;
public class JsonToPatchBodyReader extends AbstractToPatchBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(JsonToPatchBodyReader.class);
- public JsonToPatchBodyReader(SchemaContextHandler schemaContextHandler,
- DOMMountPointServiceHandler mountPointServiceHandler) {
+ public JsonToPatchBodyReader(final SchemaContextHandler schemaContextHandler,
+ final DOMMountPointServiceHandler mountPointServiceHandler) {
super(schemaContextHandler, mountPointServiceHandler);
}
try {
return readFrom(
ParserIdentifier.toInstanceIdentifier(uriPath, getSchemaContext(),
- Optional.fromNullable(getMountPointService())), entityStream);
+ Optional.ofNullable(getMountPointService())), entityStream);
} catch (final Exception e) {
propagateExceptionAs(e);
return null; // no-op
* 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.restconf.nb.rfc8040.jersey.providers.spi;
-import com.google.common.base.Optional;
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
+import java.util.Optional;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.ext.MessageBodyReader;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.handlers.DOMMountPointServiceHandler;
import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
private final SchemaContextHandler schemaContextHandler;
private final DOMMountPointServiceHandler mountPointServiceHandler;
- protected AbstractIdentifierAwareJaxRsProvider(SchemaContextHandler schemaContextHandler,
- DOMMountPointServiceHandler mountPointServiceHandler) {
+ protected AbstractIdentifierAwareJaxRsProvider(final SchemaContextHandler schemaContextHandler,
+ final DOMMountPointServiceHandler mountPointServiceHandler) {
this.schemaContextHandler = schemaContextHandler;
this.mountPointServiceHandler = mountPointServiceHandler;
}
private InstanceIdentifierContext<?> getInstanceIdentifierContext() {
return ParserIdentifier.toInstanceIdentifier(getIdentifier(), getSchemaContext(),
- Optional.fromNullable(getMountPointService()));
+ Optional.ofNullable(getMountPointService()));
}
protected UriInfo getUriInfo() {
import java.util.Date;
import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
*/
package org.opendaylight.restconf.nb.rfc8040.rests.services.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
/**
*/
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.ByteArrayInputStream;
import java.lang.annotation.Annotation;
import java.nio.charset.StandardCharsets;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nullable;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
}
LOG.debug("Data missing - returning absent");
- return Optional.absent();
+ return Optional.empty();
}
}
propagateExceptionAs(uriPath, e, "RPC");
}
- return Optional.fromNullable(output);
+ return Optional.ofNullable(output);
}
@SuppressWarnings("checkstyle:IllegalCatch")
} catch (final Exception e) {
propagateExceptionAs(uriPath, e, "PATCH");
}
- return Optional.fromNullable(output);
+ return Optional.ofNullable(output);
}
@Override
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_LOCATION_PATH_PART;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_PATH;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.time.Clock;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.context.WriterParameters;
import java.net.URI;
import javax.ws.rs.Path;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import javax.annotation.Nonnull;
import javax.ws.rs.Path;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
*/
package org.opendaylight.restconf.nb.rfc8040.rests.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
*/
public void setLogicalDatastoreType(final LogicalDatastoreType datastoreType) {
this.configuration = datastoreType;
-
}
/**
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
* @param refSchemaCtx
* reference to {@link SchemaContext} -
* {@link SchemaContextRef}
- * @return {@link CheckedFuture} with {@link DOMRpcResult} - This mean
- * output of RPC - example in JSON:
+ * @return {@link DOMRpcResult} - This means output of RPC - example in JSON:
*
* <pre>
* {@code
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
-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.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* @return {@link Response}
*/
public static Response deleteData(final TransactionVarsWrapper transactionNode) {
- final CheckedFuture<Void, TransactionCommitFailedException> future = submitData(
- transactionNode.getTransactionChainHandler(),
+ final FluentFuture<? extends CommitInfo> future = submitData(transactionNode.getTransactionChainHandler(),
transactionNode.getInstanceIdentifier().getInstanceIdentifier());
final ResponseFactory response = new ResponseFactory(Status.NO_CONTENT);
FutureCallbackTx.addCallback(future, RestconfDataServiceConstant.DeleteData.DELETE_TX_TYPE, response);
* read and write transaction
* @param path
* path of data to delete
- * @return {@link CheckedFuture}
+ * @return {@link FluentFuture}
*/
- private static CheckedFuture<Void, TransactionCommitFailedException> submitData(
+ private static FluentFuture<? extends CommitInfo> submitData(
final TransactionChainHandler transactionChainHandler, final YangInstanceIdentifier path) {
- final DOMDataReadWriteTransaction readWriteTx = transactionChainHandler.get().newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction readWriteTx = transactionChainHandler.get().newReadWriteTransaction();
TransactionUtil.checkItemExists(transactionChainHandler, readWriteTx, LogicalDatastoreType.CONFIGURATION, path,
RestconfDataServiceConstant.DeleteData.DELETE_TX_TYPE);
readWriteTx.delete(LogicalDatastoreType.CONFIGURATION, path);
- return readWriteTx.submit();
+ return readWriteTx.commit();
}
}
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
import com.google.common.base.Throwables;
-import com.google.common.util.concurrent.CheckedFuture;
-import java.util.ArrayList;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
/**
* Add callback for future objects and result set to the data factory.
- *
*/
final class FutureCallbackTx {
* if the Future throws an exception
*/
@SuppressWarnings("checkstyle:IllegalCatch")
- static <T, X extends Exception> void addCallback(final CheckedFuture<T, X> listenableFuture, final String txType,
- final FutureDataFactory<T> dataFactory) throws RestconfDocumentedException {
+ static <T> void addCallback(final FluentFuture<T> listenableFuture, final String txType,
+ final FutureDataFactory<? super T> dataFactory) throws RestconfDocumentedException {
try {
- final T result = listenableFuture.checkedGet();
+ final T result = listenableFuture.get();
dataFactory.setResult(result);
LOG.trace("Transaction({}) SUCCESSFUL", txType);
- } catch (Exception e) {
+ } catch (InterruptedException e) {
+ dataFactory.setFailureStatus();
+ LOG.warn("Transaction({}) FAILED!", txType, e);
+ throw new RestconfDocumentedException("Transaction failed", e);
+ } catch (ExecutionException e) {
dataFactory.setFailureStatus();
LOG.warn("Transaction({}) FAILED!", txType, e);
- if (e instanceof DOMRpcException) {
- final List<RpcError> rpcErrorList = new ArrayList<>();
- rpcErrorList.add(
- RpcResultBuilder.newError(RpcError.ErrorType.RPC, "operation-failed", e.getMessage()));
- dataFactory.setResult((T) new DefaultDOMRpcResult(rpcErrorList));
- } else if (e instanceof TransactionCommitFailedException) {
+
+ final Throwable cause = e.getCause();
+ if (cause instanceof DOMRpcException) {
+ dataFactory.setResult((T) new DefaultDOMRpcResult(ImmutableList.of(
+ RpcResultBuilder.newError(RpcError.ErrorType.RPC, "operation-failed", cause.getMessage()))));
+ } else if (cause instanceof TransactionCommitFailedException) {
/* If device send some error message we want this message to get to client
and not just to throw it away or override it with new generic message.
We search for NetconfDocumentedException that was send from netconfSB
and we create RestconfDocumentedException accordingly.
*/
- final List<Throwable> causalChain = Throwables.getCausalChain(e);
+ final List<Throwable> causalChain = Throwables.getCausalChain(cause);
for (Throwable error : causalChain) {
if (error instanceof NetconfDocumentedException) {
throw new RestconfDocumentedException(error.getMessage(),
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* 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.restconf.nb.rfc8040.rests.utils;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
import javax.ws.rs.core.Response.Status;
-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.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
final SchemaContextRef schemaContextRef) {
final List<PatchStatusEntity> editCollection = new ArrayList<>();
boolean noError = true;
- final DOMDataReadWriteTransaction tx = transactionNode.getTransactionChain().newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction tx = transactionNode.getTransactionChain().newReadWriteTransaction();
for (final PatchEntity patchEntity : context.getData()) {
if (noError) {
// if no errors then submit transaction, otherwise cancel
if (noError) {
final ResponseFactory response = new ResponseFactory(Status.OK);
- final CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
+ final FluentFuture<? extends CommitInfo> future = tx.commit();
try {
FutureCallbackTx.addCallback(future, PatchData.PATCH_TX_TYPE, response);
private static void createDataWithinTransaction(final LogicalDatastoreType dataStore,
final YangInstanceIdentifier path,
final NormalizedNode<?, ?> payload,
- final DOMDataReadWriteTransaction rwTransaction,
+ final DOMDataTreeReadWriteTransaction rwTransaction,
final SchemaContextRef schemaContextRef) {
LOG.trace("POST {} within Restconf Patch: {} with payload {}", dataStore.name(), path, payload);
createData(payload, schemaContextRef.get(), path, rwTransaction, dataStore, true);
*/
private static void deleteDataWithinTransaction(final LogicalDatastoreType dataStore,
final YangInstanceIdentifier path,
- final DOMDataReadWriteTransaction readWriteTransaction) {
+ final DOMDataTreeReadWriteTransaction readWriteTransaction) {
LOG.trace("Delete {} within Restconf Patch: {}", dataStore.name(), path);
checkItemExistsWithinTransaction(readWriteTransaction, dataStore, path);
readWriteTransaction.delete(dataStore, path);
private static void mergeDataWithinTransaction(final LogicalDatastoreType dataStore,
final YangInstanceIdentifier path,
final NormalizedNode<?, ?> payload,
- final DOMDataReadWriteTransaction writeTransaction,
+ final DOMDataTreeWriteTransaction writeTransaction,
final SchemaContextRef schemaContextRef) {
LOG.trace("Merge {} within Restconf Patch: {} with payload {}", dataStore.name(), path, payload);
TransactionUtil.ensureParentsByMerge(path, schemaContextRef.get(), writeTransaction);
*/
private static void removeDataWithinTransaction(final LogicalDatastoreType dataStore,
final YangInstanceIdentifier path,
- final DOMDataWriteTransaction writeTransaction) {
+ final DOMDataTreeWriteTransaction writeTransaction) {
LOG.trace("Remove {} within Restconf Patch: {}", dataStore.name(), path);
writeTransaction.delete(dataStore, path);
}
final YangInstanceIdentifier path,
final NormalizedNode<?, ?> payload,
final SchemaContextRef schemaContextRef,
- final DOMDataReadWriteTransaction rwTransaction) {
+ final DOMDataTreeReadWriteTransaction rwTransaction) {
LOG.trace("PUT {} within Restconf Patch: {} with payload {}", dataStore.name(), path, payload);
createData(payload, schemaContextRef.get(), path, rwTransaction, dataStore, false);
}
* @param errorIfExists Enable checking for existence of data (throws error if already exists)
*/
private static void createData(final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
- final YangInstanceIdentifier path, final DOMDataReadWriteTransaction rwTransaction,
+ final YangInstanceIdentifier path,
+ final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType dataStore, final boolean errorIfExists) {
if (payload instanceof MapNode) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
* @param store Datastore
* @param path Path to be checked
*/
- public static void checkItemExistsWithinTransaction(final DOMDataReadWriteTransaction rwTransaction,
+ public static void checkItemExistsWithinTransaction(final DOMDataTreeReadTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
- final CheckedFuture<Boolean, ReadFailedException> future = rwTransaction.exists(store, path);
+ final FluentFuture<Boolean> future = rwTransaction.exists(store, path);
final FutureDataFactory<Boolean> response = new FutureDataFactory<>();
FutureCallbackTx.addCallback(future, PatchData.PATCH_TX_TYPE, response);
* @param store Datastore
* @param path Path to be checked
*/
- public static void checkItemDoesNotExistsWithinTransaction(final DOMDataReadWriteTransaction rwTransaction,
+ public static void checkItemDoesNotExistsWithinTransaction(final DOMDataTreeReadTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
- final CheckedFuture<Boolean, ReadFailedException> future = rwTransaction.exists(store, path);
+ final FluentFuture<Boolean> future = rwTransaction.exists(store, path);
final FutureDataFactory<Boolean> response = new FutureDataFactory<>();
FutureCallbackTx.addCallback(future, PatchData.PATCH_TX_TYPE, response);
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.net.URI;
+import java.util.Optional;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-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.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Util class to post data to DS.
*
*/
public final class PostDataTransactionUtil {
-
- private static final Logger LOG = LoggerFactory.getLogger(PostDataTransactionUtil.class);
-
private PostDataTransactionUtil() {
throw new UnsupportedOperationException("Util class.");
}
* point
* @param insert
* insert
- * @return {@link CheckedFuture}
+ * @return {@link Response}
*/
public static Response postData(final UriInfo uriInfo, final NormalizedNodeContext payload,
final TransactionVarsWrapper transactionNode, final SchemaContextRef schemaContextRef, final String insert,
final String point) {
- final CheckedFuture<Void, TransactionCommitFailedException> future = submitData(
+ final FluentFuture<? extends CommitInfo> future = submitData(
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(),
transactionNode, schemaContextRef.get(), insert, point);
final URI location = PostDataTransactionUtil.resolveLocation(uriInfo, transactionNode, schemaContextRef);
* query parameter
* @param insert
* query parameter
- * @return {@link CheckedFuture}
+ * @return {@link FluentFuture}
*/
- private static CheckedFuture<Void, TransactionCommitFailedException> submitData(final YangInstanceIdentifier path,
+ private static FluentFuture<? extends CommitInfo> submitData(final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data, final TransactionVarsWrapper transactionNode,
final SchemaContext schemaContext, final String insert, final String point) {
final DOMTransactionChain domTransactionChain = transactionNode.getTransactionChain();
- final DOMDataReadWriteTransaction newReadWriteTransaction = domTransactionChain.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction newReadWriteTransaction = domTransactionChain.newReadWriteTransaction();
if (insert == null) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(), newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
final DataSchemaNode schemaNode = PutDataTransactionUtil.checkListAndOrderedType(schemaContext, path);
switch (insert) {
if (readList == null || readList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
newReadWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION,
path.getParent().getParent());
schemaContext, transactionNode.getTransactionChainHandler());
makePost(path, readData, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
} else {
final NormalizedNode<?, ?> readData = PutDataTransactionUtil.readList(path.getParent(),
if (readLeafList == null || readLeafList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
newReadWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION,
path.getParent().getParent());
schemaContext, transactionNode.getTransactionChainHandler());
makePost(path, readData, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
}
case "last":
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
case "before":
if (schemaNode instanceof ListSchemaNode) {
final NormalizedNode<?, ?> readData = PutDataTransactionUtil.readList(path.getParent(),
if (readList == null || readList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
insertWithPointListPost(newReadWriteTransaction, LogicalDatastoreType.CONFIGURATION, path,
data, schemaContext, point, readList, true,
transactionNode.getTransactionChainHandler());
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
} else {
final NormalizedNode<?, ?> readData = PutDataTransactionUtil.readList(path.getParent(),
if (readLeafList == null || readLeafList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
insertWithPointLeafListPost(newReadWriteTransaction, LogicalDatastoreType.CONFIGURATION,
path, data, schemaContext, point, readLeafList, true,
transactionNode.getTransactionChainHandler());
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
}
case "after":
if (readList == null || readList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
insertWithPointListPost(newReadWriteTransaction, LogicalDatastoreType.CONFIGURATION, path,
data, schemaContext, point, readList, false,
transactionNode.getTransactionChainHandler());
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
} else {
final NormalizedNode<?, ?> readData = PutDataTransactionUtil.readList(path.getParent(),
if (readLeafList == null || readLeafList.getValue().isEmpty()) {
makePost(path, data, schemaContext, transactionNode.getTransactionChainHandler(),
newReadWriteTransaction);
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
} else {
insertWithPointLeafListPost(newReadWriteTransaction, LogicalDatastoreType.CONFIGURATION,
path, data, schemaContext, point, readLeafList, true,
transactionNode.getTransactionChainHandler());
- return newReadWriteTransaction.submit();
+ return newReadWriteTransaction.commit();
}
}
default:
}
}
- private static void insertWithPointLeafListPost(final DOMDataReadWriteTransaction rwTransaction,
+ private static void insertWithPointLeafListPost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String point, final OrderedLeafSetNode<?> readLeafList,
final boolean before, final TransactionChainHandler transactionChainHandler) {
rwTransaction.delete(datastore, path.getParent().getParent());
final InstanceIdentifierContext<?> instanceIdentifier =
- ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final LeafSetEntryNode<?> nodeChild : readLeafList.getValue()) {
if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
}
}
- private static void insertWithPointListPost(final DOMDataReadWriteTransaction rwTransaction,
+ private static void insertWithPointListPost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String point, final MapNode readList, final boolean before,
final TransactionChainHandler transactionChainHandler) {
rwTransaction.delete(datastore, path.getParent().getParent());
final InstanceIdentifierContext<?> instanceIdentifier =
- ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final MapEntryNode mapEntryNode : readList.getValue()) {
if (mapEntryNode.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
private static void makePost(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
final SchemaContext schemaContext, final TransactionChainHandler transactionChainHandler,
- final DOMDataReadWriteTransaction transaction) {
+ final DOMDataTreeReadWriteTransaction transaction) {
if (data instanceof MapNode) {
boolean merge = false;
for (final MapEntryNode child : ((MapNode) data).getValue()) {
return uriBuilder.build();
}
- private static void simplePost(final DOMDataReadWriteTransaction rwTransaction,
+ private static void simplePost(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final TransactionChainHandler transactionChainHandler) {
TransactionUtil.checkItemDoesNotExists(transactionChainHandler, rwTransaction, datastore, path,
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import com.google.common.base.Optional;
import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
-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.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
* query parameter
* @param insert
* query parameter
- * @return {@link CheckedFuture}
+ * @return {@link Response}
*/
public static Response putData(final NormalizedNodeContext payload, final SchemaContextRef schemaCtxRef,
final TransactionVarsWrapper transactionNode, final String insert, final String point) {
final YangInstanceIdentifier path = payload.getInstanceIdentifierContext().getInstanceIdentifier();
final SchemaContext schemaContext = schemaCtxRef.get();
- final DOMDataReadWriteTransaction readWriteTransaction =
+ final DOMDataTreeReadWriteTransaction readWriteTransaction =
transactionNode.getTransactionChain().newReadWriteTransaction();
- final CheckedFuture<Boolean, ReadFailedException> existsFuture =
- readWriteTransaction.exists(LogicalDatastoreType.CONFIGURATION, path);
+ final FluentFuture<Boolean> existsFuture = readWriteTransaction.exists(LogicalDatastoreType.CONFIGURATION,
+ path);
final FutureDataFactory<Boolean> existsResponse = new FutureDataFactory<>();
FutureCallbackTx.addCallback(existsFuture, RestconfDataServiceConstant.PutData.PUT_TX_TYPE, existsResponse);
final ResponseFactory responseFactory =
new ResponseFactory(existsResponse.result ? Status.NO_CONTENT : Status.CREATED);
- final CheckedFuture<Void, TransactionCommitFailedException> submitData = submitData(path, schemaContext,
+ final FluentFuture<? extends CommitInfo> submitData = submitData(path, schemaContext,
transactionNode.getTransactionChainHandler(), readWriteTransaction, payload.getData(), insert, point);
FutureCallbackTx.addCallback(submitData, RestconfDataServiceConstant.PutData.PUT_TX_TYPE, responseFactory);
return responseFactory.build();
* query parameter
* @param insert
* query parameter
- * @return {@link CheckedFuture}
+ * @return {@link FluentFuture}
*/
- private static CheckedFuture<Void, TransactionCommitFailedException> submitData(final YangInstanceIdentifier path,
+ private static FluentFuture<? extends CommitInfo> submitData(final YangInstanceIdentifier path,
final SchemaContext schemaContext, final TransactionChainHandler transactionChainHandler,
- final DOMDataReadWriteTransaction readWriteTransaction,
+ final DOMDataTreeReadWriteTransaction readWriteTransaction,
final NormalizedNode<?, ?> data, final String insert, final String point) {
if (insert == null) {
return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- final DataSchemaNode schemaNode = checkListAndOrderedType(schemaContext, path);
- switch (insert) {
- case "first":
- if (schemaNode instanceof ListSchemaNode) {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedMapNode readList = (OrderedMapNode) readData;
- if (readList == null || readList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- readWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION, path.getParent());
- simplePut(LogicalDatastoreType.CONFIGURATION, path, readWriteTransaction,
- schemaContext, data);
- listPut(LogicalDatastoreType.CONFIGURATION, path.getParent(), readWriteTransaction,
- schemaContext, readList);
- return readWriteTransaction.submit();
- }
+ }
+
+ final DataSchemaNode schemaNode = checkListAndOrderedType(schemaContext, path);
+ switch (insert) {
+ case "first":
+ if (schemaNode instanceof ListSchemaNode) {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
+ final OrderedMapNode readList = (OrderedMapNode) readData;
+ if (readList == null || readList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
} else {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
+ readWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION, path.getParent());
+ simplePut(LogicalDatastoreType.CONFIGURATION, path, readWriteTransaction,
+ schemaContext, data);
+ listPut(LogicalDatastoreType.CONFIGURATION, path.getParent(), readWriteTransaction,
+ schemaContext, readList);
+ return readWriteTransaction.commit();
+ }
+ } else {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
- if (readLeafList == null || readLeafList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- readWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION, path.getParent());
- simplePut(LogicalDatastoreType.CONFIGURATION, path, readWriteTransaction,
- schemaContext, data);
- listPut(LogicalDatastoreType.CONFIGURATION, path.getParent(), readWriteTransaction,
- schemaContext, readLeafList);
- return readWriteTransaction.submit();
- }
+ final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
+ } else {
+ readWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION, path.getParent());
+ simplePut(LogicalDatastoreType.CONFIGURATION, path, readWriteTransaction,
+ schemaContext, data);
+ listPut(LogicalDatastoreType.CONFIGURATION, path.getParent(), readWriteTransaction,
+ schemaContext, readLeafList);
+ return readWriteTransaction.commit();
}
- case "last":
- return makePut(path, schemaContext, readWriteTransaction, data);
- case "before":
- if (schemaNode instanceof ListSchemaNode) {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedMapNode readList = (OrderedMapNode) readData;
- if (readList == null || readList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- insertWithPointListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION, path,
- data, schemaContext, point, readList, true);
- return readWriteTransaction.submit();
- }
+ }
+ case "last":
+ return makePut(path, schemaContext, readWriteTransaction, data);
+ case "before":
+ if (schemaNode instanceof ListSchemaNode) {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
+ final OrderedMapNode readList = (OrderedMapNode) readData;
+ if (readList == null || readList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
} else {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
+ insertWithPointListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION, path,
+ data, schemaContext, point, readList, true);
+ return readWriteTransaction.commit();
+ }
+ } else {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
- if (readLeafList == null || readLeafList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- insertWithPointLeafListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
- path, data, schemaContext, point, readLeafList, true);
- return readWriteTransaction.submit();
- }
+ final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
+ } else {
+ insertWithPointLeafListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
+ path, data, schemaContext, point, readLeafList, true);
+ return readWriteTransaction.commit();
}
- case "after":
- if (schemaNode instanceof ListSchemaNode) {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedMapNode readList = (OrderedMapNode) readData;
- if (readList == null || readList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- insertWithPointListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
- path, data, schemaContext, point, readList, false);
- return readWriteTransaction.submit();
- }
+ }
+ case "after":
+ if (schemaNode instanceof ListSchemaNode) {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
+ final OrderedMapNode readList = (OrderedMapNode) readData;
+ if (readList == null || readList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
} else {
- final NormalizedNode<?, ?> readData =
- readList(path, schemaContext, transactionChainHandler, schemaNode);
+ insertWithPointListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
+ path, data, schemaContext, point, readList, false);
+ return readWriteTransaction.commit();
+ }
+ } else {
+ final NormalizedNode<?, ?> readData =
+ readList(path, schemaContext, transactionChainHandler, schemaNode);
- final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
- if (readLeafList == null || readLeafList.getValue().isEmpty()) {
- return makePut(path, schemaContext, readWriteTransaction, data);
- } else {
- insertWithPointLeafListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
- path, data, schemaContext, point, readLeafList, true);
- return readWriteTransaction.submit();
- }
+ final OrderedLeafSetNode<?> readLeafList = (OrderedLeafSetNode<?>) readData;
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ return makePut(path, schemaContext, readWriteTransaction, data);
+ } else {
+ insertWithPointLeafListPut(readWriteTransaction, LogicalDatastoreType.CONFIGURATION,
+ path, data, schemaContext, point, readLeafList, true);
+ return readWriteTransaction.commit();
}
- default:
- throw new RestconfDocumentedException(
- "Used bad value of insert parameter. Possible values are first, last, before or after, "
- + "but was: " + insert);
- }
+ }
+ default:
+ throw new RestconfDocumentedException("Used bad value of insert parameter. Possible values are "
+ + "first, last, before or after, but was: " + insert);
}
}
return readData;
}
- private static void insertWithPointLeafListPut(final DOMDataReadWriteTransaction rwTransaction,
+ private static void insertWithPointLeafListPut(final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data, final SchemaContext schemaContext, final String point,
final OrderedLeafSetNode<?> readLeafList, final boolean before) {
rwTransaction.delete(datastore, path.getParent());
final InstanceIdentifierContext<?> instanceIdentifier =
- ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final LeafSetEntryNode<?> nodeChild : readLeafList.getValue()) {
if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
}
}
- private static void insertWithPointListPut(final DOMDataReadWriteTransaction writeTx,
+ private static void insertWithPointListPut(final DOMDataTreeReadWriteTransaction writeTx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data, final SchemaContext schemaContext, final String point,
final OrderedMapNode readList, final boolean before) {
writeTx.delete(datastore, path.getParent());
final InstanceIdentifierContext<?> instanceIdentifier =
- ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final MapEntryNode mapEntryNode : readList.getValue()) {
if (mapEntryNode.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
}
private static void listPut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
- final DOMDataReadWriteTransaction writeTx, final SchemaContext schemaContext,
+ final DOMDataTreeWriteTransaction writeTx, final SchemaContext schemaContext,
final OrderedLeafSetNode<?> payload) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
writeTx.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
}
private static void listPut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
- final DOMDataReadWriteTransaction writeTx, final SchemaContext schemaContext,
+ final DOMDataTreeWriteTransaction writeTx, final SchemaContext schemaContext,
final OrderedMapNode payload) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
writeTx.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
}
private static void simplePut(final LogicalDatastoreType configuration, final YangInstanceIdentifier path,
- final DOMDataReadWriteTransaction writeTx, final SchemaContext schemaContext,
+ final DOMDataTreeWriteTransaction writeTx, final SchemaContext schemaContext,
final NormalizedNode<?, ?> data) {
TransactionUtil.ensureParentsByMerge(path, schemaContext, writeTx);
writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data);
}
- private static CheckedFuture<Void, TransactionCommitFailedException> makePut(final YangInstanceIdentifier path,
- final SchemaContext schemaContext, final DOMDataWriteTransaction writeTx, final NormalizedNode<?, ?> data) {
+ private static FluentFuture<? extends CommitInfo> makePut(final YangInstanceIdentifier path,
+ final SchemaContext schemaContext, final DOMDataTreeWriteTransaction writeTx,
+ final NormalizedNode<?, ?> data) {
TransactionUtil.ensureParentsByMerge(path, schemaContext, writeTx);
writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data);
- return writeTx.submit();
+ return writeTx.commit();
}
public static DataSchemaNode checkListAndOrderedType(final SchemaContext ctx, final YangInstanceIdentifier path) {
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAMS_PATH;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_PATH_PART;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import com.google.common.primitives.Ints;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.ws.rs.core.UriInfo;
-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.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.WriterParameters;
import org.opendaylight.restconf.common.context.WriterParameters.WriterParametersBuilder;
final SchemaContextRef schemaContextRef, final UriInfo uriInfo) {
final SchemaContext schemaContext = schemaContextRef.get();
if (identifier.contains(STREAMS_PATH) && !identifier.contains(STREAM_PATH_PART)) {
- final DOMDataReadWriteTransaction wTx = transactionNode.getTransactionChain().newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction wTx = transactionNode.getTransactionChain().newReadWriteTransaction();
final boolean exist = SubscribeToStreamUtil.checkExist(schemaContext, wTx);
for (final NotificationDefinition notificationDefinition : schemaContextRef.get().getNotifications()) {
private static NormalizedNode<?, ?> readDataViaTransaction(
@Nonnull final TransactionVarsWrapper transactionNode) {
final NormalizedNodeFactory dataFactory = new NormalizedNodeFactory();
- try (DOMDataReadOnlyTransaction tx = transactionNode.getTransactionChain().newReadOnlyTransaction()) {
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> listenableFuture = tx.read(
+ try (DOMDataTreeReadTransaction tx = transactionNode.getTransactionChain().newReadOnlyTransaction()) {
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = tx.read(
transactionNode.getLogicalDatastoreType(),
transactionNode.getInstanceIdentifier().getInstanceIdentifier());
FutureCallbackTx.addCallback(listenableFuture, RestconfDataServiceConstant.ReadData.READ_TYPE_TX,
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.ResponseBuilder;
import javax.ws.rs.core.Response.Status;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.concepts.Builder;
-final class ResponseFactory extends FutureDataFactory<Void> implements Builder<Response> {
+final class ResponseFactory extends FutureDataFactory<CommitInfo> implements Builder<Response> {
private ResponseBuilder responseBuilder;
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import java.util.concurrent.CancellationException;
import javax.ws.rs.core.Response.Status;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
* input data
* @param schemaPath
* schema path of data
- * @return {@link CheckedFuture}
+ * @return {@link DOMRpcResult}
*/
public static DOMRpcResult invokeRpcViaMountPoint(final DOMMountPoint mountPoint, final NormalizedNode<?, ?> data,
final SchemaPath schemaPath) {
final Optional<DOMRpcService> mountPointService = mountPoint.getService(DOMRpcService.class);
if (mountPointService.isPresent()) {
- final CheckedFuture<DOMRpcResult, DOMRpcException> rpc = mountPointService.get().invokeRpc(schemaPath,
- data);
+ final FluentFuture<DOMRpcResult> rpc = mountPointService.get().invokeRpc(schemaPath, data);
return prepareResult(rpc);
}
final String errmsg = "RPC service is missing.";
* schema path of data
* @param rpcServiceHandler
* rpc service handler to invoke rpc
- * @return {@link CheckedFuture}
+ * @return {@link DOMRpcResult}
*/
public static DOMRpcResult invokeRpc(final NormalizedNode<?, ?> data, final SchemaPath schemaPath,
final RpcServiceHandler rpcServiceHandler) {
throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
}
- final CheckedFuture<DOMRpcResult, DOMRpcException> rpc = rpcService.invokeRpc(schemaPath, data);
+ final FluentFuture<DOMRpcResult> rpc = rpcService.invokeRpc(schemaPath, data);
return prepareResult(rpc);
}
}
}
- private static DOMRpcResult prepareResult(final CheckedFuture<DOMRpcResult, DOMRpcException> rpc) {
+ private static DOMRpcResult prepareResult(final FluentFuture<DOMRpcResult> rpc) {
final RpcResultFactory dataFactory = new RpcResultFactory();
FutureCallbackTx.addCallback(rpc, RestconfDataServiceConstant.PostData.POST_TX_TYPE, dataFactory);
return dataFactory.build();
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.restconf.common.util.DataChangeScope;
import org.opendaylight.restconf.nb.rfc8040.utils.RestconfConstants;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.builder.ParserBuilderConstants;
*/
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yangtools.concepts.Builder;
public class RpcResultFactory extends FutureDataFactory<DOMRpcResult> implements Builder<DOMRpcResult> {
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.concurrent.ExecutionException;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-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.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
/**
* Subscribe to stream util class.
- *
*/
public final class SubscribeToStreamUtil {
ErrorTag.UNKNOWN_ELEMENT);
}
- final DOMDataReadWriteTransaction wTx =
+ final DOMDataTreeReadWriteTransaction wTx =
handlersHolder.getTransactionChainHandler().get().newReadWriteTransaction();
final SchemaContext schemaContext = handlersHolder.getSchemaHandler().get();
final boolean exist = checkExist(schemaContext, wTx);
final URI uri = prepareUriByStreamName(uriInfo, streamName);
- final DOMDataReadWriteTransaction wTx =
+ final DOMDataTreeReadWriteTransaction wTx =
handlersHolder.getTransactionChainHandler().get().newReadWriteTransaction();
final SchemaContext schemaContext = handlersHolder.getSchemaHandler().get();
final boolean exist = checkExist(schemaContext, wTx);
@SuppressWarnings("rawtypes")
static void writeDataToDS(final SchemaContext schemaContext,
- final String name, final DOMDataReadWriteTransaction readWriteTransaction,
+ final String name, final DOMDataTreeReadWriteTransaction readWriteTransaction,
final boolean exist, final NormalizedNode mapToStreams) {
String pathId = "";
if (exist) {
mapToStreams);
}
- static void submitData(final DOMDataReadWriteTransaction readWriteTransaction) {
+ static void submitData(final DOMDataTreeReadWriteTransaction readWriteTransaction) {
try {
- readWriteTransaction.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ readWriteTransaction.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
throw new RestconfDocumentedException("Problem while putting data to DS.", e);
}
}
return;
}
- final DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)domDataBroker.getSupportedExtensions()
- .get(DOMDataTreeChangeService.class);
+ final DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
if (changeService == null) {
throw new UnsupportedOperationException("DOMDataBroker does not support the DOMDataTreeChangeService");
}
}
static boolean checkExist(final SchemaContext schemaContext,
- final DOMDataReadWriteTransaction readWriteTransaction) {
+ final DOMDataTreeReadTransaction readWriteTransaction) {
boolean exist;
try {
exist = readWriteTransaction.exists(LogicalDatastoreType.OPERATIONAL,
- IdentifierCodec.deserialize(MonitoringModule.PATH_TO_STREAMS, schemaContext)).checkedGet();
- } catch (final ReadFailedException e1) {
- throw new RestconfDocumentedException("Problem while checking data if exists", e1);
+ IdentifierCodec.deserialize(MonitoringModule.PATH_TO_STREAMS, schemaContext)).get();
+ } catch (final InterruptedException | ExecutionException e) {
+ throw new RestconfDocumentedException("Problem while checking data if exists", e);
}
return exist;
}
* 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.restconf.nb.rfc8040.rests.utils;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
-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.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
* write transaction
*/
public static void ensureParentsByMerge(final YangInstanceIdentifier path, final SchemaContext schemaContext,
- final DOMDataWriteTransaction writeTx) {
+ final DOMDataTreeWriteTransaction writeTx) {
final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
YangInstanceIdentifier rootNormalizedPath = null;
* @param operationType Type of operation (READ, POST, PUT, DELETE...)
*/
public static void checkItemExists(final TransactionChainHandler transactionChainHandler,
- final DOMDataReadWriteTransaction rwTransaction,
+ final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path,
final String operationType) {
- final CheckedFuture<Boolean, ReadFailedException> future = rwTransaction.exists(store, path);
+ final FluentFuture<Boolean> future = rwTransaction.exists(store, path);
final FutureDataFactory<Boolean> response = new FutureDataFactory<>();
FutureCallbackTx.addCallback(future, operationType, response);
* @param operationType Type of operation (READ, POST, PUT, DELETE...)
*/
public static void checkItemDoesNotExists(final TransactionChainHandler transactionChainHandler,
- final DOMDataReadWriteTransaction rwTransaction,
+ final DOMDataTreeReadWriteTransaction rwTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path,
final String operationType) {
- final CheckedFuture<Boolean, ReadFailedException> future = rwTransaction.exists(store, path);
+ final FluentFuture<Boolean> future = rwTransaction.exists(store, path);
final FutureDataFactory<Boolean> response = new FutureDataFactory<>();
FutureCallbackTx.addCallback(future, operationType, response);
*/
package org.opendaylight.restconf.nb.rfc8040.services.simple.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Optional;
import java.util.Set;
import javax.ws.rs.Path;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040.MonitoringModule;
import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
* Delete data in DS.
*/
protected void deleteDataInDS() throws Exception {
- final DOMDataWriteTransaction wTx = this.transactionChainHandler.get().newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction wTx = this.transactionChainHandler.get().newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, IdentifierCodec
.deserialize(MonitoringModule.PATH_TO_STREAM_WITHOUT_KEY + this.localName, this.schemaHandler.get()));
- wTx.submit().checkedGet();
+ wTx.commit().get();
}
/**
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import org.json.XML;
-import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
+import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
}
private Node createCreatedChangedDataChangeEventElement(final Document doc,
- final YangInstanceIdentifier eventPath, NormalizedNode<?, ?> normalized, final Operation operation,
+ final YangInstanceIdentifier eventPath, final NormalizedNode<?, ?> normalized, final Operation operation,
final SchemaContext schemaContext, final DataSchemaContextTree dataSchemaContextTree) {
final Element dataChangeEventElement = doc.createElement("data-change-event");
final Element pathElement = doc.createElement("path");
import java.util.Collection;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
*/
package org.opendaylight.restconf.nb.rfc8040.utils.mapping;
-import com.google.common.base.Optional;
import java.net.URI;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary;
final Module monitoringModule, final boolean existParent, final SchemaContext schemaContext) {
final SchemaNode schemaNode = ParserIdentifier
.toInstanceIdentifier(ParserIdentifier.stringFromYangInstanceIdentifier(path, schemaContext),
- schemaContext, Optional.absent())
+ schemaContext, Optional.empty())
.getSchemaNode();
final DataSchemaNode streamListSchema = ((ContainerSchemaNode) ((ContainerSchemaNode) monitoringModule
.getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
*/
package org.opendaylight.restconf.nb.rfc8040.utils.parser;
-import com.google.common.base.Optional;
import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import java.time.format.DateTimeParseException;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import java.util.Optional;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
</cm:default-properties>
</cm:property-placeholder>
- <reference id="domRpcService" interface="org.opendaylight.controller.md.sal.dom.api.DOMRpcService"/>
- <reference id="domMountPointService" interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"/>
- <reference id="domNotificationService" interface="org.opendaylight.controller.md.sal.dom.api.DOMNotificationService"/>
- <reference id="domDataBroker" interface="org.opendaylight.controller.md.sal.dom.api.DOMDataBroker"
+ <reference id="domRpcService" interface="org.opendaylight.mdsal.dom.api.DOMRpcService"/>
+ <reference id="domMountPointService" interface="org.opendaylight.mdsal.dom.api.DOMMountPointService"/>
+ <reference id="domNotificationService" interface="org.opendaylight.mdsal.dom.api.DOMNotificationService"/>
+ <reference id="domDataBroker" interface="org.opendaylight.mdsal.dom.api.DOMDataBroker"
ext:filter="(type=@{databroker-service-type})"/>
<reference id="domSchemaService" interface="org.opendaylight.mdsal.dom.api.DOMSchemaService"/>
* 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.restconf.nb.rfc8040;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
public static NormalizedNodeContext loadNormalizedContextFromXmlFile(final String pathToInputFile,
final String uri, final SchemaContext schemaContext) {
final InstanceIdentifierContext<?> iiContext =
- ParserIdentifier.toInstanceIdentifier(uri, schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(uri, schemaContext, Optional.empty());
final InputStream inputStream = TestRestconfUtils.class.getResourceAsStream(pathToInputFile);
try {
final Document doc = UntrustedXML.newDocumentBuilder().parse(inputStream);
import static org.mockito.Mockito.mock;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.Futures;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.mockito.Mockito;
-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.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
return mapEntryNode.build();
}
- public static SchemaContextHandler newSchemaContextHandler(SchemaContext schemaContext) {
+ public static SchemaContextHandler newSchemaContextHandler(final SchemaContext schemaContext) {
DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
DOMTransactionChain mockChain = mock(DOMTransactionChain.class);
- DOMDataWriteTransaction mockTx = mock(DOMDataWriteTransaction.class);
- doReturn(Futures.immediateCheckedFuture(null)).when(mockTx).submit();
+ DOMDataTreeWriteTransaction mockTx = mock(DOMDataTreeWriteTransaction.class);
+ doReturn(CommitInfo.emptyFluentFuture()).when(mockTx).commit();
doReturn(mockTx).when(mockChain).newWriteOnlyTransaction();
doReturn(mockChain).when(mockDataBroker).createTransactionChain(any());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import com.google.common.util.concurrent.CheckedFuture;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-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.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final TransactionChainHandler txHandler = Mockito.mock(TransactionChainHandler.class);
final DOMTransactionChain domTx = Mockito.mock(DOMTransactionChain.class);
Mockito.when(txHandler.get()).thenReturn(domTx);
- final DOMDataWriteTransaction wTx = Mockito.mock(DOMDataWriteTransaction.class);
+ final DOMDataTreeWriteTransaction wTx = Mockito.mock(DOMDataTreeWriteTransaction.class);
Mockito.when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
- final CheckedFuture<Void,TransactionCommitFailedException> checked = Mockito.mock(CheckedFuture.class);
- Mockito.when(wTx.submit()).thenReturn(checked);
- Mockito.when(checked.checkedGet()).thenReturn(null);
-
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
this.schemaContextHandler = SchemaContextHandler.newInstance(txHandler, mockDOMSchemaService);
* 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.restconf.nb.rfc8040.jersey.providers;
import static org.junit.Assert.assertEquals;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
* 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.restconf.nb.rfc8040.jersey.providers.test;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.Collections;
+import java.util.Optional;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.UriInfo;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.patch.PatchContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
protected final SchemaContextHandler schemaContextHandler;
protected final DOMMountPointServiceHandler mountPointServiceHandler;
- protected AbstractBodyReaderTest(SchemaContext schemaContext) throws NoSuchFieldException, IllegalAccessException {
+ protected AbstractBodyReaderTest(final SchemaContext schemaContext) throws NoSuchFieldException,
+ IllegalAccessException {
mediaType = getMediaType();
schemaContextHandler = TestUtils.newSchemaContextHandler(schemaContext);
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.io.Resources;
-import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-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.DOMDataBroker;
-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.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.restconf.nb.rfc8040.TestUtils;
import org.opendaylight.restconf.nb.rfc8040.handlers.DOMDataBrokerHandler;
import org.opendaylight.restconf.nb.rfc8040.handlers.DOMMountPointServiceHandler;
private DOMTransactionChain mockTxChain;
@Mock
- private DOMDataReadWriteTransaction mockReadWriteTx;
+ private DOMDataTreeReadWriteTransaction mockReadWriteTx;
@Mock
- private DOMDataReadOnlyTransaction mockReadOnlyTx;
+ private DOMDataTreeReadTransaction mockReadOnlyTx;
@Mock
- private DOMDataWriteTransaction mockWriteTx;
+ private DOMDataTreeWriteTransaction mockWriteTx;
@Mock
private DOMMountPointService mockMountPointService;
doReturn(ImmutableClassToInstanceMap.of()).when(domSchemaService).getExtensions();
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadOnlyTx).read(
+ doReturn(immediateFluentFuture(Optional.empty())).when(mockReadOnlyTx).read(
eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class));
doNothing().when(mockWriteTx).put(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class),
doNothing().when(mockWriteTx).merge(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class),
any(NormalizedNode.class));
doNothing().when(mockWriteTx).delete(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class));
- doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(mockWriteTx).commit();
doNothing().when(mockReadWriteTx).put(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class),
any(NormalizedNode.class));
- doReturn(Futures.immediateCheckedFuture(null)).when(mockReadWriteTx).submit();
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadWriteTx).read(
+ doReturn(CommitInfo.emptyFluentFuture()).when(mockReadWriteTx).commit();
+ doReturn(immediateFluentFuture(Optional.empty())).when(mockReadWriteTx).read(
eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class));
- doReturn(Futures.immediateCheckedFuture(Boolean.FALSE)).when(mockReadWriteTx).exists(
+ doReturn(immediateFalseFluentFuture()).when(mockReadWriteTx).exists(
eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class));
doReturn(mockReadOnlyTx).when(mockTxChain).newReadOnlyTransaction();
@Test(expected = OperationFailedException.class)
@SuppressWarnings("checkstyle:IllegalThrows")
public void testPutFailure() throws Throwable {
- doReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")))
- .when(mockReadWriteTx).submit();
+ doReturn(immediateFailedFluentFuture(new TransactionCommitFailedException("mock")))
+ .when(mockReadWriteTx).commit();
final String uriPath = "ietf-interfaces:interfaces/interface=eth0";
final String payload = loadData("/parts/ietf-interfaces_interfaces.json");
verifyLeafNode(actualNode, TEST_LF12_QNAME, "lf12 data");
}
- @Test(expected = TransactionCommitFailedException.class)
- @SuppressWarnings({ "checkstyle:IllegalThrows", "checkstyle:avoidHidingCauseException" })
- public void testPostFailure() throws Throwable {
- doReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")))
- .when(mockReadWriteTx).submit();
+ @Test
+ public void testPostFailure() throws IOException {
+ final Exception failure = new TransactionCommitFailedException("mock");
+ doReturn(immediateFailedFluentFuture(failure)).when(mockReadWriteTx).commit();
- final String uriPath = null;
final String payload = loadData("/parts/ietf-interfaces_interfaces_absolute_path.json");
-
try {
- this.service.post(uriPath, payload);
+ this.service.post(null, payload);
+ fail();
} catch (final OperationFailedException e) {
- assertNotNull(e.getCause());
- throw e.getCause();
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertSame(failure, cause.getCause());
}
}
@Test
@SuppressWarnings("checkstyle:IllegalThrows")
public void testPatchFailure() throws Throwable {
- doReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")))
- .when(mockReadWriteTx).submit();
+ doReturn(immediateFailedFluentFuture(new TransactionCommitFailedException("mock")))
+ .when(mockReadWriteTx).commit();
final String uriPath = "ietf-interfaces:interfaces/interface=eth0";
@Test
public void testDelete() throws Exception {
- doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(mockReadWriteTx).exists(
+ doReturn(immediateTrueFluentFuture()).when(mockReadWriteTx).exists(
eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class));
final String uriPath = "ietf-interfaces:interfaces/interface=eth0";
final SchemaPath path = SchemaPath.create(true, MAKE_TOAST_QNAME);
final DOMRpcResult expResult = new DefaultDOMRpcResult((NormalizedNode<?, ?>)null);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(mockRpcService).invokeRpc(eq(path),
- any(NormalizedNode.class));
+ doReturn(immediateFluentFuture(expResult)).when(mockRpcService).invokeRpc(eq(path), any(NormalizedNode.class));
final String uriPath = "toaster:make-toast";
final String input = loadData("/full-versions/make-toast-rpc-input.json");
final SchemaPath path = SchemaPath.create(true, CANCEL_TOAST_QNAME);
final DOMRpcResult expResult = new DefaultDOMRpcResult((NormalizedNode<?, ?>)null);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(mockRpcService).invokeRpc(eq(path), isNull());
+ doReturn(immediateFluentFuture(expResult)).when(mockRpcService).invokeRpc(eq(path), isNull());
final String uriPath = "toaster:cancel-toast";
- final Optional<String> output = this.service.invokeRpc(uriPath, Optional.absent());
+ final Optional<String> output = this.service.invokeRpc(uriPath, Optional.empty());
assertEquals("Output present", false, output.isPresent());
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_OUTPUT_QNAME))
.withChild(ImmutableNodes.leafNode(TEXT_OUT_QNAME, "foo")).build();
final DOMRpcResult expResult = new DefaultDOMRpcResult(outputNode);
- doReturn(Futures.immediateCheckedFuture(expResult)).when(mockRpcService).invokeRpc(eq(path), isNull());
+ doReturn(immediateFluentFuture(expResult)).when(mockRpcService).invokeRpc(eq(path), isNull());
final String uriPath = "toaster:testOutput";
- final Optional<String> output = this.service.invokeRpc(uriPath, Optional.absent());
+ final Optional<String> output = this.service.invokeRpc(uriPath, Optional.empty());
assertEquals("Output present", true, output.isPresent());
assertNotNull("Returned null response", output.get());
@Test(expected = OperationFailedException.class)
public void testInvokeRpcFailure() throws Exception {
final DOMRpcException exception = new DOMRpcImplementationNotAvailableException("testExeption");
- doReturn(Futures.immediateFailedCheckedFuture(exception)).when(mockRpcService).invokeRpc(any(SchemaPath.class),
+ doReturn(immediateFailedFluentFuture(exception)).when(mockRpcService).invokeRpc(any(SchemaPath.class),
any(NormalizedNode.class));
final String uriPath = "toaster:cancel-toast";
- this.service.invokeRpc(uriPath, Optional.absent());
+ this.service.invokeRpc(uriPath, Optional.empty());
}
void testGet(final LogicalDatastoreType datastoreType) throws OperationFailedException {
.withChild(ImmutableNodes.leafNode(DESC_QNAME, "eth interface"))
.build();
- doReturn(Futures.immediateCheckedFuture(Optional.of(entryNode))).when(mockReadOnlyTx).read(
+ doReturn(immediateFluentFuture(Optional.of(entryNode))).when(mockReadOnlyTx).read(
eq(datastoreType), any(YangInstanceIdentifier.class));
final String uriPath = "ietf-interfaces:interfaces/interface=eth0";
import static org.opendaylight.restconf.common.patch.PatchEditOperation.DELETE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.REPLACE;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-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.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
@Mock
private UriInfo uriInfo;
@Mock
- private DOMDataReadWriteTransaction readWrite;
+ private DOMDataTreeReadWriteTransaction readWrite;
@Mock
- private DOMDataReadOnlyTransaction read;
+ private DOMDataTreeReadTransaction read;
@Mock
- private DOMDataWriteTransaction write;
+ private DOMDataTreeWriteTransaction write;
@Mock
private DOMMountPointService mountPointService;
@Mock
YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)));
this.schemaNode = DataSchemaContextTree.from(this.contextRef.get()).getChild(this.iidBase).getDataSchemaNode();
- doReturn(Futures.immediateCheckedFuture(null)).when(this.write).submit();
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.write).commit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
doReturn(this.read).when(domTransactionChain).newReadOnlyTransaction();
doReturn(this.readWrite).when(domTransactionChain).newReadWriteTransaction();
doReturn(this.contextRef.get()).when(this.mountPoint).getSchemaContext();
doReturn(Optional.of(this.mountDataBroker)).when(this.mountPoint).getService(DOMDataBroker.class);
doReturn(this.mountTransactionChain).when(this.mountDataBroker)
- .createTransactionChain(any(TransactionChainListener.class));
+ .createTransactionChain(any(DOMTransactionChainListener.class));
doReturn(this.read).when(this.mountTransactionChain).newReadOnlyTransaction();
doReturn(this.readWrite).when(this.mountTransactionChain).newReadWriteTransaction();
}
@Test
public void testReadData() {
doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseCont))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(Optional.absent()))
+ doReturn(immediateFluentFuture(Optional.empty()))
.when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
assertNotNull(response);
@Test
public void testReadDataMountPoint() {
doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
.read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
final Response response = this.dataService.readData(
@Test(expected = RestconfDocumentedException.class)
public void testReadDataNoData() {
doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
- doReturn(Futures.immediateCheckedFuture(Optional.absent()))
+ doReturn(immediateFluentFuture(Optional.empty()))
.when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(Optional.absent()))
+ doReturn(immediateFluentFuture(Optional.empty()))
.when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
}
parameters.put("content", Collections.singletonList("config"));
doReturn(parameters).when(this.uriInfo).getQueryParameters();
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
.read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
parameters.put("content", Collections.singletonList("nonconfig"));
doReturn(parameters).when(this.uriInfo).getQueryParameters();
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
.read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef.get());
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
- doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(this.readWrite)
+ doReturn(immediateTrueFluentFuture()).when(this.readWrite)
.exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData());
final Response response = this.dataService.putData(null, payload, this.uriInfo);
new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, mountPoint, this.contextRef.get());
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
- doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(this.readWrite)
+ doReturn(immediateTrueFluentFuture()).when(this.readWrite)
.exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData());
final Response response = this.dataService.putData(null, payload, this.uriInfo);
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
new InstanceIdentifierContext<>(this.iidBase, null, null, this.contextRef.get());
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildList);
- doReturn(Futures.immediateCheckedFuture(Optional.absent()))
+ doReturn(immediateFluentFuture(Optional.empty()))
.when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
final MapNode data = (MapNode) payload.getData();
final YangInstanceIdentifier.NodeIdentifierWithPredicates identifier =
data.getValue().iterator().next().getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
- doReturn(Futures.immediateCheckedFuture(false))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(this.uriInfo).getBaseUriBuilder();
@Test
public void testDeleteData() {
doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(true))
+ doReturn(immediateTrueFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
final Response response = this.dataService.deleteData("example-jukebox:jukebox");
assertNotNull(response);
@Test
public void testDeleteDataMountPoint() {
doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(true))
+ doReturn(immediateTrueFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
final Response response =
this.dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
entity.add(new PatchEntity("delete data", DELETE, iidleaf));
final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseCont))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
- doReturn(Futures.immediateCheckedFuture(false))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(true))
+ doReturn(immediateTrueFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
assertTrue(status.isOk());
entity.add(new PatchEntity("delete data", DELETE, iidleaf));
final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseCont))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
- doReturn(Futures.immediateCheckedFuture(false))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(true))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
+ doReturn(immediateTrueFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
assertTrue(status.isOk());
entity.add(new PatchEntity("delete data", DELETE, iidleaf));
final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
- doReturn(Futures.immediateCheckedFuture(Optional.of(this.buildBaseCont))).when(this.read)
+ doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
.read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
- doReturn(Futures.immediateCheckedFuture(false))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
- doReturn(Futures.immediateCheckedFuture(false))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
doReturn(true).when(this.readWrite).cancel();
final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
* 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.restconf.nb.rfc8040.rests.services.impl;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
+
import javax.ws.rs.core.UriInfo;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-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.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
MockitoAnnotations.initMocks(this);
final SchemaContextRef contextRef = new SchemaContextRef(
YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)));
- final TransactionChainHandler txHandler = Mockito.mock(TransactionChainHandler.class);
- final DOMTransactionChain domTx = Mockito.mock(DOMTransactionChain.class);
- Mockito.when(txHandler.get()).thenReturn(domTx);
- final DOMDataWriteTransaction wTx = Mockito.mock(DOMDataWriteTransaction.class);
- Mockito.when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
- final CheckedFuture<Void, TransactionCommitFailedException> checked = Mockito.mock(CheckedFuture.class);
- Mockito.when(wTx.submit()).thenReturn(checked);
- Mockito.when(checked.checkedGet()).thenReturn(null);
- final SchemaContextHandler schemaContextHandler =
- SchemaContextHandler.newInstance(txHandler, Mockito.mock(DOMSchemaService.class));
+ final TransactionChainHandler txHandler = mock(TransactionChainHandler.class);
+ final DOMTransactionChain domTx = mock(DOMTransactionChain.class);
+ when(txHandler.get()).thenReturn(domTx);
+ final DOMDataTreeWriteTransaction wTx = mock(DOMDataTreeWriteTransaction.class);
+ when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
+ doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
+ final SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(txHandler,
+ mock(DOMSchemaService.class));
schemaContextHandler.onGlobalContextUpdated(contextRef.get());
this.invokeOperationsService =
new RestconfInvokeOperationsServiceImpl(this.rpcServiceHandler, schemaContextHandler);
- Mockito.when(this.rpcServiceHandler.get()).thenReturn(this.rpcService);
+ when(this.rpcServiceHandler.get()).thenReturn(this.rpcService);
}
@Test
public void testInvokeRpc() throws Exception {
final String identifier = "invoke-rpc-module:rpcTest";
- final NormalizedNode<?, ?> result = Mockito.mock(NormalizedNode.class);
+ final NormalizedNode<?, ?> result = mock(NormalizedNode.class);
final NormalizedNodeContext payload = prepNNC(result);
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final NormalizedNodeContext rpc = this.invokeOperationsService.invokeRpc(identifier, payload, uriInfo);
- Assert.assertEquals(result, rpc.getData());
+ assertEquals(result, rpc.getData());
}
- private NormalizedNodeContext prepNNC(final NormalizedNode result) {
- final InstanceIdentifierContext context = Mockito.mock(InstanceIdentifierContext.class);
- final RpcDefinition schemaNode = Mockito.mock(RpcDefinition.class);
+ private NormalizedNodeContext prepNNC(final NormalizedNode<?, ?> result) {
+ final InstanceIdentifierContext<?> context = mock(InstanceIdentifierContext.class);
+ final RpcDefinition schemaNode = mock(RpcDefinition.class);
final QName qname = QName.create("invoke:rpc:module", "2013-12-03", "rpcTest");
final SchemaPath schemaPath = SchemaPath.create(true, qname);
- Mockito.when(schemaNode.getPath()).thenReturn(schemaPath);
- Mockito.when(schemaNode.getQName()).thenReturn(qname);
- Mockito.when(context.getSchemaNode()).thenReturn(schemaNode);
- final NormalizedNode<?, ?> data = Mockito.mock(NormalizedNode.class);
- final DOMRpcResult domRpcResult = Mockito.mock(DOMRpcResult.class);
- final CheckedFuture<DOMRpcResult, DOMRpcException> checkdFuture = Futures.immediateCheckedFuture(domRpcResult);
- Mockito.when(this.rpcService.invokeRpc(schemaPath, data)).thenReturn(checkdFuture);
- Mockito.when(domRpcResult.getResult()).thenReturn(result);
+ when(schemaNode.getPath()).thenReturn(schemaPath);
+ when(schemaNode.getQName()).thenReturn(qname);
+ doReturn(schemaNode).when(context).getSchemaNode();
+ final NormalizedNode<?, ?> data = mock(NormalizedNode.class);
+ final DOMRpcResult domRpcResult = mock(DOMRpcResult.class);
+ when(this.rpcService.invokeRpc(schemaPath, data)).thenReturn(immediateFluentFuture(domRpcResult));
+ doReturn(result).when(domRpcResult).getResult();
return new NormalizedNodeContext(context, data);
}
-
}
* 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.restconf.nb.rfc8040.rests.services.impl;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import java.lang.reflect.Field;
import java.net.URI;
-import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-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.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.util.SimpleUriInfo;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-@SuppressWarnings("deprecation")
public class RestconfStreamsSubscriptionServiceImplTest {
private static final String URI = "/restconf/18/data/ietf-restconf-monitoring:restconf-state/streams/stream/"
MockitoAnnotations.initMocks(this);
final DOMTransactionChain domTx = mock(DOMTransactionChain.class);
- final DOMDataWriteTransaction wTx = Mockito.mock(DOMDataWriteTransaction.class);
- Mockito.when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
- final DOMDataReadWriteTransaction rwTx = Mockito.mock(DOMDataReadWriteTransaction.class);
- final CheckedFuture<Boolean, ReadFailedException> checkedFuture = Futures.immediateCheckedFuture(Boolean.TRUE);
- Mockito.when(rwTx.exists(Mockito.any(), Mockito.any())).thenReturn(checkedFuture);
- final CheckedFuture<Void, TransactionCommitFailedException> checkedFutureEmpty =
- Futures.immediateCheckedFuture(null);
- Mockito.when(rwTx.submit()).thenReturn(checkedFutureEmpty);
- Mockito.when(domTx.newReadWriteTransaction()).thenReturn(rwTx);
- final CheckedFuture<Void, TransactionCommitFailedException> checked = mock(CheckedFuture.class);
- Mockito.when(wTx.submit()).thenReturn(checked);
- Mockito.when(checked.checkedGet()).thenReturn(null);
+ final DOMDataTreeWriteTransaction wTx = mock(DOMDataTreeWriteTransaction.class);
+ when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
+ final DOMDataTreeReadWriteTransaction rwTx = mock(DOMDataTreeReadWriteTransaction.class);
+ when(rwTx.exists(any(), any())).thenReturn(immediateTrueFluentFuture());
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTx).commit();
+ when(domTx.newReadWriteTransaction()).thenReturn(rwTx);
+ doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
final DOMDataBroker dataBroker = mock(DOMDataBroker.class);
doReturn(domTx).when(dataBroker).createTransactionChain(any());
transactionHandler = new TransactionChainHandler(dataBroker);
- schemaHandler = SchemaContextHandler.newInstance(transactionHandler, Mockito.mock(DOMSchemaService.class));
+ schemaHandler = SchemaContextHandler.newInstance(transactionHandler, mock(DOMSchemaService.class));
DOMDataTreeChangeService dataTreeChangeService = mock(DOMDataTreeChangeService.class);
doReturn(mock(ListenerRegistration.class)).when(dataTreeChangeService)
.registerDataTreeChangeListener(any(), any());
- doReturn(Collections.singletonMap(DOMDataTreeChangeService.class, dataTreeChangeService))
- .when(dataBroker).getSupportedExtensions();
+ doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, dataTreeChangeService))
+ .when(dataBroker).getExtensions();
doReturn(dataBroker).when(this.dataBrokerHandler).get();
final MultivaluedMap<String, String> map = mock(MultivaluedMap.class);
final Set<Entry<String, List<String>>> set = new HashSet<>();
- Mockito.when(map.entrySet()).thenReturn(set);
- Mockito.when(this.uriInfo.getQueryParameters()).thenReturn(map);
+ when(map.entrySet()).thenReturn(set);
+ when(this.uriInfo.getQueryParameters()).thenReturn(map);
final UriBuilder baseUriBuilder = new LocalUriInfo().getBaseUriBuilder();
- Mockito.when(uriInfo.getBaseUri()).thenReturn(baseUriBuilder.build());
- Mockito.when(uriInfo.getBaseUriBuilder()).thenReturn(baseUriBuilder);
+ when(uriInfo.getBaseUri()).thenReturn(baseUriBuilder.build());
+ when(uriInfo.getBaseUriBuilder()).thenReturn(baseUriBuilder);
this.schemaHandler.onGlobalContextUpdated(
YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/notifications")));
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
* 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.restconf.nb.rfc8040.rests.utils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.util.concurrent.Futures;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
@Mock
private InstanceIdentifierContext<?> context;
@Mock
- private DOMDataReadWriteTransaction readWrite;
+ private DOMDataTreeReadWriteTransaction readWrite;
@Mock
private DOMDataBroker mockDataBroker;
public void init() throws Exception {
MockitoAnnotations.initMocks(this);
Mockito.when(this.transactionChain.newReadWriteTransaction()).thenReturn(this.readWrite);
- Mockito.when(this.readWrite.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
Mockito.when(this.context.getInstanceIdentifier()).thenReturn(YangInstanceIdentifier.EMPTY);
Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
public void deleteData() throws Exception {
// assert that data to delete exists
Mockito.when(this.transactionChain.newReadWriteTransaction().exists(LogicalDatastoreType.CONFIGURATION,
- YangInstanceIdentifier.EMPTY))
- .thenReturn(Futures.immediateCheckedFuture(Boolean.TRUE));
+ YangInstanceIdentifier.EMPTY)).thenReturn(immediateTrueFluentFuture());
// test
final Response response = DeleteDataTransactionUtil.deleteData(
public void deleteDataNegativeTest() throws Exception {
// assert that data to delete does NOT exist
Mockito.when(this.transactionChain.newReadWriteTransaction().exists(LogicalDatastoreType.CONFIGURATION,
- YangInstanceIdentifier.EMPTY))
- .thenReturn(Futures.immediateCheckedFuture(Boolean.FALSE));
+ YangInstanceIdentifier.EMPTY)).thenReturn(immediateFalseFluentFuture());
// test and assert error
try {
* 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.restconf.nb.rfc8040.rests.utils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.CREATE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.MERGE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.REPLACE;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.patch.PatchContext;
private DOMTransactionChain transactionChain;
@Mock
- private DOMDataReadWriteTransaction rwTransaction;
+ private DOMDataTreeReadWriteTransaction rwTransaction;
@Mock
private DOMDataBroker mockDataBroker;
public void setUp() throws Exception {
initMocks(this);
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
+ doReturn(transactionChain).when(mockDataBroker).createTransactionChain(any());
transactionChainHandler = new TransactionChainHandler(mockDataBroker);
this.refSchemaCtx = new SchemaContextRef(
/* Mocks */
doReturn(this.rwTransaction).when(this.transactionChain).newReadWriteTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(this.rwTransaction).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
}
@Test
public void testPatchDataReplaceMergeAndRemove() {
- doReturn(Futures.immediateCheckedFuture(false)).doReturn(Futures.immediateCheckedFuture(true))
+ doReturn(immediateFalseFluentFuture()).doReturn(immediateTrueFluentFuture())
.when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.targetNodeMerge);
final PatchEntity entityReplace =
@Test
public void testPatchDataCreateAndDelete() throws Exception {
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.instanceIdContainer);
- doReturn(Futures.immediateCheckedFuture(true))
- .when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
+ doReturn(immediateFalseFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ this.instanceIdContainer);
+ doReturn(immediateTrueFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ this.targetNodeForCreateAndDelete);
final PatchEntity entityCreate =
new PatchEntity("edit1", CREATE, this.instanceIdContainer, this.buildBaseContainerForTests);
@Test
public void deleteNonexistentDataTest() {
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
+ doReturn(immediateFalseFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ this.targetNodeForCreateAndDelete);
- final PatchEntity entityDelete =
- new PatchEntity("edit", DELETE, this.targetNodeForCreateAndDelete);
+ final PatchEntity entityDelete = new PatchEntity("edit", DELETE, this.targetNodeForCreateAndDelete);
final List<PatchEntity> entities = new ArrayList<>();
entities.add(entityDelete);
@Test
public void testPatchMergePutContainer() throws Exception {
- doReturn(Futures.immediateCheckedFuture(false)).doReturn(Futures.immediateCheckedFuture(true))
+ doReturn(immediateFalseFluentFuture()).doReturn(immediateTrueFluentFuture())
.when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
final PatchEntity entityMerge =
* 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.restconf.nb.rfc8040.rests.utils;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
-import com.google.common.util.concurrent.Futures;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-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.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
@Mock
private DOMTransactionChain transactionChain;
@Mock
- private DOMDataReadWriteTransaction readWrite;
+ private DOMDataTreeReadWriteTransaction readWrite;
@Mock
- private DOMDataReadOnlyTransaction read;
+ private DOMDataTreeReadTransaction read;
@Mock
- private DOMDataWriteTransaction write;
+ private DOMDataTreeWriteTransaction write;
@Mock
private UriInfo uriInfo;
@Mock
new InstanceIdentifierContext<>(this.iid2, null, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
+ this.iid2);
final YangInstanceIdentifier.NodeIdentifier identifier =
((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
final TransactionVarsWrapper wrapper =
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler);
final Response response =
data.getValue().iterator().next().getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
final TransactionVarsWrapper wrapper =
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler);
final Response response =
new InstanceIdentifierContext<>(this.iid2, null, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
+ this.iid2);
final YangInstanceIdentifier.NodeIdentifier identifier =
((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
- doReturn(Futures.immediateCheckedFuture(false))
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
- doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node,
- payload.getData());
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
+ doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
final DOMException domException = new DOMException((short) 414, "Post request failed");
- doReturn(Futures.immediateFailedCheckedFuture(domException)).when(this.readWrite).submit();
+ doReturn(immediateFailedFluentFuture(domException)).when(this.readWrite).commit();
final TransactionVarsWrapper wrapper =
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler);
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
}
-
}
* 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.restconf.nb.rfc8040.rests.utils;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
-import com.google.common.util.concurrent.Futures;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-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.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
@Mock
private DOMTransactionChain transactionChain;
@Mock
- private DOMDataReadWriteTransaction readWrite;
+ private DOMDataTreeReadWriteTransaction readWrite;
@Mock
- private DOMDataReadOnlyTransaction read;
+ private DOMDataTreeReadTransaction read;
@Mock
- private DOMDataWriteTransaction write;
+ private DOMDataTreeWriteTransaction write;
@Mock
private DOMDataBroker mockDataBroker;
doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(Boolean.FALSE))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
PutDataTransactionUtil.putData(payload, this.refSchemaCtx,
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null,
doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(Boolean.FALSE))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
PutDataTransactionUtil.putData(payload, this.refSchemaCtx,
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null,
doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(Boolean.FALSE))
+ doReturn(immediateFalseFluentFuture())
.when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
- doReturn(Futures.immediateCheckedFuture(null)).when(this.readWrite).submit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
PutDataTransactionUtil.putData(payload, this.refSchemaCtx,
new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null,
null);
verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData());
}
-
}
-
* 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.restconf.nb.rfc8040.rests.utils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.Futures;
import java.util.Collections;
+import java.util.Optional;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.UriInfo;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.WriterParameters;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
@Mock
private InstanceIdentifierContext<ContainerSchemaNode> context;
@Mock
- private DOMDataReadOnlyTransaction read;
+ private DOMDataTreeReadTransaction read;
@Mock
private SchemaContext schemaContext;
@Mock
@Test
public void readDataConfigTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data3))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path);
doReturn(DATA.path).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG;
@Test
public void readAllHavingOnlyConfigTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data3))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read)
+ doReturn(immediateFluentFuture(Optional.empty())).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path);
doReturn(DATA.path).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
@Test
public void readAllHavingOnlyNonConfigTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read)
+ doReturn(immediateFluentFuture(Optional.empty())).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
doReturn(DATA.path2).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
@Test
public void readDataNonConfigTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
doReturn(DATA.path2).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.NONCONFIG;
@Test
public void readContainerDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data3))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data4))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path);
doReturn(DATA.path).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
@Test
public void readContainerDataConfigNoValueOfContentTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data3))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.data4))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path);
doReturn(DATA.path).when(context).getInstanceIdentifier();
final NormalizedNode<?, ?> normalizedNode = ReadDataTransactionUtil.readData(
@Test
public void readListDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.listData))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.listData2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
doReturn(DATA.path3).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
@Test
public void readOrderedListDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.orderedMapNode1))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.orderedMapNode2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
doReturn(DATA.path3).when(context).getInstanceIdentifier();
@Test
public void readUnkeyedListDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.unkeyedListNode1))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.unkeyedListNode2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
doReturn(DATA.path3).when(context).getInstanceIdentifier();
@Test
public void readLeafListDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.leafSetNode1))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.leafSetNode2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
doReturn(DATA.leafSetNodePath).when(context).getInstanceIdentifier();
@Test
public void readOrderedLeafListDataAllTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.orderedLeafSetNode1))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
- doReturn(Futures.immediateCheckedFuture(Optional.of(DATA.orderedLeafSetNode2))).when(read)
+ doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
doReturn(DATA.leafSetNodePath).when(context).getInstanceIdentifier();
@Test
public void readDataWrongPathOrNoContentTest() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read)
+ doReturn(immediateFluentFuture(Optional.empty())).when(read)
.read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
doReturn(DATA.path2).when(context).getInstanceIdentifier();
final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG;
* 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.restconf.nb.rfc8040.rests.utils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.doReturn;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.Collection;
import java.util.Collections;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.handlers.RpcServiceHandler;
import org.opendaylight.yangtools.yang.common.RpcError;
@Test
public void invokeRpcTest() {
final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, Collections.emptyList());
- doReturn(Futures.immediateCheckedFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
+ doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, serviceHandler);
Assert.assertTrue(rpcResult.getErrors().isEmpty());
assertEquals(DATA.output, rpcResult.getResult());
public void invokeRpcErrorsAndCheckTestTest() {
final DOMRpcException exception = new DOMRpcImplementationNotAvailableException(
"No implementation of RPC " + DATA.errorRpc.toString() + " available.");
- doReturn(Futures.immediateFailedCheckedFuture(exception)).when(rpcService).invokeRpc(DATA.errorRpc, DATA.input);
+ doReturn(immediateFailedFluentFuture(exception)).when(rpcService).invokeRpc(DATA.errorRpc, DATA.input);
final DOMRpcResult rpcResult =
RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.errorRpc, serviceHandler);
assertNull(rpcResult.getResult());
@Test
public void invokeRpcViaMountPointTest() {
- doReturn(Optional.fromNullable(rpcService)).when(moutPoint).getService(DOMRpcService.class);
+ doReturn(Optional.ofNullable(rpcService)).when(moutPoint).getService(DOMRpcService.class);
final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, Collections.emptyList());
- doReturn(Futures.immediateCheckedFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
+ doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
final DOMRpcResult rpcResult =
RestconfInvokeOperationsUtil.invokeRpcViaMountPoint(moutPoint, DATA.input, DATA.rpc);
Assert.assertTrue(rpcResult.getErrors().isEmpty());
@Test(expected = RestconfDocumentedException.class)
public void invokeRpcMissingMountPointServiceTest() {
- doReturn(Optional.absent()).when(moutPoint).getService(DOMRpcService.class);
+ doReturn(Optional.empty()).when(moutPoint).getService(DOMRpcService.class);
final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, Collections.emptyList());
- doReturn(Futures.immediateCheckedFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
+ doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
final DOMRpcResult rpcResult =
RestconfInvokeOperationsUtil.invokeRpcViaMountPoint(moutPoint, DATA.input, DATA.rpc);
}
@Test
public void checkResponseTest() {
final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, Collections.emptyList());
- doReturn(Futures.immediateCheckedFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
+ doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, serviceHandler);
Assert.assertTrue(rpcResult.getErrors().isEmpty());
assertEquals(DATA.output, rpcResult.getResult());
assertNotNull(RestconfInvokeOperationsUtil.checkResponse(rpcResult));
}
-
}
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.restconf.nb.rfc8040.TestUtils;
* 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.restconf.nb.rfc8040.services.simple.impl;
import static org.junit.Assert.assertEquals;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.broker.impl.mount.DOMMountPointServiceImpl;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.schema.SchemaExportContext;
* 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.restconf.nb.rfc8040.streams.listeners;
import static java.time.Instant.EPOCH;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
NotificationOutputTypeGrouping.NotificationOutputType.JSON, true);
adapter.setCloseVars(transactionChainHandler, schemaContextHandler);
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
DOMDataTreeIdentifier root = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, PATCH_CONT_YIID);
changeService.registerDataTreeChangeListener(root, adapter);
InstanceIdentifier<MyList1> iid = InstanceIdentifier.create(PatchCont.class)
.child(MyList1.class, new MyList1Key("Althea"));
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_CREATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
builder = new MyList1Builder().withKey(new MyList1Key("Althea")).setMyLeaf12("Bertha");
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_UPDATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_LEAVES_DEL));
}
NotificationOutputTypeGrouping.NotificationOutputType.JSON, false);
adapter.setCloseVars(transactionChainHandler, schemaContextHandler);
- DOMDataTreeChangeService changeService = (DOMDataTreeChangeService)
- domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
+ .getInstance(DOMDataTreeChangeService.class);
DOMDataTreeIdentifier root = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, PATCH_CONT_YIID);
changeService.registerDataTreeChangeListener(root, adapter);
InstanceIdentifier<MyList1> iid = InstanceIdentifier.create(PatchCont.class)
.child(MyList1.class, new MyList1Key("Althea"));
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_CREATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
builder = new MyList1Builder().withKey(new MyList1Key("Althea")).setMyLeaf12("Bertha");
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iid, builder.build(), true);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_UPDATE));
writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- writeTransaction.submit();
+ writeTransaction.commit();
adapter.assertGot(getNotifJson(JSON_NOTIF_DEL));
}
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.restconf.nb.rfc8040.TestUtils;
import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.util.SingletonSet;
* 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.restconf.nb.rfc8040.utils.parser;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.Map.Entry;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.broker.impl.mount.DOMMountPointServiceImpl;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
@Test
public void toInstanceIdentifierTest() {
final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
- TEST_IDENT, this.schemaContext, Optional.absent());
+ TEST_IDENT, this.schemaContext, Optional.empty());
assertEquals("Returned not expected identifier",
TEST_IDENT_RESULT, context .getInstanceIdentifier().toString());
@Test
public void toInstanceIdentifierOtherModulesTest() {
final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
- TEST_IDENT_OTHERS, this.schemaContext, Optional.absent());
+ TEST_IDENT_OTHERS, this.schemaContext, Optional.empty());
assertEquals("Returned not expected identifier",
TEST_IDENT_OTHERS_RESULT, context.getInstanceIdentifier().toString());
@Test
public void toInstanceIdentifierNullIdentifierTest() {
final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
- null, this.schemaContext, Optional.absent());
+ null, this.schemaContext, Optional.empty());
assertEquals("Returned not expected identifier",
YangInstanceIdentifier.EMPTY, context.getInstanceIdentifier());
}
@Test
public void toInstanceIdentifierNullSchemaContextNegativeTest() {
this.thrown.expect(NullPointerException.class);
- ParserIdentifier.toInstanceIdentifier(TEST_IDENT, null, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(TEST_IDENT, null, Optional.empty());
}
/**
@Test
public void toInstanceIdentifierEmptyIdentifierTest() {
final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
- "", this.schemaContext, Optional.absent());
+ "", this.schemaContext, Optional.empty());
assertEquals("Returned not expected identifier",
YangInstanceIdentifier.EMPTY, context.getInstanceIdentifier());
}
@Test
public void toInstanceIdentifierInvalidIdentifierNegativeTest() {
this.thrown.expect(IllegalArgumentException.class);
- ParserIdentifier.toInstanceIdentifier(INVALID_TEST_IDENT, this.schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(INVALID_TEST_IDENT, this.schemaContext, Optional.empty());
}
/**
@Test
public void toInstanceIdentifierMissingMountPointServiceNegativeTest() {
try {
- ParserIdentifier.toInstanceIdentifier(RestconfConstants.MOUNT, this.schemaContext, Optional.absent());
+ ParserIdentifier.toInstanceIdentifier(RestconfConstants.MOUNT, this.schemaContext, Optional.empty());
fail("Test should fail due to absent mount point service");
} catch (final RestconfDocumentedException e) {
assertEquals("Not expected error type",
@Test
public void invokeRpcTest() {
final InstanceIdentifierContext<?> result = ParserIdentifier.toInstanceIdentifier(
- INVOKE_RPC, this.schemaContext, Optional.absent());
+ INVOKE_RPC, this.schemaContext, Optional.empty());
// RPC schema node
final QName rpcQName = result.getSchemaNode().getQName();
Code Review / netconf.git / commitdiff