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 com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.opendaylight.netconf.sal.streams.listeners.ListenerAdapter;
import org.opendaylight.netconf.sal.streams.listeners.NotificationListenerAdapter;
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;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
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.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.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
}
private void checkPreconditions() {
- if ((this.context == null) || (this.domDataBroker == null)) {
+ if (this.context == null || this.domDataBroker == null) {
throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
}
}
- // READ configuration
+ /**
+ * Read config data by path
+ *
+ * @param path
+ * - path of data
+ * @return read date
+ */
public NormalizedNode<?, ?> readConfigurationData(final YangInstanceIdentifier path) {
+ return readConfigurationData(path, null);
+ }
+
+ /**
+ * Read config data by path
+ *
+ * @param path
+ * - path of data
+ * @param withDefa
+ * - value of with-defaults parameter
+ * @return read date
+ */
+ public NormalizedNode<?, ?> readConfigurationData(final YangInstanceIdentifier path, final String withDefa) {
checkPreconditions();
- return readDataViaTransaction(this.domDataBroker.newReadOnlyTransaction(), CONFIGURATION, path);
+ return readDataViaTransaction(this.domDataBroker.newReadOnlyTransaction(), CONFIGURATION, path, withDefa);
}
- public NormalizedNode<?, ?> readConfigurationData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
+ /**
+ * Read config data from mount point by path.
+ *
+ * @param mountPoint
+ * - mount point for reading data
+ * @param path
+ * - path of data
+ * @return read data
+ */
+ public NormalizedNode<?, ?> readConfigurationData(final DOMMountPoint mountPoint,
+ final YangInstanceIdentifier path) {
+ return readConfigurationData(mountPoint, path, null);
+ }
+
+ /**
+ * Read config data from mount point by path.
+ *
+ * @param mountPoint
+ * - mount point for reading data
+ * @param path
+ * - path of data
+ * @param withDefa
+ * - value of with-defaults parameter
+ * @return read data
+ */
+ public NormalizedNode<?, ?> readConfigurationData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path,
+ final String withDefa) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
- return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), CONFIGURATION, path);
+ return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), CONFIGURATION, path,
+ withDefa);
}
final String errMsg = "DOM data broker service isn't available for mount point " + path;
LOG.warn(errMsg);
throw new RestconfDocumentedException(errMsg);
}
- // READ operational
+ /**
+ * Read operational data by path.
+ *
+ * @param path
+ * - path of data
+ * @return read data
+ */
public NormalizedNode<?, ?> readOperationalData(final YangInstanceIdentifier path) {
checkPreconditions();
return readDataViaTransaction(this.domDataBroker.newReadOnlyTransaction(), OPERATIONAL, path);
}
+ /**
+ * Read operational data from mount point by path.
+ *
+ * @param mountPoint
+ * - mount point for reading data
+ * @param path
+ * - path of data
+ * @return read data
+ */
public NormalizedNode<?, ?> readOperationalData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
- LOG.trace("Read {} via Restconf: {}", datastore.name(), path);
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = transaction.read(datastore, path);
- final ReadDataResult<NormalizedNode<?, ?>> readData = new ReadDataResult<>();
- final CountDownLatch responseWaiter = new CountDownLatch(1);
+ return readDataViaTransaction(transaction, datastore, path, null);
+ }
- Futures.addCallback(listenableFuture, new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
+ private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final String withDefa) {
+ LOG.trace("Read {} via Restconf: {}", datastore.name(), path);
- @Override
- public void onSuccess(final Optional<NormalizedNode<?, ?>> result) {
- handlingCallback(null, datastore, path, result, readData);
- responseWaiter.countDown();
+ try {
+ final Optional<NormalizedNode<?, ?>> optional = transaction.read(datastore, path).checkedGet();
+ return !optional.isPresent() ? null : withDefa == null ? optional.get() :
+ prepareDataByParamWithDef(optional.get(), path, withDefa);
+ } catch (ReadFailedException 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);
+ }
}
+ throw new RestconfDocumentedException("Error reading data.", e, e.getErrorList());
+ }
+ }
- @Override
- public void onFailure(final Throwable t) {
- responseWaiter.countDown();
- handlingCallback(t, datastore, path, null, null);
+ private NormalizedNode<?, ?> prepareDataByParamWithDef(final NormalizedNode<?, ?> result,
+ final YangInstanceIdentifier path, final String withDefa) {
+ boolean trim;
+ switch (withDefa) {
+ case "trim":
+ trim = true;
+ break;
+ case "explicit":
+ trim = false;
+ break;
+ default:
+ throw new RestconfDocumentedException("Bad value used with with-defaults parameter : " + withDefa);
+ }
+
+ final SchemaContext ctx = ControllerContext.getInstance().getGlobalSchema();
+ final DataSchemaContextTree baseSchemaCtxTree = DataSchemaContextTree.from(ctx);
+ final DataSchemaNode baseSchemaNode = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
+ if (result instanceof ContainerNode) {
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder =
+ Builders.containerBuilder((ContainerSchemaNode) baseSchemaNode);
+ buildCont(builder, (ContainerNode) result, baseSchemaCtxTree, path, trim);
+ return builder.build();
+ }
+
+ final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
+ Builders.mapEntryBuilder((ListSchemaNode) baseSchemaNode);
+ buildMapEntryBuilder(builder, (MapEntryNode) result, baseSchemaCtxTree, path, trim,
+ ((ListSchemaNode) baseSchemaNode).getKeyDefinition());
+ return builder.build();
+ }
+
+ private void buildMapEntryBuilder(final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
+ final MapEntryNode result, final DataSchemaContextTree baseSchemaCtxTree,
+ final YangInstanceIdentifier actualPath, final boolean trim, final List<QName> keys) {
+ for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
+ final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
+ final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
+ if (child instanceof ContainerNode) {
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> childBuilder =
+ Builders.containerBuilder((ContainerSchemaNode) childSchema);
+ buildCont(childBuilder, (ContainerNode) child, baseSchemaCtxTree, path, trim);
+ builder.withChild(childBuilder.build());
+ } else if (child instanceof MapNode) {
+ final CollectionNodeBuilder<MapEntryNode, MapNode> childBuilder =
+ Builders.mapBuilder((ListSchemaNode) childSchema);
+ buildList(childBuilder, (MapNode) child, baseSchemaCtxTree, path, trim,
+ ((ListSchemaNode) childSchema).getKeyDefinition());
+ builder.withChild(childBuilder.build());
+ } else if (child instanceof LeafNode) {
+ final String defaultVal = ((LeafSchemaNode) childSchema).getDefault();
+ final String nodeVal = ((LeafNode<String>) child).getValue();
+ final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ Builders.leafBuilder((LeafSchemaNode) childSchema);
+ if (keys.contains(child.getNodeType())) {
+ leafBuilder.withValue(((LeafNode) child).getValue());
+ builder.withChild(leafBuilder.build());
+ } else {
+ if (trim) {
+ if (defaultVal == null || !defaultVal.equals(nodeVal)) {
+ leafBuilder.withValue(((LeafNode) child).getValue());
+ builder.withChild(leafBuilder.build());
+ }
+ } else {
+ if (defaultVal != null && defaultVal.equals(nodeVal)) {
+ leafBuilder.withValue(((LeafNode) child).getValue());
+ builder.withChild(leafBuilder.build());
+ }
+ }
+ }
}
- });
+ }
+ }
- try {
- responseWaiter.await();
- } catch (final Exception e) {
- final String msg = "Problem while waiting for response";
- LOG.warn(msg);
- throw new RestconfDocumentedException(msg, e);
+ private void buildList(final CollectionNodeBuilder<MapEntryNode, MapNode> builder, final MapNode result,
+ final DataSchemaContextTree baseSchemaCtxTree, final YangInstanceIdentifier path, final boolean trim,
+ final List<QName> keys) {
+ for (final MapEntryNode mapEntryNode : result.getValue()) {
+ final YangInstanceIdentifier actualNode = path.node(mapEntryNode.getIdentifier());
+ final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(actualNode).getDataSchemaNode();
+ final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
+ Builders.mapEntryBuilder((ListSchemaNode) childSchema);
+ buildMapEntryBuilder(mapEntryBuilder, mapEntryNode, baseSchemaCtxTree, actualNode, trim, keys);
+ builder.withChild(mapEntryBuilder.build());
+ }
+ }
+
+ private void buildCont(final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder,
+ final ContainerNode result, final DataSchemaContextTree baseSchemaCtxTree,
+ final YangInstanceIdentifier actualPath, final boolean trim) {
+ for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
+ final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
+ final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
+ if(child instanceof ContainerNode){
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builderChild =
+ Builders.containerBuilder((ContainerSchemaNode) childSchema);
+ buildCont(builderChild, result, baseSchemaCtxTree, actualPath, trim);
+ builder.withChild(builderChild.build());
+ } else if (child instanceof MapNode) {
+ final CollectionNodeBuilder<MapEntryNode, MapNode> childBuilder =
+ Builders.mapBuilder((ListSchemaNode) childSchema);
+ buildList(childBuilder, (MapNode) child, baseSchemaCtxTree, path, trim,
+ ((ListSchemaNode) childSchema).getKeyDefinition());
+ builder.withChild(childBuilder.build());
+ } else if (child instanceof LeafNode) {
+ final String defaultVal = ((LeafSchemaNode) childSchema).getDefault();
+ final String nodeVal = ((LeafNode<String>) child).getValue();
+ final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ Builders.leafBuilder((LeafSchemaNode) childSchema);
+ if (trim) {
+ if (defaultVal == null || !defaultVal.equals(nodeVal)) {
+ leafBuilder.withValue(((LeafNode) child).getValue());
+ builder.withChild(leafBuilder.build());
+ }
+ } else {
+ if (defaultVal != null && defaultVal.equals(nodeVal)) {
+ leafBuilder.withValue(((LeafNode) child).getValue());
+ builder.withChild(leafBuilder.build());
+ }
+ }
+ }
}
- return readData.getResult();
}
/**
final SchemaContext schemaContext, final String insert, final String point) {
if (insert == null) {
makeNormalPost(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- final DataSchemaNode schemaNode = checkListAndOrderedType(schemaContext, path);
- checkItemDoesNotExists(rWTransaction, datastore, path);
- switch (insert) {
- case "first":
- if(schemaNode instanceof ListSchemaNode){
- final OrderedMapNode readList =
- (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- rWTransaction.delete(datastore, path.getParent().getParent());
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- makeNormalPost(rWTransaction, datastore, path.getParent().getParent(), readList,
- schemaContext);
- }
+ return;
+ }
+
+ final DataSchemaNode schemaNode = checkListAndOrderedType(schemaContext, path);
+ checkItemDoesNotExists(rWTransaction, datastore, path);
+ switch (insert) {
+ case "first":
+ if(schemaNode instanceof ListSchemaNode){
+ final OrderedMapNode readList =
+ (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
+ if (readList == null || readList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
} else {
- final OrderedLeafSetNode readLeafList =
- (OrderedLeafSetNode) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- rWTransaction.delete(datastore, path.getParent());
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- makeNormalPost(rWTransaction, datastore, path.getParent().getParent(), readLeafList,
- schemaContext);
- }
+ rWTransaction.delete(datastore, path.getParent().getParent());
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ makeNormalPost(rWTransaction, datastore, path.getParent().getParent(), readList,
+ schemaContext);
}
- break;
- case "last":
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- break;
- case "before":
- if(schemaNode instanceof ListSchemaNode){
- final OrderedMapNode readList =
- (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- insertWithPointListPost(rWTransaction, datastore, path, payload, schemaContext, point,
- readList,
- true);
- }
+ } else {
+ final OrderedLeafSetNode<?> readLeafList =
+ (OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
} else {
- final OrderedLeafSetNode<?> readLeafList =
- (OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- insertWithPointLeafListPost(rWTransaction, datastore, path, payload, schemaContext, point,
- readLeafList, true);
- }
+ rWTransaction.delete(datastore, path.getParent());
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ makeNormalPost(rWTransaction, datastore, path.getParent().getParent(), readLeafList,
+ schemaContext);
}
- break;
- case "after":
- if (schemaNode instanceof ListSchemaNode) {
- final OrderedMapNode readList =
- (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- insertWithPointListPost(rWTransaction, datastore, path, payload, schemaContext, point,
- readList,
- false);
- }
+ }
+ break;
+ case "last":
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ break;
+ case "before":
+ if(schemaNode instanceof ListSchemaNode){
+ final OrderedMapNode readList =
+ (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
+ if (readList == null || readList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
} else {
- final OrderedLeafSetNode<?> readLeafList =
- (OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
- simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
- } else {
- insertWithPointLeafListPost(rWTransaction, datastore, path, payload, schemaContext, point,
- readLeafList, false);
- }
+ insertWithPointListPost(rWTransaction, datastore, path, payload, schemaContext, point,
+ readList,
+ true);
}
- break;
- default:
- throw new RestconfDocumentedException(
- "Used bad value of insert parameter. Possible values are first, last, before or after, "
- + "but was: " + insert);
- }
+ } else {
+ final OrderedLeafSetNode<?> readLeafList =
+ (OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ } else {
+ insertWithPointLeafListPost(rWTransaction, datastore, path, payload, schemaContext, point,
+ readLeafList, true);
+ }
+ }
+ break;
+ case "after":
+ if (schemaNode instanceof ListSchemaNode) {
+ final OrderedMapNode readList =
+ (OrderedMapNode) this.readConfigurationData(path.getParent().getParent());
+ if (readList == null || readList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ } else {
+ insertWithPointListPost(rWTransaction, datastore, path, payload, schemaContext, point,
+ readList,
+ false);
+ }
+ } else {
+ final OrderedLeafSetNode<?> readLeafList =
+ (OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
+ simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ } else {
+ insertWithPointLeafListPost(rWTransaction, datastore, path, payload, schemaContext, point,
+ readLeafList, false);
+ }
+ }
+ break;
+ default:
+ throw new RestconfDocumentedException(
+ "Used bad value of insert parameter. Possible values are first, last, before or after, "
+ + "but was: " + insert);
}
}
- private void insertWithPointLeafListPost(final DOMDataReadWriteTransaction rWTransaction,
+ private static void insertWithPointLeafListPost(final DOMDataReadWriteTransaction 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 static void insertWithPointListPost(final DOMDataReadWriteTransaction rWTransaction,
final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext,
final String point, final MapNode readList, final boolean before) {
}
}
- private DataSchemaNode checkListAndOrderedType(final SchemaContext ctx,
- final YangInstanceIdentifier path) {
+ private static DataSchemaNode checkListAndOrderedType(final SchemaContext ctx, final YangInstanceIdentifier path) {
final YangInstanceIdentifier parent = path.getParent();
final DataSchemaContextNode<?> node = DataSchemaContextTree.from(ctx).getChild(parent);
final DataSchemaNode dataSchemaNode = node.getDataSchemaNode();
throw new RestconfDocumentedException("Insert parameter can be used only with list or leaf-list");
}
- private void makeNormalPost(final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
+ private static void makeNormalPost(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
+ final SchemaContext schemaContext) {
+ final Collection<? extends NormalizedNode<?, ?>> children;
if (payload instanceof MapNode) {
- final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
- rWTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
- ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
- for (final MapEntryNode child : ((MapNode) payload).getValue()) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
- checkItemDoesNotExists(rWTransaction, datastore, childPath);
- rWTransaction.put(datastore, childPath, child);
- }
+ children = ((MapNode) payload).getValue();
} else if (payload instanceof LeafSetNode) {
- final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
- rWTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
- ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
- for (final LeafSetEntryNode<?> child : ((LeafSetNode<?>) payload).getValue()) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
- checkItemDoesNotExists(rWTransaction, datastore, childPath);
- rWTransaction.put(datastore, childPath, child);
- }
+ children = ((LeafSetNode<?>) payload).getValue();
} else {
simplePostPut(rWTransaction, datastore, path, payload, schemaContext);
+ return;
+ }
+
+ // We are putting multiple children, we really need a create() operation, but until we have that we make do
+ // with a two-step process of verifying if the children exist and then putting them in.
+ for (final NormalizedNode<?, ?> child : children) {
+ checkItemDoesNotExists(rWTransaction, datastore, path.node(child.getIdentifier()));
+ }
+
+ final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
+ rWTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
+ ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
+ for (final NormalizedNode<?, ?> child : children) {
+ rWTransaction.put(datastore, path.node(child.getIdentifier()), child);
}
}
- private void simplePostPut(final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
+ private static void simplePostPut(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
+ final SchemaContext schemaContext) {
checkItemDoesNotExists(rWTransaction, datastore, path);
ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
rWTransaction.put(datastore, path, payload);
}
+ private static boolean doesItemExist(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ try {
+ return rWTransaction.exists(store, path).checkedGet();
+ } catch (ReadFailedException e) {
+ rWTransaction.cancel();
+ throw new RestconfDocumentedException("Could not determine the existence of path " + path,
+ e, e.getErrorList());
+ }
+ }
+
/**
* Check if item already exists. Throws error if it does NOT already exist.
* @param rWTransaction Current transaction
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private void checkItemExists(final DOMDataReadWriteTransaction rWTransaction,
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
- final CountDownLatch responseWaiter = new CountDownLatch(1);
- final ReadDataResult<Boolean> readData = new ReadDataResult<>();
- final CheckedFuture<Boolean, ReadFailedException> future = rWTransaction.exists(store, path);
-
- Futures.addCallback(future, new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(@Nullable final Boolean result) {
- handlingCallback(null, store, path, Optional.of(result), readData);
- responseWaiter.countDown();
- }
-
- @Override
- public void onFailure(final Throwable t) {
- responseWaiter.countDown();
- handlingCallback(t, store, path, null, null);
- }
- });
-
- try {
- responseWaiter.await();
- } catch (final Exception e) {
- final String msg = "Problem while waiting for response";
- LOG.warn(msg);
- throw new RestconfDocumentedException(msg, e);
- }
-
- if ((readData.getResult() == null) || !readData.getResult()) {
+ private static void checkItemExists(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ if (!doesItemExist(rWTransaction, store, path)) {
final String errMsg = "Operation via Restconf was not executed because data does not exist";
LOG.trace("{}:{}", errMsg, path);
rWTransaction.cancel();
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
- final CountDownLatch responseWaiter = new CountDownLatch(1);
- final ReadDataResult<Boolean> readData = new ReadDataResult<>();
- final CheckedFuture<Boolean, ReadFailedException> future = rWTransaction.exists(store, path);
-
- Futures.addCallback(future, new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(@Nullable final Boolean result) {
- handlingCallback(null, store, path, Optional.of(result), readData);
- responseWaiter.countDown();
- }
-
- @Override
- public void onFailure(final Throwable t) {
- responseWaiter.countDown();
- handlingCallback(t, store, path, null, null);
- }
- });
-
- try {
- responseWaiter.await();
- } catch (final Exception e) {
- final String msg = "Problem while waiting for response";
- LOG.warn(msg);
- throw new RestconfDocumentedException(msg, e);
- }
-
- if (readData.getResult()) {
+ private static void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ if (doesItemExist(rWTransaction, store, path)) {
final String errMsg = "Operation via Restconf was not executed because data already exists";
LOG.trace("{}:{}", errMsg, path);
rWTransaction.cancel();
if (schemaNode instanceof ListSchemaNode) {
final OrderedMapNode readList =
(OrderedMapNode) this.readConfigurationData(path.getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
+ if (readList == null || readList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
rWTransaction.delete(datastore, path.getParent());
} else {
final OrderedLeafSetNode<?> readLeafList =
(OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
rWTransaction.delete(datastore, path.getParent());
if (schemaNode instanceof ListSchemaNode) {
final OrderedMapNode readList =
(OrderedMapNode) this.readConfigurationData(path.getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
+ if (readList == null || readList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
insertWithPointListPut(rWTransaction, datastore, path, payload, schemaContext, point,
} else {
final OrderedLeafSetNode<?> readLeafList =
(OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
insertWithPointLeafListPut(rWTransaction, datastore, path, payload, schemaContext, point,
if (schemaNode instanceof ListSchemaNode) {
final OrderedMapNode readList =
(OrderedMapNode) this.readConfigurationData(path.getParent());
- if ((readList == null) || readList.getValue().isEmpty()) {
+ if (readList == null || readList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
insertWithPointListPut(rWTransaction, datastore, path, payload, schemaContext, point,
} else {
final OrderedLeafSetNode<?> readLeafList =
(OrderedLeafSetNode<?>) readConfigurationData(path.getParent());
- if ((readLeafList == null) || readLeafList.getValue().isEmpty()) {
+ if (readLeafList == null || readLeafList.getValue().isEmpty()) {
simplePut(datastore, path, rWTransaction, schemaContext, payload);
} else {
insertWithPointLeafListPut(rWTransaction, datastore, path, payload, schemaContext, point,
}
}
- private void insertWithPointLeafListPut(final DOMDataReadWriteTransaction rWTransaction,
+ private static void insertWithPointLeafListPut(final DOMDataReadWriteTransaction rWTransaction,
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 DOMDataReadWriteTransaction rWTransaction,
+ private static void insertWithPointListPut(final DOMDataReadWriteTransaction rWTransaction,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
final SchemaContext schemaContext, final String point, final OrderedMapNode readList,
final boolean before) {
}
}
- private void makePut(final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
+ private static void makePut(final DOMDataReadWriteTransaction writeTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
+ final SchemaContext schemaContext) {
if (payload instanceof MapNode) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
writeTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
}
}
- private void simplePut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
+ private static void simplePut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
final DOMDataReadWriteTransaction writeTransaction, final SchemaContext schemaContext,
final NormalizedNode<?, ?> payload) {
ensureParentsByMerge(datastore, path, writeTransaction, schemaContext);
writeTransaction.put(datastore, path, payload);
}
- private CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
+ private static CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
final DOMDataReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path) {
LOG.trace("Delete {} via Restconf: {}", datastore.name(), path);
return readWriteTransaction.submit();
}
- private void deleteDataWithinTransaction(
- final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path) {
+ private static void deleteDataWithinTransaction(final DOMDataWriteTransaction writeTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
LOG.trace("Delete {} within Restconf PATCH: {}", datastore.name(), path);
writeTransaction.delete(datastore, path);
}
- private void mergeDataWithinTransaction(
+ private static void mergeDataWithinTransaction(
final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
LOG.trace("Merge {} within Restconf PATCH: {} with payload {}", datastore.name(), path, payload);
ensureParentsByMerge(datastore, path, writeTransaction, schemaContext);
- // merging is necessary only for lists otherwise we can call put method
- if (payload instanceof MapNode) {
- writeTransaction.merge(datastore, path, payload);
- } else {
- writeTransaction.put(datastore, path, payload);
- }
+ // Since YANG Patch provides the option to specify what kind of operation for each edit,
+ // OpenDaylight should not change it.
+ writeTransaction.merge(datastore, path, payload);
}
public void setDomDataBroker(final DOMDataBroker domDataBroker) {
this.domDataBroker = domDataBroker;
}
- /**
- * Helper class for result of transaction commit callback.
- * @param <T> Type of result
- */
- private final class ReadDataResult<T> {
- T result = null;
-
- T getResult() {
- return this.result;
- }
-
- void setResult(final T result) {
- this.result = result;
- }
- }
-
- /**
- * Set result from transaction commit callback.
- * @param t Throwable if transaction commit failed
- * @param datastore Datastore from which data are read
- * @param path Path from which data are read
- * @param result Result of read from {@code datastore}
- * @param readData Result value which will be set
- * @param <X> Result type
- */
- protected final static <X> void handlingCallback(final Throwable t, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final Optional<X> result,
- final ReadDataResult<X> readData) {
- if (t != null) {
- LOG.warn("Exception by reading {} via Restconf: {}", datastore.name(), path, t);
- throw new RestconfDocumentedException("Problem to get data from transaction.", t);
- } else {
- LOG.debug("Reading result data from transaction.");
- if (result != null) {
- if (result.isPresent()) {
- readData.setResult(result.get());
- }
- }
- }
- }
-
public void registerToListenNotification(final NotificationListenerAdapter listener) {
checkPreconditions();
}
}
- private void ensureParentsByMerge(final LogicalDatastoreType store, final YangInstanceIdentifier normalizedPath,
- final DOMDataReadWriteTransaction rwTx, final SchemaContext schemaContext) {
+ private static void ensureParentsByMerge(final LogicalDatastoreType store,
+ final YangInstanceIdentifier normalizedPath, final DOMDataReadWriteTransaction rwTx,
+ final SchemaContext schemaContext) {
final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
YangInstanceIdentifier rootNormalizedPath = null;
Code Review / netconf.git / blobdiff