*/
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.HashMap;
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.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.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
-import org.opendaylight.restconf.common.validation.RestconfValidationUtils;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
-import org.opendaylight.restconf.nb.rfc8040.references.SchemaContextRef;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
if (schemaNode instanceof ListSchemaNode) {
final List<QName> keyDefinitions = ((ListSchemaNode) schemaNode).getKeyDefinition();
if (lastPathArgument instanceof NodeIdentifierWithPredicates && data instanceof MapEntryNode) {
- final Map<QName, Object> uriKeyValues = ((NodeIdentifierWithPredicates) lastPathArgument)
- .getKeyValues();
+ final Map<QName, Object> uriKeyValues = ((NodeIdentifierWithPredicates) lastPathArgument).asMap();
isEqualUriAndPayloadKeyValues(uriKeyValues, (MapEntryNode) data, keyDefinitions);
}
}
private static void isEqualUriAndPayloadKeyValues(final Map<QName, Object> uriKeyValues, final MapEntryNode payload,
final List<QName> keyDefinitions) {
- final Map<QName, Object> mutableCopyUriKeyValues = Maps.newHashMap(uriKeyValues);
+ final Map<QName, Object> mutableCopyUriKeyValues = new HashMap<>(uriKeyValues);
for (final QName keyDefinition : keyDefinitions) {
- final Object uriKeyValue = mutableCopyUriKeyValues.remove(keyDefinition);
- RestconfValidationUtils.checkDocumentedError(uriKeyValue != null, ErrorType.PROTOCOL, ErrorTag.DATA_MISSING,
- "Missing key " + keyDefinition + " in URI.");
+ final Object uriKeyValue = RestconfDocumentedException.throwIfNull(
+ mutableCopyUriKeyValues.remove(keyDefinition), ErrorType.PROTOCOL, ErrorTag.DATA_MISSING,
+ "Missing key %s in URI.", keyDefinition);
- final Object dataKeyValue = payload.getIdentifier().getKeyValues().get(keyDefinition);
+ final Object dataKeyValue = payload.getIdentifier().getValue(keyDefinition);
if (!uriKeyValue.equals(dataKeyValue)) {
final String errMsg = "The value '" + uriKeyValue + "' for key '" + keyDefinition.getLocalName()
}
/**
- * Check mount point and prepare variables for put data to DS.
+ * Check mount point and prepare variables for put data to DS. Close {@link DOMTransactionChain} inside of object
+ * {@link TransactionVarsWrapper} provided as a parameter.
*
* @param payload
* data to put
- * @param schemaCtxRef
- * reference to {@link SchemaContext}
+ * @param schemaContext
+ * reference to {@link EffectiveModelContext}
* @param transactionNode
* wrapper of variables for transaction
* @param point
* query parameter
* @param insert
* query parameter
- * @return {@link CheckedFuture}
+ * @return {@link Response}
*/
- public static Response putData(final NormalizedNodeContext payload, final SchemaContextRef schemaCtxRef,
+ public static Response putData(final NormalizedNodeContext payload, final EffectiveModelContext schemaContext,
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);
+ //This method will close transactionChain
+ FutureCallbackTx.addCallback(submitData, RestconfDataServiceConstant.PutData.PUT_TX_TYPE, responseFactory,
+ transactionNode.getTransactionChain());
return responseFactory.build();
}
* query parameter
* @param insert
* query parameter
- * @return {@link CheckedFuture}
+ * @return {@link FluentFuture}
*/
- private static CheckedFuture<Void, TransactionCommitFailedException> submitData(final YangInstanceIdentifier path,
- final SchemaContext schemaContext, final TransactionChainHandler transactionChainHandler,
- final DOMDataReadWriteTransaction readWriteTransaction,
+ private static FluentFuture<? extends CommitInfo> submitData(final YangInstanceIdentifier path,
+ final EffectiveModelContext schemaContext, final TransactionChainHandler transactionChainHandler,
+ 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, RestconfError.ErrorType.PROTOCOL, ErrorTag.BAD_ATTRIBUTE);
}
}
- public static NormalizedNode<?, ?> readList(final YangInstanceIdentifier path, final SchemaContext schemaContext,
- final TransactionChainHandler transactionChainHandler, final DataSchemaNode schemaNode) {
+ public static NormalizedNode<?, ?> readList(final YangInstanceIdentifier path,
+ final EffectiveModelContext schemaContext, final TransactionChainHandler transactionChainHandler,
+ final DataSchemaNode schemaNode) {
final InstanceIdentifierContext<?> iid = new InstanceIdentifierContext<SchemaNode>(
path.getParent(), schemaNode, null, schemaContext);
final TransactionVarsWrapper transactionNode = new TransactionVarsWrapper(iid, null, transactionChainHandler);
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 NormalizedNode<?, ?> data, final EffectiveModelContext 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 NormalizedNode<?, ?> data, final EffectiveModelContext 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);
TransactionUtil.ensureParentsByMerge(path, schemaContext, writeTx);
- for (final MapEntryNode child : ((MapNode) payload).getValue()) {
+ for (final MapEntryNode child : payload.getValue()) {
final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
writeTx.put(datastore, childPath, child);
}
}
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) {
if (dataSchemaNode instanceof ListSchemaNode) {
if (!((ListSchemaNode) dataSchemaNode).isUserOrdered()) {
- throw new RestconfDocumentedException("Insert parameter can be used only with ordered-by user list.");
+ throw new RestconfDocumentedException("Insert parameter can be used only with ordered-by user list.",
+ RestconfError.ErrorType.PROTOCOL, ErrorTag.BAD_ELEMENT);
}
return dataSchemaNode;
}
if (dataSchemaNode instanceof LeafListSchemaNode) {
if (!((LeafListSchemaNode) dataSchemaNode).isUserOrdered()) {
throw new RestconfDocumentedException(
- "Insert parameter can be used only with ordered-by user leaf-list.");
+ "Insert parameter can be used only with ordered-by user leaf-list.",
+ RestconfError.ErrorType.PROTOCOL, ErrorTag.BAD_ELEMENT);
}
return dataSchemaNode;
}
- throw new RestconfDocumentedException("Insert parameter can be used only with list or leaf-list");
+ throw new RestconfDocumentedException("Insert parameter can be used only with list or leaf-list",
+ RestconfError.ErrorType.PROTOCOL, ErrorTag.BAD_ELEMENT);
}
}
Code Review / netconf.git / blobdiff