*/
package org.opendaylight.netconf.sal.restconf.impl;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.URI;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
import org.opendaylight.mdsal.dom.api.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.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeContext;
import org.opendaylight.netconf.sal.streams.listeners.ListenerAdapter;
import org.opendaylight.netconf.sal.streams.listeners.NotificationListenerAdapter;
import org.opendaylight.netconf.sal.streams.listeners.Notificator;
import org.opendaylight.netconf.sal.streams.websockets.WebSocketServer;
+import org.opendaylight.restconf.common.OperationsContent;
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.ErrorTag;
-import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
import org.opendaylight.restconf.common.patch.PatchContext;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
-import org.opendaylight.restconf.common.util.DataChangeScope;
-import org.opendaylight.restconf.common.validation.RestconfValidationUtils;
+import org.opendaylight.restconf.common.util.OperationsResourceUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
+import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.CreateDataChangeEventSubscriptionInput1.Scope;
import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
+import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
+import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
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.SystemLeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.ListNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
-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.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.SchemaAwareBuilders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.util.SimpleSchemaContext;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(RestconfImpl.class);
- private static final DataChangeScope DEFAULT_SCOPE = DataChangeScope.BASE;
-
private static final LogicalDatastoreType DEFAULT_DATASTORE = LogicalDatastoreType.CONFIGURATION;
- private static final URI NAMESPACE_EVENT_SUBSCRIPTION_AUGMENT = URI.create("urn:sal:restconf:event:subscription");
+ private static final XMLNamespace NAMESPACE_EVENT_SUBSCRIPTION_AUGMENT =
+ XMLNamespace.of("urn:sal:restconf:event:subscription");
private static final String DATASTORE_PARAM_NAME = "datastore";
private static final String NETCONF_BASE_PAYLOAD_NAME = "data";
- private static final QName NETCONF_BASE_QNAME = QName.create(QNameModule.create(URI.create(NETCONF_BASE)),
+ private static final QName NETCONF_BASE_QNAME = QName.create(QNameModule.create(XMLNamespace.of(NETCONF_BASE)),
NETCONF_BASE_PAYLOAD_NAME).intern();
private static final QNameModule SAL_REMOTE_AUGMENT = QNameModule.create(NAMESPACE_EVENT_SUBSCRIPTION_AUGMENT,
}
@Override
+ @Deprecated
public NormalizedNodeContext getModules(final UriInfo uriInfo) {
- final Set<Module> allModules = this.controllerContext.getAllModules();
- final MapNode allModuleMap = makeModuleMapNode(allModules);
+ final MapNode allModuleMap = makeModuleMapNode(controllerContext.getAllModules());
- final SchemaContext schemaContext = this.controllerContext.getGlobalSchema();
+ final EffectiveModelContext schemaContext = controllerContext.getGlobalSchema();
final Module restconfModule = getRestconfModule();
- final DataSchemaNode modulesSchemaNode = this.controllerContext.getRestconfModuleRestConfSchemaNode(
+ final DataSchemaNode modulesSchemaNode = controllerContext.getRestconfModuleRestConfSchemaNode(
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
- Preconditions.checkState(modulesSchemaNode instanceof ContainerSchemaNode);
+ checkState(modulesSchemaNode instanceof ContainerSchemaNode);
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
- Builders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
+ SchemaAwareBuilders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
moduleContainerBuilder.withChild(allModuleMap);
- return new NormalizedNodeContext(new InstanceIdentifierContext<>(null, modulesSchemaNode, null, schemaContext),
+ return new NormalizedNodeContext(new InstanceIdentifierContext(null, modulesSchemaNode, null, schemaContext),
moduleContainerBuilder.build(), QueryParametersParser.parseWriterParameters(uriInfo));
}
* Valid only for mount point.
*/
@Override
+ @Deprecated
public NormalizedNodeContext getModules(final String identifier, final UriInfo uriInfo) {
- Preconditions.checkNotNull(identifier);
if (!identifier.contains(ControllerContext.MOUNT)) {
final String errMsg = "URI has bad format. If modules behind mount point should be showed,"
+ " URI has to end with " + ControllerContext.MOUNT;
throw new RestconfDocumentedException(errMsg, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- final InstanceIdentifierContext<?> mountPointIdentifier =
- this.controllerContext.toMountPointIdentifier(identifier);
+ final InstanceIdentifierContext mountPointIdentifier =
+ controllerContext.toMountPointIdentifier(identifier);
final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint();
- final Set<Module> modules = this.controllerContext.getAllModules(mountPoint);
- final MapNode mountPointModulesMap = makeModuleMapNode(modules);
+ final MapNode mountPointModulesMap = makeModuleMapNode(controllerContext.getAllModules(mountPoint));
final Module restconfModule = getRestconfModule();
- final DataSchemaNode modulesSchemaNode = this.controllerContext.getRestconfModuleRestConfSchemaNode(
+ final DataSchemaNode modulesSchemaNode = controllerContext.getRestconfModuleRestConfSchemaNode(
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
- Preconditions.checkState(modulesSchemaNode instanceof ContainerSchemaNode);
+ checkState(modulesSchemaNode instanceof ContainerSchemaNode);
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
- Builders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
+ SchemaAwareBuilders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
moduleContainerBuilder.withChild(mountPointModulesMap);
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, modulesSchemaNode, mountPoint,
- this.controllerContext.getGlobalSchema()),
+ new InstanceIdentifierContext(null, modulesSchemaNode, mountPoint,
+ controllerContext.getGlobalSchema()),
moduleContainerBuilder.build(), QueryParametersParser.parseWriterParameters(uriInfo));
}
@Override
+ @Deprecated
public NormalizedNodeContext getModule(final String identifier, final UriInfo uriInfo) {
- Preconditions.checkNotNull(identifier);
- final Entry<String, Revision> nameRev = getModuleNameAndRevision(identifier);
+ final Entry<String, Revision> nameRev = getModuleNameAndRevision(requireNonNull(identifier));
Module module = null;
DOMMountPoint mountPoint = null;
- final SchemaContext schemaContext;
+ final EffectiveModelContext schemaContext;
if (identifier.contains(ControllerContext.MOUNT)) {
- final InstanceIdentifierContext<?> mountPointIdentifier =
- this.controllerContext.toMountPointIdentifier(identifier);
+ final InstanceIdentifierContext mountPointIdentifier =
+ controllerContext.toMountPointIdentifier(identifier);
mountPoint = mountPointIdentifier.getMountPoint();
- module = this.controllerContext.findModuleByNameAndRevision(mountPoint, nameRev.getKey(),
+ module = controllerContext.findModuleByNameAndRevision(mountPoint, nameRev.getKey(),
nameRev.getValue());
- schemaContext = mountPoint.getSchemaContext();
+ schemaContext = modelContext(mountPoint);
} else {
- module = this.controllerContext.findModuleByNameAndRevision(nameRev.getKey(), nameRev.getValue());
- schemaContext = this.controllerContext.getGlobalSchema();
+ module = controllerContext.findModuleByNameAndRevision(nameRev.getKey(), nameRev.getValue());
+ schemaContext = controllerContext.getGlobalSchema();
}
if (module == null) {
final Set<Module> modules = Collections.singleton(module);
final MapNode moduleMap = makeModuleMapNode(modules);
- final DataSchemaNode moduleSchemaNode = this.controllerContext
+ final DataSchemaNode moduleSchemaNode = controllerContext
.getRestconfModuleRestConfSchemaNode(restconfModule, Draft02.RestConfModule.MODULE_LIST_SCHEMA_NODE);
- Preconditions.checkState(moduleSchemaNode instanceof ListSchemaNode);
+ checkState(moduleSchemaNode instanceof ListSchemaNode);
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, moduleSchemaNode, mountPoint, schemaContext), moduleMap,
+ new InstanceIdentifierContext(null, moduleSchemaNode, mountPoint, schemaContext), moduleMap,
QueryParametersParser.parseWriterParameters(uriInfo));
}
@Override
+ @Deprecated
public NormalizedNodeContext getAvailableStreams(final UriInfo uriInfo) {
- final SchemaContext schemaContext = this.controllerContext.getGlobalSchema();
+ final EffectiveModelContext schemaContext = controllerContext.getGlobalSchema();
final Set<String> availableStreams = Notificator.getStreamNames();
final Module restconfModule = getRestconfModule();
- final DataSchemaNode streamSchemaNode = this.controllerContext
+ final DataSchemaNode streamSchemaNode = controllerContext
.getRestconfModuleRestConfSchemaNode(restconfModule, Draft02.RestConfModule.STREAM_LIST_SCHEMA_NODE);
- Preconditions.checkState(streamSchemaNode instanceof ListSchemaNode);
+ checkState(streamSchemaNode instanceof ListSchemaNode);
- final CollectionNodeBuilder<MapEntryNode, MapNode> listStreamsBuilder =
- Builders.mapBuilder((ListSchemaNode) streamSchemaNode);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> listStreamsBuilder =
+ SchemaAwareBuilders.mapBuilder((ListSchemaNode) streamSchemaNode);
for (final String streamName : availableStreams) {
listStreamsBuilder.withChild(toStreamEntryNode(streamName, streamSchemaNode));
}
- final DataSchemaNode streamsContainerSchemaNode = this.controllerContext.getRestconfModuleRestConfSchemaNode(
+ final DataSchemaNode streamsContainerSchemaNode = controllerContext.getRestconfModuleRestConfSchemaNode(
restconfModule, Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
- Preconditions.checkState(streamsContainerSchemaNode instanceof ContainerSchemaNode);
+ checkState(streamsContainerSchemaNode instanceof ContainerSchemaNode);
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> streamsContainerBuilder =
- Builders.containerBuilder((ContainerSchemaNode) streamsContainerSchemaNode);
+ SchemaAwareBuilders.containerBuilder((ContainerSchemaNode) streamsContainerSchemaNode);
streamsContainerBuilder.withChild(listStreamsBuilder.build());
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, streamsContainerSchemaNode, null, schemaContext),
+ new InstanceIdentifierContext(null, streamsContainerSchemaNode, null, schemaContext),
streamsContainerBuilder.build(), QueryParametersParser.parseWriterParameters(uriInfo));
}
@Override
- public NormalizedNodeContext getOperations(final UriInfo uriInfo) {
- final Set<Module> allModules = this.controllerContext.getAllModules();
- return operationsFromModulesToNormalizedContext(allModules, null);
+ @Deprecated
+ public String getOperationsJSON() {
+ return OperationsContent.JSON.bodyFor(controllerContext.getGlobalSchema());
}
@Override
- public NormalizedNodeContext getOperations(final String identifier, final UriInfo uriInfo) {
- Set<Module> modules = null;
- DOMMountPoint mountPoint = null;
- if (identifier.contains(ControllerContext.MOUNT)) {
- final InstanceIdentifierContext<?> mountPointIdentifier =
- this.controllerContext.toMountPointIdentifier(identifier);
- mountPoint = mountPointIdentifier.getMountPoint();
- modules = this.controllerContext.getAllModules(mountPoint);
+ @Deprecated
+ public String getOperationsXML() {
+ return OperationsContent.XML.bodyFor(controllerContext.getGlobalSchema());
+ }
- } else {
+ @Override
+ @Deprecated
+ public NormalizedNodeContext getOperations(final String identifier, final UriInfo uriInfo) {
+ if (!identifier.contains(ControllerContext.MOUNT)) {
final String errMsg = "URI has bad format. If operations behind mount point should be showed, URI has to "
+ " end with " + ControllerContext.MOUNT;
LOG.debug("{} for {}", errMsg, identifier);
throw new RestconfDocumentedException(errMsg, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- return operationsFromModulesToNormalizedContext(modules, mountPoint);
- }
-
- /**
- * Special case only for GET restconf/operations use (since moment of
- * pre-Beryllium Yang parser and Yang model API removal). The method is
- * creating fake schema context with fake module and fake data by use own
- * implementations of schema nodes and module.
- *
- * @param modules
- * set of modules for get RPCs from every module
- * @param mountPoint
- * mount point, if in use otherwise null
- * @return {@link NormalizedNodeContext}
- */
- private static NormalizedNodeContext operationsFromModulesToNormalizedContext(final Set<Module> modules,
- final DOMMountPoint mountPoint) {
-
- final Collection<Module> neededModules = new ArrayList<>(modules.size());
- final ArrayList<LeafSchemaNode> fakeRpcSchema = new ArrayList<>();
-
- for (final Module m : modules) {
- final Set<RpcDefinition> rpcs = m.getRpcs();
- if (!rpcs.isEmpty()) {
- neededModules.add(m);
-
- fakeRpcSchema.ensureCapacity(fakeRpcSchema.size() + rpcs.size());
- rpcs.forEach(rpc -> fakeRpcSchema.add(new FakeLeafSchemaNode(rpc.getQName())));
- }
- }
-
- final ContainerSchemaNode fakeCont = new FakeContainerSchemaNode(fakeRpcSchema);
- final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
- Builders.containerBuilder(fakeCont);
-
- for (final LeafSchemaNode leaf : fakeRpcSchema) {
- containerBuilder.withChild(Builders.leafBuilder(leaf).build());
- }
-
- final Collection<Module> fakeModules = new ArrayList<>(neededModules.size() + 1);
- neededModules.forEach(imp -> fakeModules.add(new FakeImportedModule(imp)));
- fakeModules.add(new FakeRestconfModule(neededModules, fakeCont));
-
- final SchemaContext fakeSchemaCtx = SimpleSchemaContext.forModules(ImmutableSet.copyOf(fakeModules));
- final InstanceIdentifierContext<ContainerSchemaNode> instanceIdentifierContext =
- new InstanceIdentifierContext<>(null, fakeCont, mountPoint, fakeSchemaCtx);
- return new NormalizedNodeContext(instanceIdentifierContext, containerBuilder.build());
+ final InstanceIdentifierContext mountPointIdentifier = controllerContext.toMountPointIdentifier(identifier);
+ final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint();
+ final var entry = OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint);
+ return new NormalizedNodeContext(entry.getKey(), entry.getValue());
}
private Module getRestconfModule() {
- final Module restconfModule = this.controllerContext.getRestconfModule();
+ final Module restconfModule = controllerContext.getRestconfModule();
if (restconfModule == null) {
LOG.debug("ietf-restconf module was not found.");
throw new RestconfDocumentedException("ietf-restconf module was not found.", ErrorType.APPLICATION,
return invokeRpc(identifier, uriInfo);
}
- final SchemaPath type = payload.getInstanceIdentifierContext().getSchemaNode().getPath();
- final URI namespace = payload.getInstanceIdentifierContext().getSchemaNode().getQName().getNamespace();
- final ListenableFuture<DOMRpcResult> response;
+ final SchemaNode schema = payload.getInstanceIdentifierContext().getSchemaNode();
+ final ListenableFuture<? extends DOMRpcResult> response;
final DOMMountPoint mountPoint = payload.getInstanceIdentifierContext().getMountPoint();
- final SchemaContext schemaContext;
+ final NormalizedNode input = nonnullInput(schema, payload.getData());
+ final EffectiveModelContext schemaContext;
if (mountPoint != null) {
final Optional<DOMRpcService> mountRpcServices = mountPoint.getService(DOMRpcService.class);
- if (!mountRpcServices.isPresent()) {
+ if (mountRpcServices.isEmpty()) {
LOG.debug("Error: Rpc service is missing.");
throw new RestconfDocumentedException("Rpc service is missing.");
}
- schemaContext = mountPoint.getSchemaContext();
- response = mountRpcServices.get().invokeRpc(type, payload.getData());
+ schemaContext = modelContext(mountPoint);
+ response = mountRpcServices.get().invokeRpc(schema.getQName(), input);
} else {
+ final XMLNamespace namespace = schema.getQName().getNamespace();
if (namespace.toString().equals(SAL_REMOTE_NAMESPACE)) {
if (identifier.contains(CREATE_DATA_SUBSCR)) {
response = invokeSalRemoteRpcSubscribeRPC(payload);
throw new RestconfDocumentedException(msg, ErrorType.RPC, ErrorTag.OPERATION_NOT_SUPPORTED);
}
} else {
- response = this.broker.invokeRpc(type, payload.getData());
+ response = broker.invokeRpc(schema.getQName(), input);
}
- schemaContext = this.controllerContext.getGlobalSchema();
+ schemaContext = controllerContext.getGlobalSchema();
}
final DOMRpcResult result = checkRpcResponse(response);
RpcDefinition resultNodeSchema = null;
- final NormalizedNode<?, ?> resultData;
+ final NormalizedNode resultData;
if (result != null && result.getResult() != null) {
resultData = result.getResult();
resultNodeSchema = (RpcDefinition) payload.getInstanceIdentifierContext().getSchemaNode();
resultData = null;
}
- if (resultData != null && ((ContainerNode) resultData).getValue().isEmpty()) {
+ if (resultData != null && ((ContainerNode) resultData).isEmpty()) {
throw new WebApplicationException(Response.Status.NO_CONTENT);
} else {
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, resultNodeSchema, mountPoint, schemaContext),
+ new InstanceIdentifierContext(null, resultNodeSchema, mountPoint, schemaContext),
resultData, QueryParametersParser.parseWriterParameters(uriInfo));
}
}
+ @SuppressFBWarnings(value = "NP_LOAD_OF_KNOWN_NULL_VALUE",
+ justification = "Looks like a false positive, see below FIXME")
private NormalizedNodeContext invokeRpc(final String identifier, final UriInfo uriInfo) {
-
- DOMMountPoint mountPoint = null;
+ final DOMMountPoint mountPoint;
final String identifierEncoded;
- final SchemaContext schemaContext;
+ final EffectiveModelContext schemaContext;
if (identifier.contains(ControllerContext.MOUNT)) {
// mounted RPC call - look up mount instance.
- final InstanceIdentifierContext<?> mountPointId = this.controllerContext.toMountPointIdentifier(identifier);
+ final InstanceIdentifierContext mountPointId = controllerContext.toMountPointIdentifier(identifier);
mountPoint = mountPointId.getMountPoint();
- schemaContext = mountPoint.getSchemaContext();
+ schemaContext = modelContext(mountPoint);
final int startOfRemoteRpcName =
identifier.lastIndexOf(ControllerContext.MOUNT) + ControllerContext.MOUNT.length() + 1;
final String remoteRpcName = identifier.substring(startOfRemoteRpcName);
identifierEncoded = remoteRpcName;
- } else if (identifier.indexOf('/') != CHAR_NOT_FOUND) {
+ } else if (identifier.indexOf('/') == CHAR_NOT_FOUND) {
+ identifierEncoded = identifier;
+ mountPoint = null;
+ schemaContext = controllerContext.getGlobalSchema();
+ } else {
LOG.debug("Identifier {} cannot contain slash character (/).", identifier);
throw new RestconfDocumentedException(String.format("Identifier %n%s%ncan\'t contain slash character (/).%n"
+ "If slash is part of identifier name then use %%2F placeholder.", identifier), ErrorType.PROTOCOL,
ErrorTag.INVALID_VALUE);
- } else {
- identifierEncoded = identifier;
- schemaContext = this.controllerContext.getGlobalSchema();
}
- final String identifierDecoded = this.controllerContext.urlPathArgDecode(identifierEncoded);
-
- RpcDefinition rpc;
+ final String identifierDecoded = ControllerContext.urlPathArgDecode(identifierEncoded);
+ final RpcDefinition rpc;
if (mountPoint == null) {
- rpc = this.controllerContext.getRpcDefinition(identifierDecoded);
+ rpc = controllerContext.getRpcDefinition(identifierDecoded);
} else {
- rpc = findRpc(mountPoint.getSchemaContext(), identifierDecoded);
+ rpc = findRpc(modelContext(mountPoint), identifierDecoded);
}
if (rpc == null) {
+ " with an input section defined", ErrorType.RPC, ErrorTag.MISSING_ELEMENT);
}
- final ListenableFuture<DOMRpcResult> response;
+ final ContainerNode input = defaultInput(rpc.getQName());
+ final ListenableFuture<? extends DOMRpcResult> response;
if (mountPoint != null) {
final Optional<DOMRpcService> mountRpcServices = mountPoint.getService(DOMRpcService.class);
- if (!mountRpcServices.isPresent()) {
+ if (mountRpcServices.isEmpty()) {
throw new RestconfDocumentedException("Rpc service is missing.");
}
- response = mountRpcServices.get().invokeRpc(rpc.getPath(), null);
+ response = mountRpcServices.get().invokeRpc(rpc.getQName(), input);
} else {
- response = this.broker.invokeRpc(rpc.getPath(), null);
+ response = broker.invokeRpc(rpc.getQName(), input);
}
- final DOMRpcResult result = checkRpcResponse(response);
-
- if (result.getResult() != null && ((ContainerNode) result.getResult()).getValue().isEmpty()) {
+ final NormalizedNode result = checkRpcResponse(response).getResult();
+ if (result != null && ((ContainerNode) result).isEmpty()) {
throw new WebApplicationException(Response.Status.NO_CONTENT);
- } else {
- return new NormalizedNodeContext(new InstanceIdentifierContext<>(null, rpc, mountPoint, schemaContext),
- result.getResult(), QueryParametersParser.parseWriterParameters(uriInfo));
}
+
+ // FIXME: in reference to the above @SupressFBWarnings: "mountPoint" reference here trips up SpotBugs, as it
+ // thinks it can only ever be null. Except it can very much be non-null. The core problem is the horrible
+ // structure of this code where we have a sh*tload of checks for mountpoint above and all over the
+ // codebase where all that difference should have been properly encapsulated.
+ //
+ // This is legacy code, so if anybody cares to do that refactor, feel free to contribute, but I am not
+ // doing that work.
+ return new NormalizedNodeContext(new InstanceIdentifierContext(null, rpc, mountPoint, schemaContext), result,
+ QueryParametersParser.parseWriterParameters(uriInfo));
+ }
+
+ private static @NonNull NormalizedNode nonnullInput(final SchemaNode rpc, final NormalizedNode input) {
+ return input != null ? input : defaultInput(rpc.getQName());
+ }
+
+ private static @NonNull ContainerNode defaultInput(final QName rpcName) {
+ return ImmutableNodes.containerNode(YangConstants.operationInputQName(rpcName.getModule()));
}
@SuppressWarnings("checkstyle:avoidHidingCauseException")
- private static DOMRpcResult checkRpcResponse(final ListenableFuture<DOMRpcResult> response) {
+ private static DOMRpcResult checkRpcResponse(final ListenableFuture<? extends DOMRpcResult> response) {
if (response == null) {
return null;
}
} catch (final ExecutionException e) {
LOG.debug("Execution RpcError: ", e);
Throwable cause = e.getCause();
- if (cause != null) {
- while (cause.getCause() != null) {
- cause = cause.getCause();
- }
-
- if (cause instanceof IllegalArgumentException) {
- throw new RestconfDocumentedException(cause.getMessage(), ErrorType.PROTOCOL,
- ErrorTag.INVALID_VALUE);
- } else if (cause instanceof DOMRpcImplementationNotAvailableException) {
- throw new RestconfDocumentedException(cause.getMessage(), ErrorType.APPLICATION,
- ErrorTag.OPERATION_NOT_SUPPORTED);
- }
+ if (cause == null) {
throw new RestconfDocumentedException("The operation encountered an unexpected error while executing.",
- cause);
- } else {
- throw new RestconfDocumentedException("The operation encountered an unexpected error while executing.",
- e);
+ e);
+ }
+ while (cause.getCause() != null) {
+ cause = cause.getCause();
}
+
+ if (cause instanceof IllegalArgumentException) {
+ throw new RestconfDocumentedException(cause.getMessage(), ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
+ } else if (cause instanceof DOMRpcImplementationNotAvailableException) {
+ throw new RestconfDocumentedException(cause.getMessage(), ErrorType.APPLICATION,
+ ErrorTag.OPERATION_NOT_SUPPORTED);
+ }
+ throw new RestconfDocumentedException("The operation encountered an unexpected error while executing.",
+ cause);
} catch (final CancellationException e) {
final String errMsg = "The operation was cancelled while executing.";
LOG.debug("Cancel RpcExecution: {}", errMsg, e);
private ListenableFuture<DOMRpcResult> invokeSalRemoteRpcSubscribeRPC(final NormalizedNodeContext payload) {
final ContainerNode value = (ContainerNode) payload.getData();
final QName rpcQName = payload.getInstanceIdentifierContext().getSchemaNode().getQName();
- final Optional<DataContainerChild<? extends PathArgument, ?>> path = value.getChild(
- new NodeIdentifier(QName.create(payload.getInstanceIdentifierContext().getSchemaNode().getQName(),
- "path")));
- final Object pathValue = path.isPresent() ? path.get().getValue() : null;
+ final Optional<DataContainerChild> path =
+ value.findChildByArg(new NodeIdentifier(QName.create(rpcQName, "path")));
+ final Object pathValue = path.isPresent() ? path.get().body() : null;
if (!(pathValue instanceof YangInstanceIdentifier)) {
LOG.debug("Instance identifier {} was not normalized correctly", rpcQName);
NotificationOutputType outputType = null;
if (!pathIdentifier.isEmpty()) {
final String fullRestconfIdentifier =
- DATA_SUBSCR + this.controllerContext.toFullRestconfIdentifier(pathIdentifier, null);
+ DATA_SUBSCR + controllerContext.toFullRestconfIdentifier(pathIdentifier, null);
LogicalDatastoreType datastore =
parseEnumTypeParameter(value, LogicalDatastoreType.class, DATASTORE_PARAM_NAME);
datastore = datastore == null ? DEFAULT_DATASTORE : datastore;
- DataChangeScope scope = parseEnumTypeParameter(value, DataChangeScope.class, SCOPE_PARAM_NAME);
- scope = scope == null ? DEFAULT_SCOPE : scope;
+ Scope scope = parseEnumTypeParameter(value, Scope.class, SCOPE_PARAM_NAME);
+ scope = scope == null ? Scope.BASE : scope;
outputType = parseEnumTypeParameter(value, NotificationOutputType.class, OUTPUT_TYPE_PARAM_NAME);
outputType = outputType == null ? NotificationOutputType.XML : outputType;
break;
}
}
+
+ // TODO: this flag is always ignored
boolean tagged = false;
if (withDefaUsed) {
if ("report-all-tagged".equals(withDefa)) {
}
}
- final InstanceIdentifierContext<?> iiWithData = this.controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
- NormalizedNode<?, ?> data = null;
+ NormalizedNode data = null;
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
if (mountPoint != null) {
- data = this.broker.readConfigurationData(mountPoint, normalizedII, withDefa);
+ data = broker.readConfigurationData(mountPoint, normalizedII, withDefa);
} else {
- data = this.broker.readConfigurationData(normalizedII, withDefa);
+ data = broker.readConfigurationData(normalizedII, withDefa);
}
if (data == null) {
throw dataMissing(identifier);
}
- return new NormalizedNodeContext(iiWithData, data,
- QueryParametersParser.parseWriterParameters(uriInfo, tagged));
+ return new NormalizedNodeContext(iiWithData, data, QueryParametersParser.parseWriterParameters(uriInfo));
}
@Override
public NormalizedNodeContext readOperationalData(final String identifier, final UriInfo uriInfo) {
- final InstanceIdentifierContext<?> iiWithData = this.controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
- NormalizedNode<?, ?> data = null;
+ NormalizedNode data = null;
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
if (mountPoint != null) {
- data = this.broker.readOperationalData(mountPoint, normalizedII);
+ data = broker.readOperationalData(mountPoint, normalizedII);
} else {
- data = this.broker.readOperationalData(normalizedII);
+ data = broker.readOperationalData(normalizedII);
}
if (data == null) {
throw dataMissing(identifier);
"Point parameter can be used only with 'after' or 'before' values of Insert parameter.");
}
- Preconditions.checkNotNull(identifier);
+ requireNonNull(identifier);
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iiWithData = payload.getInstanceIdentifierContext();
validateInput(iiWithData.getSchemaNode(), payload);
validateTopLevelNodeName(payload, iiWithData.getInstanceIdentifier());
while (true) {
if (mountPoint != null) {
- result = this.broker.commitMountPointDataPut(mountPoint, normalizedII, payload.getData(), insert,
+ result = broker.commitMountPointDataPut(mountPoint, normalizedII, payload.getData(), insert,
point);
} else {
- result = this.broker.commitConfigurationDataPut(this.controllerContext.getGlobalSchema(), normalizedII,
+ result = broker.commitConfigurationDataPut(controllerContext.getGlobalSchema(), normalizedII,
payload.getData(), insert, point);
}
private static void validateTopLevelNodeName(final NormalizedNodeContext node,
final YangInstanceIdentifier identifier) {
- final String payloadName = node.getData().getNodeType().getLocalName();
+ final String payloadName = node.getData().getIdentifier().getNodeType().getLocalName();
// no arguments
if (identifier.isEmpty()) {
// no "data" payload
- if (!node.getData().getNodeType().equals(NETCONF_BASE_QNAME)) {
+ if (!node.getData().getIdentifier().getNodeType().equals(NETCONF_BASE_QNAME)) {
throw new RestconfDocumentedException("Instance identifier has to contain at least one path argument",
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE);
}
*
*/
private static void validateListKeysEqualityInPayloadAndUri(final NormalizedNodeContext payload) {
- Preconditions.checkArgument(payload != null);
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ checkArgument(payload != null);
+ 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 Map<QName, Object> uriKeyValues =
- ((NodeIdentifierWithPredicates) lastPathArgument).getKeyValues();
+ final Map<QName, Object> uriKeyValues = ((NodeIdentifierWithPredicates) lastPathArgument).asMap();
isEqualUriAndPayloadKeyValues(uriKeyValues, (MapEntryNode) data, keyDefinitions);
}
}
public 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);
- // should be caught during parsing URI to InstanceIdentifier
- RestconfValidationUtils.checkDocumentedError(uriKeyValue != null, ErrorType.PROTOCOL, ErrorTag.DATA_MISSING,
- "Missing key " + keyDefinition + " in URI.");
+ final Object uriKeyValue = RestconfDocumentedException.throwIfNull(
+ // should be caught during parsing URI to InstanceIdentifier
+ 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 (!Objects.deepEquals(uriKeyValue, dataKeyValue)) {
final String errMsg = "The value '" + uriKeyValue + "' for key '" + keyDefinition.getLocalName()
throw new RestconfDocumentedException("Input is required.", ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE);
}
final DOMMountPoint mountPoint = payload.getInstanceIdentifierContext().getMountPoint();
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iiWithData = payload.getInstanceIdentifierContext();
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
boolean insertUsed = false;
FluentFuture<? extends CommitInfo> future;
if (mountPoint != null) {
- future = this.broker.commitConfigurationDataPost(mountPoint, normalizedII, payload.getData(), insert,
+ future = broker.commitConfigurationDataPost(mountPoint, normalizedII, payload.getData(), insert,
point);
} else {
- future = this.broker.commitConfigurationDataPost(this.controllerContext.getGlobalSchema(), normalizedII,
+ future = broker.commitConfigurationDataPost(controllerContext.getGlobalSchema(), normalizedII,
payload.getData(), insert, point);
}
final UriBuilder uriBuilder = uriInfo.getBaseUriBuilder();
uriBuilder.path("config");
try {
- uriBuilder.path(this.controllerContext.toFullRestconfIdentifier(normalizedII, mountPoint));
+ uriBuilder.path(controllerContext.toFullRestconfIdentifier(normalizedII, mountPoint));
} catch (final Exception e) {
LOG.info("Location for instance identifier {} was not created", normalizedII, e);
return null;
@Override
public Response deleteConfigurationData(final String identifier) {
- final InstanceIdentifierContext<?> iiWithData = this.controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
final FluentFuture<? extends CommitInfo> future;
if (mountPoint != null) {
- future = this.broker.commitConfigurationDataDelete(mountPoint, normalizedII);
+ future = broker.commitConfigurationDataDelete(mountPoint, normalizedII);
} else {
- future = this.broker.commitConfigurationDataDelete(normalizedII);
+ future = broker.commitConfigurationDataDelete(normalizedII);
}
try {
* <ul>
* <li>datastore - default CONFIGURATION (other values of
* {@link LogicalDatastoreType} enum type)</li>
- * <li>scope - default BASE (other values of {@link DataChangeScope})</li>
+ * <li>scope - default BASE (other values of {@link Scope})</li>
* </ul>
*/
@Override
String filter = null;
boolean leafNodesOnlyUsed = false;
boolean leafNodesOnly = false;
+ boolean skipNotificationDataUsed = false;
+ boolean skipNotificationData = false;
for (final Entry<String, List<String>> entry : uriInfo.getQueryParameters().entrySet()) {
switch (entry.getKey()) {
throw new RestconfDocumentedException("Odl-leaf-nodes-only parameter can be used only once.");
}
break;
+ case "odl-skip-notification-data":
+ if (!skipNotificationDataUsed) {
+ skipNotificationDataUsed = true;
+ skipNotificationData = Boolean.parseBoolean(entry.getValue().iterator().next());
+ } else {
+ throw new RestconfDocumentedException(
+ "Odl-skip-notification-data parameter can be used only once.");
+ }
+ break;
default:
throw new RestconfDocumentedException("Bad parameter used with notifications: " + entry.getKey());
}
}
URI response = null;
if (identifier.contains(DATA_SUBSCR)) {
- response = dataSubs(identifier, uriInfo, start, stop, filter, leafNodesOnly);
+ response = dataSubs(identifier, uriInfo, start, stop, filter, leafNodesOnly, skipNotificationData);
} else if (identifier.contains(NOTIFICATION_STREAM)) {
response = notifStream(identifier, uriInfo, start, stop, filter);
}
if (response != null) {
// prepare node with value of location
- final InstanceIdentifierContext<?> iid = prepareIIDSubsStreamOutput();
+ final InstanceIdentifierContext iid = prepareIIDSubsStreamOutput();
final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> builder =
ImmutableLeafNodeBuilder.create().withValue(response.toString());
builder.withNodeIdentifier(
NodeIdentifier.create(QName.create("subscribe:to:notification", "2016-10-28", "location")));
// prepare new header with location
- final Map<String, Object> headers = new HashMap<>();
- headers.put("Location", response);
-
- return new NormalizedNodeContext(iid, builder.build(), headers);
+ return new NormalizedNodeContext(iid, builder.build(), ImmutableMap.of("Location", response));
}
final String msg = "Bad type of notification of sal-remote";
* @return {@link InstanceIdentifierContext} of location leaf for
* notification
*/
- private InstanceIdentifierContext<?> prepareIIDSubsStreamOutput() {
+ private InstanceIdentifierContext prepareIIDSubsStreamOutput() {
final QName qnameBase = QName.create("subscribe:to:notification", "2016-10-28", "notifi");
- final SchemaContext schemaCtx = controllerContext.getGlobalSchema();
+ final EffectiveModelContext schemaCtx = controllerContext.getGlobalSchema();
final DataSchemaNode location = ((ContainerSchemaNode) schemaCtx
.findModule(qnameBase.getModule()).orElse(null)
.getDataChildByName(qnameBase)).getDataChildByName(QName.create(qnameBase, "location"));
path.add(NodeIdentifier.create(qnameBase));
path.add(NodeIdentifier.create(QName.create(qnameBase, "location")));
- return new InstanceIdentifierContext<SchemaNode>(YangInstanceIdentifier.create(path), location, null,
- schemaCtx);
+ return new InstanceIdentifierContext(YangInstanceIdentifier.create(path), location, null, schemaCtx);
}
/**
}
for (final NotificationListenerAdapter listener : listeners) {
- this.broker.registerToListenNotification(listener);
- listener.setQueryParams(start, Optional.ofNullable(stop), Optional.ofNullable(filter), false);
+ broker.registerToListenNotification(listener);
+ listener.setQueryParams(start, Optional.ofNullable(stop), Optional.ofNullable(filter), false, false);
}
final UriBuilder uriBuilder = uriInfo.getAbsolutePathBuilder();
* @return {@link URI} of location
*/
private URI dataSubs(final String identifier, final UriInfo uriInfo, final Instant start, final Instant stop,
- final String filter, final boolean leafNodesOnly) {
+ final String filter, final boolean leafNodesOnly, final boolean skipNotificationData) {
final String streamName = Notificator.createStreamNameFromUri(identifier);
if (Strings.isNullOrEmpty(streamName)) {
throw new RestconfDocumentedException("Stream name is empty.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
throw new RestconfDocumentedException("Stream was not found.", ErrorType.PROTOCOL,
ErrorTag.UNKNOWN_ELEMENT);
}
- listener.setQueryParams(start, Optional.ofNullable(stop), Optional.ofNullable(filter), leafNodesOnly);
+ listener.setQueryParams(start, Optional.ofNullable(stop), Optional.ofNullable(filter), leafNodesOnly,
+ skipNotificationData);
final Map<String, String> paramToValues = resolveValuesFromUri(identifier);
final LogicalDatastoreType datastore =
throw new RestconfDocumentedException("Stream name doesn't contains datastore value (pattern /datastore=)",
ErrorType.APPLICATION, ErrorTag.MISSING_ATTRIBUTE);
}
- final DataChangeScope scope =
- parserURIEnumParameter(DataChangeScope.class, paramToValues.get(SCOPE_PARAM_NAME));
+ final Scope scope = parserURIEnumParameter(Scope.class, paramToValues.get(SCOPE_PARAM_NAME));
if (scope == null) {
throw new RestconfDocumentedException("Stream name doesn't contains datastore value (pattern /scope=)",
ErrorType.APPLICATION, ErrorTag.MISSING_ATTRIBUTE);
}
- this.broker.registerToListenDataChanges(datastore, scope, listener);
+ broker.registerToListenDataChanges(datastore, scope, listener);
final UriBuilder uriBuilder = uriInfo.getAbsolutePathBuilder();
}
try {
- return this.broker.patchConfigurationDataWithinTransaction(context);
+ return broker.patchConfigurationDataWithinTransaction(context);
} catch (final Exception e) {
LOG.debug("Patch transaction failed", e);
throw new RestconfDocumentedException(e.getMessage(), e);
}
try {
- return this.broker.patchConfigurationDataWithinTransaction(context);
+ return broker.patchConfigurationDataWithinTransaction(context);
} catch (final Exception e) {
LOG.debug("Patch transaction failed", e);
throw new RestconfDocumentedException(e.getMessage(), e);
*/
private static <T> T parseEnumTypeParameter(final ContainerNode value, final Class<T> classDescriptor,
final String paramName) {
- final Optional<DataContainerChild<? extends PathArgument, ?>> optAugNode = value.getChild(
- SAL_REMOTE_AUG_IDENTIFIER);
- if (!optAugNode.isPresent()) {
+ final Optional<DataContainerChild> optAugNode = value.findChildByArg(SAL_REMOTE_AUG_IDENTIFIER);
+ if (optAugNode.isEmpty()) {
return null;
}
- final DataContainerChild<? extends PathArgument, ?> augNode = optAugNode.get();
+ final DataContainerChild augNode = optAugNode.get();
if (!(augNode instanceof AugmentationNode)) {
return null;
}
- final Optional<DataContainerChild<? extends PathArgument, ?>> enumNode = ((AugmentationNode) augNode).getChild(
+ final Optional<DataContainerChild> enumNode = ((AugmentationNode) augNode).findChildByArg(
new NodeIdentifier(QName.create(SAL_REMOTE_AUGMENT, paramName)));
- if (!enumNode.isPresent()) {
+ if (enumNode.isEmpty()) {
return null;
}
- final Object rawValue = enumNode.get().getValue();
+ final Object rawValue = enumNode.get().body();
if (!(rawValue instanceof String)) {
return null;
}
return result;
}
- private MapNode makeModuleMapNode(final Set<Module> modules) {
- Preconditions.checkNotNull(modules);
+ private MapNode makeModuleMapNode(final Collection<? extends Module> modules) {
+ requireNonNull(modules);
final Module restconfModule = getRestconfModule();
- final DataSchemaNode moduleSchemaNode = this.controllerContext
+ final DataSchemaNode moduleSchemaNode = controllerContext
.getRestconfModuleRestConfSchemaNode(restconfModule, Draft02.RestConfModule.MODULE_LIST_SCHEMA_NODE);
- Preconditions.checkState(moduleSchemaNode instanceof ListSchemaNode);
+ checkState(moduleSchemaNode instanceof ListSchemaNode);
- final CollectionNodeBuilder<MapEntryNode, MapNode> listModuleBuilder =
- Builders.mapBuilder((ListSchemaNode) moduleSchemaNode);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> listModuleBuilder =
+ SchemaAwareBuilders.mapBuilder((ListSchemaNode) moduleSchemaNode);
for (final Module module : modules) {
listModuleBuilder.withChild(toModuleEntryNode(module, moduleSchemaNode));
return listModuleBuilder.build();
}
- private MapEntryNode toModuleEntryNode(final Module module, final DataSchemaNode moduleSchemaNode) {
- Preconditions.checkArgument(moduleSchemaNode instanceof ListSchemaNode,
+ private static MapEntryNode toModuleEntryNode(final Module module, final DataSchemaNode moduleSchemaNode) {
+ checkArgument(moduleSchemaNode instanceof ListSchemaNode,
"moduleSchemaNode has to be of type ListSchemaNode");
final ListSchemaNode listModuleSchemaNode = (ListSchemaNode) moduleSchemaNode;
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> moduleNodeValues =
- Builders.mapEntryBuilder(listModuleSchemaNode);
+ SchemaAwareBuilders.mapEntryBuilder(listModuleSchemaNode);
List<DataSchemaNode> instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listModuleSchemaNode, "name");
final DataSchemaNode nameSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(nameSchemaNode instanceof LeafSchemaNode);
- moduleNodeValues
- .withChild(Builders.leafBuilder((LeafSchemaNode) nameSchemaNode).withValue(module.getName()).build());
+ checkState(nameSchemaNode instanceof LeafSchemaNode);
+ moduleNodeValues.withChild(
+ SchemaAwareBuilders.leafBuilder((LeafSchemaNode) nameSchemaNode).withValue(module.getName()).build());
final QNameModule qNameModule = module.getQNameModule();
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listModuleSchemaNode, "revision");
final DataSchemaNode revisionSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(revisionSchemaNode instanceof LeafSchemaNode);
+ checkState(revisionSchemaNode instanceof LeafSchemaNode);
final Optional<Revision> revision = qNameModule.getRevision();
- moduleNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) revisionSchemaNode)
+ moduleNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) revisionSchemaNode)
.withValue(revision.map(Revision::toString).orElse("")).build());
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listModuleSchemaNode, "namespace");
final DataSchemaNode namespaceSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(namespaceSchemaNode instanceof LeafSchemaNode);
- moduleNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) namespaceSchemaNode)
+ checkState(namespaceSchemaNode instanceof LeafSchemaNode);
+ moduleNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) namespaceSchemaNode)
.withValue(qNameModule.getNamespace().toString()).build());
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listModuleSchemaNode, "feature");
final DataSchemaNode featureSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(featureSchemaNode instanceof LeafListSchemaNode);
- final ListNodeBuilder<Object, LeafSetEntryNode<Object>> featuresBuilder =
- Builders.leafSetBuilder((LeafListSchemaNode) featureSchemaNode);
+ checkState(featureSchemaNode instanceof LeafListSchemaNode);
+ final ListNodeBuilder<Object, SystemLeafSetNode<Object>> featuresBuilder =
+ SchemaAwareBuilders.leafSetBuilder((LeafListSchemaNode) featureSchemaNode);
for (final FeatureDefinition feature : module.getFeatures()) {
- featuresBuilder.withChild(Builders.leafSetEntryBuilder((LeafListSchemaNode) featureSchemaNode)
+ featuresBuilder.withChild(SchemaAwareBuilders.leafSetEntryBuilder((LeafListSchemaNode) featureSchemaNode)
.withValue(feature.getQName().getLocalName()).build());
}
moduleNodeValues.withChild(featuresBuilder.build());
}
protected MapEntryNode toStreamEntryNode(final String streamName, final DataSchemaNode streamSchemaNode) {
- Preconditions.checkArgument(streamSchemaNode instanceof ListSchemaNode,
+ checkArgument(streamSchemaNode instanceof ListSchemaNode,
"streamSchemaNode has to be of type ListSchemaNode");
final ListSchemaNode listStreamSchemaNode = (ListSchemaNode) streamSchemaNode;
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamNodeValues =
- Builders.mapEntryBuilder(listStreamSchemaNode);
+ SchemaAwareBuilders.mapEntryBuilder(listStreamSchemaNode);
List<DataSchemaNode> instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listStreamSchemaNode, "name");
final DataSchemaNode nameSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(nameSchemaNode instanceof LeafSchemaNode);
- streamNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) nameSchemaNode).withValue(streamName).build());
+ checkState(nameSchemaNode instanceof LeafSchemaNode);
+ streamNodeValues.withChild(
+ SchemaAwareBuilders.leafBuilder((LeafSchemaNode) nameSchemaNode).withValue(streamName).build());
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listStreamSchemaNode, "description");
final DataSchemaNode descriptionSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(descriptionSchemaNode instanceof LeafSchemaNode);
- streamNodeValues.withChild(
- Builders.leafBuilder((LeafSchemaNode) nameSchemaNode).withValue("DESCRIPTION_PLACEHOLDER").build());
+ checkState(descriptionSchemaNode instanceof LeafSchemaNode);
+ streamNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) nameSchemaNode)
+ .withValue("DESCRIPTION_PLACEHOLDER")
+ .build());
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listStreamSchemaNode, "replay-support");
final DataSchemaNode replaySupportSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(replaySupportSchemaNode instanceof LeafSchemaNode);
- streamNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) replaySupportSchemaNode)
+ checkState(replaySupportSchemaNode instanceof LeafSchemaNode);
+ streamNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) replaySupportSchemaNode)
.withValue(Boolean.TRUE).build());
instanceDataChildrenByName =
ControllerContext.findInstanceDataChildrenByName(listStreamSchemaNode, "replay-log-creation-time");
final DataSchemaNode replayLogCreationTimeSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(replayLogCreationTimeSchemaNode instanceof LeafSchemaNode);
+ checkState(replayLogCreationTimeSchemaNode instanceof LeafSchemaNode);
streamNodeValues.withChild(
- Builders.leafBuilder((LeafSchemaNode) replayLogCreationTimeSchemaNode).withValue("").build());
+ SchemaAwareBuilders.leafBuilder((LeafSchemaNode) replayLogCreationTimeSchemaNode).withValue("").build());
instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(listStreamSchemaNode, "events");
final DataSchemaNode eventsSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
- Preconditions.checkState(eventsSchemaNode instanceof LeafSchemaNode);
- streamNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) eventsSchemaNode).build());
+ checkState(eventsSchemaNode instanceof LeafSchemaNode);
+ streamNodeValues.withChild(
+ SchemaAwareBuilders.leafBuilder((LeafSchemaNode) eventsSchemaNode).withValue(Empty.value()).build());
return streamNodeValues.build();
}
final ContainerNode data = (ContainerNode) payload.getData();
LeafSetNode leafSet = null;
String outputType = "XML";
- for (final DataContainerChild<? extends PathArgument, ?> dataChild : data.getValue()) {
+ for (final DataContainerChild dataChild : data.body()) {
if (dataChild instanceof LeafSetNode) {
leafSet = (LeafSetNode) dataChild;
} else if (dataChild instanceof AugmentationNode) {
- outputType = (String) ((AugmentationNode) dataChild).getValue().iterator().next().getValue();
+ outputType = (String) ((AugmentationNode) dataChild).body().iterator().next().body();
}
}
- final Collection<LeafSetEntryNode> entryNodes = leafSet.getValue();
+ final Collection<LeafSetEntryNode<?>> entryNodes = leafSet.body();
final List<SchemaPath> paths = new ArrayList<>();
String streamName = CREATE_NOTIFICATION_STREAM + "/";
StringBuilder streamNameBuilder = new StringBuilder(streamName);
- final Iterator<LeafSetEntryNode> iterator = entryNodes.iterator();
+ final Iterator<LeafSetEntryNode<?>> iterator = entryNodes.iterator();
while (iterator.hasNext()) {
- final QName valueQName = QName.create((String) iterator.next().getValue());
- final Module module = controllerContext.findModuleByNamespace(valueQName.getModule().getNamespace());
- Preconditions.checkNotNull(module,
- "Module for namespace " + valueQName.getModule().getNamespace() + " does not exist");
+ final QName valueQName = QName.create((String) iterator.next().body());
+ final XMLNamespace namespace = valueQName.getModule().getNamespace();
+ final Module module = controllerContext.findModuleByNamespace(namespace);
+ checkNotNull(module, "Module for namespace %s does not exist", namespace);
NotificationDefinition notifiDef = null;
for (final NotificationDefinition notification : module.getNotifications()) {
if (notification.getQName().equals(valueQName)) {
}
}
final String moduleName = module.getName();
- Preconditions.checkNotNull(notifiDef,
- "Notification " + valueQName + "doesn't exist in module " + moduleName);
- paths.add(notifiDef.getPath());
+ checkNotNull(notifiDef, "Notification %s does not exist in module %s", valueQName, moduleName);
+ paths.add(SchemaPath.of(Absolute.of(notifiDef.getQName())));
streamNameBuilder.append(moduleName).append(':').append(valueQName.getLocalName());
if (iterator.hasNext()) {
streamNameBuilder.append(',');
return Futures.immediateFuture(new DefaultDOMRpcResult(output));
}
+
+ private static EffectiveModelContext modelContext(final DOMMountPoint mountPoint) {
+ return mountPoint.getService(DOMSchemaService.class)
+ .flatMap(svc -> Optional.ofNullable(svc.getGlobalContext()))
+ .orElse(null);
+ }
}
Code Review / netconf.git / blobdiff