import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
+import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfTransaction;
import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.PostPutQueryParameters.Insert;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
* @param payload data
*/
public static void validTopLevelNodeName(final YangInstanceIdentifier path, final NormalizedNodeContext payload) {
- final String payloadName = payload.getData().getNodeType().getLocalName();
+ final String payloadName = payload.getData().getIdentifier().getNodeType().getLocalName();
if (path.isEmpty()) {
- if (!payload.getData().getNodeType().equals(RestconfDataServiceConstant.NETCONF_BASE_QNAME)) {
+ if (!payload.getData().getIdentifier().getNodeType().equals(
+ RestconfDataServiceConstant.NETCONF_BASE_QNAME)) {
throw new RestconfDocumentedException("Instance identifier has to contain at least one path argument",
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE);
}
final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
final PathArgument lastPathArgument = iiWithData.getInstanceIdentifier().getLastPathArgument();
final SchemaNode schemaNode = iiWithData.getSchemaNode();
- final NormalizedNode<?, ?> data = payload.getData();
+ final NormalizedNode data = payload.getData();
if (schemaNode instanceof ListSchemaNode) {
final List<QName> keyDefinitions = ((ListSchemaNode) schemaNode).getKeyDefinition();
if (lastPathArgument instanceof NodeIdentifierWithPredicates && data instanceof MapEntryNode) {
final RestconfStrategy strategy, final Insert insert, final String point) {
final YangInstanceIdentifier path = payload.getInstanceIdentifierContext().getInstanceIdentifier();
- strategy.prepareReadWriteExecution();
final FluentFuture<Boolean> existsFuture = strategy.exists(LogicalDatastoreType.CONFIGURATION, path);
+ final FutureDataFactory<Boolean> existsResponse = new FutureDataFactory<>();
+ FutureCallbackTx.addCallback(existsFuture, PUT_TX_TYPE, existsResponse);
+
+ final ResponseFactory responseFactory =
+ new ResponseFactory(existsResponse.result ? Status.NO_CONTENT : Status.CREATED);
final FluentFuture<? extends CommitInfo> submitData = submitData(path, schemaContext, strategy,
- payload.getData(), insert, point);
- final ResponseFactory response = new ResponseFactory();
+ payload.getData(), insert, point);
//This method will close transactionChain if any
- FutureCallbackTx.addCallback(submitData, PUT_TX_TYPE, response, strategy.getTransactionChain());
-
- final FutureDataFactory<Boolean> isExists = new FutureDataFactory<>();
- FutureCallbackTx.addCallback(existsFuture, PUT_TX_TYPE, isExists);
- return response.status(isExists.result ? Status.NO_CONTENT : Status.CREATED).build();
+ FutureCallbackTx.addCallback(submitData, PUT_TX_TYPE, responseFactory, strategy, path);
+ return responseFactory.build();
}
/**
private static FluentFuture<? extends CommitInfo> submitData(final YangInstanceIdentifier path,
final EffectiveModelContext schemaContext,
final RestconfStrategy strategy,
- final NormalizedNode<?, ?> data,
+ final NormalizedNode data,
final Insert insert, final String point) {
+ final RestconfTransaction transaction = strategy.prepareWriteExecution();
if (insert == null) {
- return makePut(path, schemaContext, strategy, data);
+ return makePut(path, schemaContext, transaction, data);
}
checkListAndOrderedType(schemaContext, path);
- final NormalizedNode<?, ?> readData;
+ final NormalizedNode readData;
switch (insert) {
case FIRST:
readData = readList(strategy, path.getParent());
- if (readData == null || ((NormalizedNodeContainer<?, ?, ?>) readData).getValue().isEmpty()) {
- return makePut(path, schemaContext, strategy, data);
+ if (readData == null || ((NormalizedNodeContainer<?>) readData).isEmpty()) {
+ return makePut(path, schemaContext, transaction, data);
}
- strategy.remove(LogicalDatastoreType.CONFIGURATION, path.getParent());
- strategy.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
- strategy.replace(LogicalDatastoreType.CONFIGURATION, path.getParent(), readData, schemaContext);
- return strategy.commit();
+ transaction.remove(LogicalDatastoreType.CONFIGURATION, path.getParent());
+ transaction.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
+ transaction.replace(LogicalDatastoreType.CONFIGURATION, path.getParent(), readData, schemaContext);
+ return transaction.commit();
case LAST:
- return makePut(path, schemaContext, strategy, data);
+ return makePut(path, schemaContext, transaction, data);
case BEFORE:
readData = readList(strategy, path.getParent());
- if (readData == null || ((NormalizedNodeContainer<?, ?, ?>) readData).getValue().isEmpty()) {
- return makePut(path, schemaContext, strategy, data);
+ if (readData == null || ((NormalizedNodeContainer<?>) readData).isEmpty()) {
+ return makePut(path, schemaContext, transaction, data);
}
- insertWithPointPut(strategy, path, data, schemaContext, point,
- (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) readData, true);
- return strategy.commit();
+ insertWithPointPut(transaction, path, data, schemaContext, point, (NormalizedNodeContainer<?>) readData,
+ true);
+ return transaction.commit();
case AFTER:
readData = readList(strategy, path.getParent());
- if (readData == null || ((NormalizedNodeContainer<?, ?, ?>) readData).getValue().isEmpty()) {
- return makePut(path, schemaContext, strategy, data);
+ if (readData == null || ((NormalizedNodeContainer<?>) readData).isEmpty()) {
+ return makePut(path, schemaContext, transaction, data);
}
- insertWithPointPut(strategy, path, data, schemaContext, point,
- (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) readData, false);
- return strategy.commit();
+ insertWithPointPut(transaction, path, data, schemaContext, point, (NormalizedNodeContainer<?>) readData,
+ false);
+ return transaction.commit();
default:
throw new RestconfDocumentedException(
"Used bad value of insert parameter. Possible values are first, last, before or after, "
// FIXME: this method is only called from a context where we are modifying data. This should be part of strategy,
// requiring an already-open transaction. It also must return a future, so it can be properly composed.
- static NormalizedNode<?, ?> readList(final RestconfStrategy strategy, final YangInstanceIdentifier path) {
- return ReadDataTransactionUtil.readDataViaTransaction(strategy, LogicalDatastoreType.CONFIGURATION,
- path,false);
+ static NormalizedNode readList(final RestconfStrategy strategy, final YangInstanceIdentifier path) {
+ return ReadDataTransactionUtil.readDataViaTransaction(strategy, LogicalDatastoreType.CONFIGURATION, path,
+ false);
}
- private static void insertWithPointPut(final RestconfStrategy strategy,
+ private static void insertWithPointPut(final RestconfTransaction transaction,
final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data,
+ final NormalizedNode data,
final EffectiveModelContext schemaContext, final String point,
- final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> readList,
- final boolean before) {
- strategy.remove(LogicalDatastoreType.CONFIGURATION, path.getParent());
+ final NormalizedNodeContainer<?> readList, final boolean before) {
+ transaction.remove(LogicalDatastoreType.CONFIGURATION, path.getParent());
final InstanceIdentifierContext<?> instanceIdentifier =
ParserIdentifier.toInstanceIdentifier(point, schemaContext, Optional.empty());
int lastItemPosition = 0;
- for (final NormalizedNode<?, ?> nodeChild : readList.getValue()) {
+ for (final NormalizedNode nodeChild : readList.body()) {
if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
break;
}
lastItemPosition++;
}
int lastInsertedPosition = 0;
- final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path.getParent());
- strategy.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create(emptySubtree.getIdentifier()),
+ final NormalizedNode emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path.getParent());
+ transaction.merge(LogicalDatastoreType.CONFIGURATION,
+ YangInstanceIdentifier.create(emptySubtree.getIdentifier()),
emptySubtree);
- for (final NormalizedNode<?, ?> nodeChild : readList.getValue()) {
+ for (final NormalizedNode nodeChild : readList.body()) {
if (lastInsertedPosition == lastItemPosition) {
- strategy.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
+ transaction.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
}
final YangInstanceIdentifier childPath = path.getParent().node(nodeChild.getIdentifier());
- strategy.replace(LogicalDatastoreType.CONFIGURATION, childPath, nodeChild, schemaContext);
+ transaction.replace(LogicalDatastoreType.CONFIGURATION, childPath, nodeChild, schemaContext);
lastInsertedPosition++;
}
}
private static FluentFuture<? extends CommitInfo> makePut(final YangInstanceIdentifier path,
final SchemaContext schemaContext,
- final RestconfStrategy strategy,
- final NormalizedNode<?, ?> data) {
- strategy.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
- return strategy.commit();
+ final RestconfTransaction transaction,
+ final NormalizedNode data) {
+ transaction.replace(LogicalDatastoreType.CONFIGURATION, path, data, schemaContext);
+ return transaction.commit();
}
public static DataSchemaNode checkListAndOrderedType(final EffectiveModelContext ctx,
Code Review / netconf.git / blobdiff