import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-public class InstanceIdentifierContext<T extends SchemaNode> {
-
+// FIXME: non-final for Mocking, which we should not tolerate
+public class InstanceIdentifierContext {
private final YangInstanceIdentifier instanceIdentifier;
- private final T schemaNode;
+ private final SchemaNode schemaNode;
private final DOMMountPoint mountPoint;
private final EffectiveModelContext schemaContext;
- public InstanceIdentifierContext(final YangInstanceIdentifier instanceIdentifier, final T schemaNode,
+ public InstanceIdentifierContext(final YangInstanceIdentifier instanceIdentifier, final SchemaNode schemaNode,
final DOMMountPoint mountPoint, final EffectiveModelContext context) {
this.instanceIdentifier = instanceIdentifier;
this.schemaNode = schemaNode;
this.mountPoint = mountPoint;
- this.schemaContext = context;
+ schemaContext = context;
}
public YangInstanceIdentifier getInstanceIdentifier() {
return instanceIdentifier;
}
- public T getSchemaNode() {
+ public SchemaNode getSchemaNode() {
return schemaNode;
}
import java.util.List;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
public class PatchContext {
- private final InstanceIdentifierContext<? extends SchemaNode> context;
+ private final InstanceIdentifierContext context;
private final List<PatchEntity> data;
private final String patchId;
- public PatchContext(final InstanceIdentifierContext<? extends SchemaNode> context,
- final List<PatchEntity> data, final String patchId) {
+ public PatchContext(final InstanceIdentifierContext context, final List<PatchEntity> data, final String patchId) {
this.context = requireNonNull(context);
this.data = requireNonNull(data);
this.patchId = requireNonNull(patchId);
}
- public InstanceIdentifierContext<? extends SchemaNode> getInstanceIdentifierContext() {
+ public InstanceIdentifierContext getInstanceIdentifierContext() {
return context;
}
// Hidden on purpose
}
- public static @NonNull Entry<InstanceIdentifierContext<OperationsContainerSchemaNode>, ContainerNode>
+ public static @NonNull Entry<InstanceIdentifierContext, ContainerNode>
contextForModelContext(final @NonNull SchemaContext context, final @Nullable DOMMountPoint mountPoint) {
// Determine which modules we need and construct leaf schemas to correspond to all RPC definitions
final Collection<Module> modules = new ArrayList<>();
operationsBuilder.withChild(ImmutableNodes.leafNode(leaf.getQName(), Empty.value()));
}
- return Map.entry(new InstanceIdentifierContext<>(null, operatationsSchema, mountPoint,
+ return Map.entry(new InstanceIdentifierContext(null, operatationsSchema, mountPoint,
new OperationsEffectiveModuleContext(ImmutableSet.copyOf(modules))), operationsBuilder.build());
}
}
}
private SchemaContext getMountSchemaContext(final String identifier) {
- final InstanceIdentifierContext<?> mountContext = salContext.toMountPointIdentifier(identifier);
+ final InstanceIdentifierContext mountContext = salContext.toMountPointIdentifier(identifier);
return mountContext.getSchemaContext();
}
}
private final ControllerContext controllerContext;
- protected AbstractIdentifierAwareJaxRsProvider(ControllerContext controllerContext) {
+ protected AbstractIdentifierAwareJaxRsProvider(final ControllerContext controllerContext) {
this.controllerContext = controllerContext;
}
protected final String getIdentifier() {
- return this.uriInfo.getPathParameters(false).getFirst(RestconfConstants.IDENTIFIER);
+ return uriInfo.getPathParameters(false).getFirst(RestconfConstants.IDENTIFIER);
}
- protected InstanceIdentifierContext<?> getInstanceIdentifierContext() {
+ protected InstanceIdentifierContext getInstanceIdentifierContext() {
return controllerContext.toInstanceIdentifier(getIdentifier());
}
protected UriInfo getUriInfo() {
- return this.uriInfo;
+ return uriInfo;
}
protected boolean isPost() {
- return POST.equals(this.request.getMethod());
+ return POST.equals(request.getMethod());
}
protected ControllerContext getControllerContext() {
}
Request getRequest() {
- return this.request;
+ return request;
}
}
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.data.impl.schema.ResultAlreadySetException;
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.SchemaInferenceStack;
import org.slf4j.Logger;
}
}
- private static NormalizedNodeContext readFrom(final InstanceIdentifierContext<?> path,
+ private static NormalizedNodeContext readFrom(final InstanceIdentifierContext path,
final InputStream entityStream, final boolean isPost)
throws IOException {
final Optional<InputStream> nonEmptyInputStreamOptional = RestUtil.isInputStreamEmpty(entityStream);
NormalizedNode result = resultHolder.getResult();
final List<YangInstanceIdentifier.PathArgument> iiToDataList = new ArrayList<>();
- InstanceIdentifierContext<? extends SchemaNode> newIIContext;
+ InstanceIdentifierContext newIIContext;
while (result instanceof AugmentationNode || result instanceof ChoiceNode) {
final Object childNode = ((DataContainerNode) result).body().iterator().next();
final YangInstanceIdentifier fullIIToData = YangInstanceIdentifier.create(Iterables.concat(
path.getInstanceIdentifier().getPathArguments(), iiToDataList));
- newIIContext = new InstanceIdentifierContext<>(fullIIToData, path.getSchemaNode(), path.getMountPoint(),
+ newIIContext = new InstanceIdentifierContext(fullIIToData, path.getSchemaNode(), path.getMountPoint(),
path.getSchemaContext());
return new NormalizedNodeContext(newIIContext, result);
}
}
- private PatchContext readFrom(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ private PatchContext readFrom(final InstanceIdentifierContext path, final InputStream entityStream)
throws IOException {
final Optional<InputStream> nonEmptyInputStreamOptional = RestUtil.isInputStreamEmpty(entityStream);
if (nonEmptyInputStreamOptional.isEmpty()) {
ErrorTag.MALFORMED_MESSAGE, exception);
}
- private List<PatchEntity> read(final JsonReader in, final InstanceIdentifierContext<?> path,
+ private List<PatchEntity> read(final JsonReader in, final InstanceIdentifierContext path,
final AtomicReference<String> patchId) throws IOException {
final List<PatchEntity> resultCollection = new ArrayList<>();
final StringModuleInstanceIdentifierCodec codec = new StringModuleInstanceIdentifierCodec(
* @throws IOException if operation fails
*/
private void parseByName(final @NonNull String name, final @NonNull PatchEdit edit,
- final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext path,
final @NonNull StringModuleInstanceIdentifierCodec codec,
final @NonNull List<PatchEntity> resultCollection,
final @NonNull AtomicReference<String> patchId) throws IOException {
* @throws IOException if operation fails
*/
private void readEditDefinition(final @NonNull PatchEdit edit, final @NonNull JsonReader in,
- final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull InstanceIdentifierContext path,
final @NonNull StringModuleInstanceIdentifierCodec codec) throws IOException {
final StringBuilder value = new StringBuilder();
in.beginObject();
* @return NormalizedNode representing data
*/
private static NormalizedNode readEditData(final @NonNull JsonReader in,
- final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext<?> path) {
+ final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final EffectiveModelContext context = path.getSchemaContext();
private NormalizedNode data;
public String getId() {
- return this.id;
+ return id;
}
public void setId(final String id) {
}
public PatchEditOperation getOperation() {
- return this.operation;
+ return operation;
}
public void setOperation(final PatchEditOperation operation) {
}
public YangInstanceIdentifier getTarget() {
- return this.target;
+ return target;
}
public void setTarget(final YangInstanceIdentifier target) {
}
public SchemaNode getTargetSchemaNode() {
- return this.targetSchemaNode;
+ return targetSchemaNode;
}
public void setTargetSchemaNode(final SchemaNode targetSchemaNode) {
}
public NormalizedNode getData() {
- return this.data;
+ return data;
}
public void setData(final NormalizedNode data) {
}
public void clear() {
- this.id = null;
- this.operation = null;
- this.target = null;
- this.targetSchemaNode = null;
- this.data = null;
+ id = null;
+ operation = null;
+ target = null;
+ targetSchemaNode = null;
+ data = null;
}
}
}
import com.google.common.collect.ImmutableMap;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
@Deprecated(forRemoval = true, since = "2.0.6")
// Non-final for mocking
public class NormalizedNodeContext {
- private final InstanceIdentifierContext<? extends SchemaNode> context;
+ private final InstanceIdentifierContext context;
private final ImmutableMap<String, Object> headers;
private final WriterParameters writerParameters;
private final NormalizedNode data;
- public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ public NormalizedNodeContext(final InstanceIdentifierContext context,
final NormalizedNode data, final WriterParameters writerParameters,
final ImmutableMap<String, Object> headers) {
this.context = context;
this.headers = requireNonNull(headers);
}
- public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ public NormalizedNodeContext(final InstanceIdentifierContext context,
final NormalizedNode data, final WriterParameters writerParameters) {
this(context, data, writerParameters, ImmutableMap.of());
}
- public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ public NormalizedNodeContext(final InstanceIdentifierContext context,
final NormalizedNode data) {
this(context, data, WriterParameters.EMPTY, ImmutableMap.of());
}
- public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ public NormalizedNodeContext(final InstanceIdentifierContext context,
final NormalizedNode data, final ImmutableMap<String, Object> headers) {
this(context, data, WriterParameters.EMPTY, headers);
}
- public InstanceIdentifierContext<? extends SchemaNode> getInstanceIdentifierContext() {
+ public InstanceIdentifierContext getInstanceIdentifierContext() {
return context;
}
return;
}
- @SuppressWarnings("unchecked")
- final InstanceIdentifierContext<SchemaNode> identifierCtx =
- (InstanceIdentifierContext<SchemaNode>) context.getInstanceIdentifierContext();
+ final InstanceIdentifierContext identifierCtx = context.getInstanceIdentifierContext();
try (JsonWriter jsonWriter = createJsonWriter(entityStream, context.getWriterParameters().isPrettyPrint())) {
jsonWriter.beginObject();
}
}
- private static void writeNormalizedNode(final JsonWriter jsonWriter,
- final InstanceIdentifierContext<SchemaNode> context, NormalizedNode data,
- final @Nullable Integer depth) throws IOException {
+ private static void writeNormalizedNode(final JsonWriter jsonWriter, final InstanceIdentifierContext context,
+ // Note: mutable argument
+ NormalizedNode data, final @Nullable Integer depth) throws IOException {
SchemaPath path = context.getSchemaNode().getPath();
final RestconfNormalizedNodeWriter nnWriter;
if (SchemaPath.ROOT.equals(path)) {
}
private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(
- final InstanceIdentifierContext<SchemaNode> context, final SchemaPath path, final JsonWriter jsonWriter,
+ final InstanceIdentifierContext context, final SchemaPath path, final JsonWriter jsonWriter,
final @Nullable Integer depth) {
final SchemaNode schema = context.getSchemaNode();
return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8));
}
- private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
+ private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext context) {
// TODO: Performance: Cache JSON Codec factory and schema context
return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(context.getSchemaContext());
}
for (final Entry<String, Object> entry : context.getNewHeaders().entrySet()) {
httpHeaders.add(entry.getKey(), entry.getValue());
}
- final InstanceIdentifierContext<?> pathContext = context.getInstanceIdentifierContext();
+ final InstanceIdentifierContext pathContext = context.getInstanceIdentifierContext();
if (context.getData() == null) {
return;
}
}
private static void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath schemaPath,
- final InstanceIdentifierContext<?> pathContext, NormalizedNode data, final @Nullable Integer depth)
+ final InstanceIdentifierContext pathContext, NormalizedNode data, final @Nullable Integer depth)
throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
final EffectiveModelContext schemaCtx = pathContext.getSchemaContext();
}
errContBuild.withChild(listErorsBuilder.build());
- final NormalizedNodeContext errContext = new NormalizedNodeContext(new InstanceIdentifierContext<>(null,
+ final NormalizedNodeContext errContext = new NormalizedNodeContext(new InstanceIdentifierContext(null,
(DataSchemaNode) errorsSchemaNode, null, controllerContext.getGlobalSchema()), errContBuild.build());
Object responseBody;
final DataNodeContainer errorsSchemaNode) {
final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
NormalizedNode data = errorsNode.getData();
- final InstanceIdentifierContext<?> context = errorsNode.getInstanceIdentifierContext();
+ final InstanceIdentifierContext context = errorsNode.getInstanceIdentifierContext();
final DataSchemaNode schema = (DataSchemaNode) context.getSchemaNode();
SchemaPath path = context.getSchemaNode().getPath();
private static Object toXMLResponseBody(final NormalizedNodeContext errorsNode,
final DataNodeContainer errorsSchemaNode) {
- final InstanceIdentifierContext<?> pathContext = errorsNode.getInstanceIdentifierContext();
+ final InstanceIdentifierContext pathContext = errorsNode.getInstanceIdentifierContext();
final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
final XMLStreamWriter xmlWriter;
private NormalizedNodeContext readFrom(final InputStream entityStream) throws IOException, SAXException,
XMLStreamException, ParserConfigurationException, URISyntaxException {
- final InstanceIdentifierContext<?> path = getInstanceIdentifierContext();
+ final InstanceIdentifierContext path = getInstanceIdentifierContext();
final Optional<InputStream> nonEmptyInputStreamOptional = RestUtil.isInputStreamEmpty(entityStream);
if (nonEmptyInputStreamOptional.isEmpty()) {
// represent empty nopayload input
return parse(path, doc);
}
- private NormalizedNodeContext parse(final InstanceIdentifierContext<?> pathContext,final Document doc)
+ private NormalizedNodeContext parse(final InstanceIdentifierContext pathContext,final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final SchemaNode schemaNodeContext = pathContext.getSchemaNode();
DataSchemaNode schemaNode;
final YangInstanceIdentifier fullIIToData = YangInstanceIdentifier.create(Iterables.concat(
pathContext.getInstanceIdentifier().getPathArguments(), iiToDataList));
- final InstanceIdentifierContext<? extends SchemaNode> outIIContext = new InstanceIdentifierContext<>(
+ final InstanceIdentifierContext outIIContext = new InstanceIdentifierContext(
fullIIToData, pathContext.getSchemaNode(), pathContext.getMountPoint(), pathContext.getSchemaContext());
return new NormalizedNodeContext(outIIContext, parsed);
throws WebApplicationException {
try {
- final InstanceIdentifierContext<?> path = getInstanceIdentifierContext();
+ final InstanceIdentifierContext path = getInstanceIdentifierContext();
final Optional<InputStream> nonEmptyInputStreamOptional = RestUtil.isInputStreamEmpty(entityStream);
if (nonEmptyInputStreamOptional.isEmpty()) {
// represent empty nopayload input
}
}
- private static PatchContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc)
+ private static PatchContext parse(final InstanceIdentifierContext pathContext, final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final List<PatchEntity> resultCollection = new ArrayList<>();
final String patchId = doc.getElementsByTagName("patch-id").item(0).getFirstChild().getNodeValue();
* @return read date
*/
public NormalizedNode readConfigurationData(final YangInstanceIdentifier path, final String withDefa) {
- try (DOMDataTreeReadTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
return readDataViaTransaction(tx, CONFIGURATION, path, withDefa);
}
}
* @return read data
*/
public NormalizedNode readOperationalData(final YangInstanceIdentifier path) {
- try (DOMDataTreeReadTransaction tx = this.domDataBroker.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
return readDataViaTransaction(tx, OPERATIONAL, path);
}
}
requireNonNull(payload);
isMounted.set(false);
- final DOMDataTreeReadWriteTransaction newReadWriteTransaction = this.domDataBroker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction newReadWriteTransaction = domDataBroker.newReadWriteTransaction();
final Status status = readDataViaTransaction(newReadWriteTransaction, CONFIGURATION, path) != null ? Status.OK
: Status.CREATED;
final FluentFuture<? extends CommitInfo> future = putDataViaTransaction(
final DOMDataTreeReadWriteTransaction patchTransaction;
if (mountPoint == null) {
schemaContext = patchContext.getInstanceIdentifierContext().getSchemaContext();
- patchTransaction = this.domDataBroker.newReadWriteTransaction();
+ patchTransaction = domDataBroker.newReadWriteTransaction();
} else {
schemaContext = modelContext(mountPoint);
final NormalizedNode payload, final String insert, final String point) {
isMounted.set(false);
FluentFuture<? extends CommitInfo> future =
- postDataViaTransaction(this.domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload,
+ postDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload,
globalSchema, insert, point);
isMounted.remove();
return future;
// DELETE configuration
public FluentFuture<? extends CommitInfo> commitConfigurationDataDelete(final YangInstanceIdentifier path) {
- return deleteDataViaTransaction(this.domDataBroker.newReadWriteTransaction(), CONFIGURATION, path);
+ return deleteDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path);
}
public FluentFuture<? extends CommitInfo> commitConfigurationDataDelete(
// RPC
public ListenableFuture<? extends DOMRpcResult> invokeRpc(final @NonNull QName type,
final @NonNull NormalizedNode input) {
- if (this.rpcService == null) {
+ if (rpcService == null) {
throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
}
LOG.trace("Invoke RPC {} with input: {}", type, input);
- return this.rpcService.invokeRpc(type, input);
+ return rpcService.invokeRpc(type, input);
}
public void registerToListenDataChanges(final LogicalDatastoreType datastore, final Scope scope,
}
final YangInstanceIdentifier path = listener.getPath();
- DOMDataTreeChangeService changeService = this.domDataBroker.getExtensions()
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
if (changeService == null) {
throw new UnsupportedOperationException("DOMDataBroker does not support the DOMDataTreeChangeService"
- + this.domDataBroker);
+ + domDataBroker);
}
DOMDataTreeIdentifier root = new DOMDataTreeIdentifier(datastore, path);
ListenerRegistration<ListenerAdapter> registration =
final SchemaContext schemaContext, final String point, final UserLeafSetNode<?> readLeafList,
final boolean before) {
rwTransaction.delete(datastore, path.getParent().getParent());
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext.toInstanceIdentifier(point);
+ final InstanceIdentifierContext instanceIdentifier = controllerContext.toInstanceIdentifier(point);
int lastItemPosition = 0;
for (final LeafSetEntryNode<?> nodeChild : readLeafList.body()) {
if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
final YangInstanceIdentifier path, final NormalizedNode payload, final SchemaContext schemaContext,
final String point, final MapNode readList, final boolean before) {
rwTransaction.delete(datastore, path.getParent().getParent());
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext.toInstanceIdentifier(point);
+ final InstanceIdentifierContext instanceIdentifier = controllerContext.toInstanceIdentifier(point);
int lastItemPosition = 0;
for (final MapEntryNode mapEntryNode : readList.body()) {
if (mapEntryNode.getIdentifier()
final SchemaContext schemaContext, final String point, final UserLeafSetNode<?> readLeafList,
final boolean before) {
tx.delete(datastore, path.getParent());
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext.toInstanceIdentifier(point);
+ final InstanceIdentifierContext instanceIdentifier = controllerContext.toInstanceIdentifier(point);
int index1 = 0;
for (final LeafSetEntryNode<?> nodeChild : readLeafList.body()) {
if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
final YangInstanceIdentifier path, final NormalizedNode payload, final SchemaContext schemaContext,
final String point, final UserMapNode readList, final boolean before) {
tx.delete(datastore, path.getParent());
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext.toInstanceIdentifier(point);
+ final InstanceIdentifierContext instanceIdentifier = controllerContext.toInstanceIdentifier(point);
int index1 = 0;
for (final MapEntryNode mapEntryNode : readList.body()) {
if (mapEntryNode.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
}
final SchemaPath path = listener.getSchemaPath();
- final ListenerRegistration<DOMNotificationListener> registration = this.domNotification
+ final ListenerRegistration<DOMNotificationListener> registration = domNotification
.registerNotificationListener(listener, Absolute.of(ImmutableList.copyOf(path.getPathFromRoot())));
listener.setRegistration(registration);
PatchStatusContext status;
public PatchStatusContext getStatus() {
- return this.status;
+ return status;
}
public void setStatus(final PatchStatusContext status) {
onModelContextUpdated(schemas);
}
- public InstanceIdentifierContext<?> toInstanceIdentifier(final String restconfInstance) {
+ public InstanceIdentifierContext toInstanceIdentifier(final String restconfInstance) {
return toIdentifier(restconfInstance, false);
}
return globalSchema;
}
- public InstanceIdentifierContext<?> toMountPointIdentifier(final String restconfInstance) {
+ public InstanceIdentifierContext toMountPointIdentifier(final String restconfInstance) {
return toIdentifier(restconfInstance, true);
}
- private InstanceIdentifierContext<?> toIdentifier(final String restconfInstance,
- final boolean toMountPointIdentifier) {
+ private InstanceIdentifierContext toIdentifier(final String restconfInstance,
+ final boolean toMountPointIdentifier) {
checkPreconditions();
if (restconfInstance == null) {
- return new InstanceIdentifierContext<>(YangInstanceIdentifier.empty(), globalSchema, null,
- globalSchema);
+ return new InstanceIdentifierContext(YangInstanceIdentifier.empty(), globalSchema, null, globalSchema);
}
final List<String> pathArgs = urlPathArgsDecode(SLASH_SPLITTER.split(restconfInstance));
ErrorType.PROTOCOL, ErrorTag.UNKNOWN_ELEMENT);
}
- final InstanceIdentifierContext<?> iiWithSchemaNode =
+ final InstanceIdentifierContext iiWithSchemaNode =
collectPathArguments(builder, pathArgs, latestModule.iterator().next(), null, toMountPointIdentifier);
if (iiWithSchemaNode == null) {
}
@SuppressFBWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE", justification = "Unrecognised NullableDecl")
- private InstanceIdentifierContext<?> collectPathArguments(final InstanceIdentifierBuilder builder,
+ private InstanceIdentifierContext collectPathArguments(final InstanceIdentifierBuilder builder,
final List<String> strings, final DataNodeContainer parentNode, final DOMMountPoint mountPoint,
final boolean returnJustMountPoint) {
requireNonNull(strings);
}
if (returnJustMountPoint || strings.size() == 1) {
- return new InstanceIdentifierContext<>(YangInstanceIdentifier.empty(), mountPointSchema, mount,
+ return new InstanceIdentifierContext(YangInstanceIdentifier.empty(), mountPointSchema, mount,
mountPointSchema);
}
rpc = getRpcDefinition(module, rpcName);
}
if (rpc != null) {
- return new InstanceIdentifierContext<>(builder.build(), rpc, mountPoint,
+ return new InstanceIdentifierContext(builder.build(), rpc, mountPoint,
mountPoint != null ? getModelContext(mountPoint) : globalSchema);
}
}
mountPoint != null ? getModelContext(mountPoint) : globalSchema);
}
- private static InstanceIdentifierContext<?> createContext(final YangInstanceIdentifier instance,
+ private static InstanceIdentifierContext createContext(final YangInstanceIdentifier instance,
final DataSchemaNode dataSchemaNode, final DOMMountPoint mountPoint,
final EffectiveModelContext schemaContext) {
final YangInstanceIdentifier instanceIdentifier = new DataNormalizer(schemaContext).toNormalized(instance);
- return new InstanceIdentifierContext<>(instanceIdentifier, dataSchemaNode, mountPoint, schemaContext);
+ return new InstanceIdentifierContext(instanceIdentifier, dataSchemaNode, mountPoint, schemaContext);
}
public static DataSchemaNode findInstanceDataChildByNameAndNamespace(final DataNodeContainer container,
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));
}
throw new RestconfDocumentedException(errMsg, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- final InstanceIdentifierContext<?> mountPointIdentifier =
+ final InstanceIdentifierContext mountPointIdentifier =
controllerContext.toMountPointIdentifier(identifier);
final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint();
final MapNode mountPointModulesMap = makeModuleMapNode(controllerContext.getAllModules(mountPoint));
moduleContainerBuilder.withChild(mountPointModulesMap);
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, modulesSchemaNode, mountPoint,
+ new InstanceIdentifierContext(null, modulesSchemaNode, mountPoint,
controllerContext.getGlobalSchema()),
moduleContainerBuilder.build(), QueryParametersParser.parseWriterParameters(uriInfo));
}
DOMMountPoint mountPoint = null;
final EffectiveModelContext schemaContext;
if (identifier.contains(ControllerContext.MOUNT)) {
- final InstanceIdentifierContext<?> mountPointIdentifier =
+ final InstanceIdentifierContext mountPointIdentifier =
controllerContext.toMountPointIdentifier(identifier);
mountPoint = mountPointIdentifier.getMountPoint();
module = controllerContext.findModuleByNameAndRevision(mountPoint, nameRev.getKey(),
checkState(moduleSchemaNode instanceof ListSchemaNode);
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, moduleSchemaNode, mountPoint, schemaContext), moduleMap,
+ new InstanceIdentifierContext(null, moduleSchemaNode, mountPoint, schemaContext), moduleMap,
QueryParametersParser.parseWriterParameters(uriInfo));
}
streamsContainerBuilder.withChild(listStreamsBuilder.build());
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, streamsContainerSchemaNode, null, schemaContext),
+ new InstanceIdentifierContext(null, streamsContainerSchemaNode, null, schemaContext),
streamsContainerBuilder.build(), QueryParametersParser.parseWriterParameters(uriInfo));
}
throw new RestconfDocumentedException(errMsg, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- final InstanceIdentifierContext<?> mountPointIdentifier =
- controllerContext.toMountPointIdentifier(identifier);
+ 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());
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));
}
}
final EffectiveModelContext schemaContext;
if (identifier.contains(ControllerContext.MOUNT)) {
// mounted RPC call - look up mount instance.
- final InstanceIdentifierContext<?> mountPointId = controllerContext.toMountPointIdentifier(identifier);
+ final InstanceIdentifierContext mountPointId = controllerContext.toMountPointIdentifier(identifier);
mountPoint = mountPointId.getMountPoint();
schemaContext = modelContext(mountPoint);
final int startOfRemoteRpcName =
//
// 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,
+ return new NormalizedNodeContext(new InstanceIdentifierContext(null, rpc, mountPoint, schemaContext), result,
QueryParametersParser.parseWriterParameters(uriInfo));
}
}
}
- final InstanceIdentifierContext<?> iiWithData = controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
NormalizedNode data = null;
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
@Override
public NormalizedNodeContext readOperationalData(final String identifier, final UriInfo uriInfo) {
- final InstanceIdentifierContext<?> iiWithData = controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
NormalizedNode data = null;
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
requireNonNull(identifier);
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iiWithData = payload.getInstanceIdentifierContext();
validateInput(iiWithData.getSchemaNode(), payload);
validateTopLevelNodeName(payload, iiWithData.getInstanceIdentifier());
*/
private static void validateListKeysEqualityInPayloadAndUri(final NormalizedNodeContext payload) {
checkArgument(payload != null);
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iiWithData = payload.getInstanceIdentifierContext();
final PathArgument lastPathArgument = iiWithData.getInstanceIdentifier().getLastPathArgument();
final SchemaNode schemaNode = iiWithData.getSchemaNode();
final NormalizedNode data = payload.getData();
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;
@Override
public Response deleteConfigurationData(final String identifier) {
- final InstanceIdentifierContext<?> iiWithData = controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
final DOMMountPoint mountPoint = iiWithData.getMountPoint();
final YangInstanceIdentifier normalizedII = iiWithData.getInstanceIdentifier();
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(
* @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 EffectiveModelContext schemaCtx = controllerContext.getGlobalSchema();
final DataSchemaNode location = ((ContainerSchemaNode) schemaCtx
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);
}
/**
@SuppressWarnings("checkstyle:IllegalCatch")
public static NormalizedNodeContext loadNormalizedContextFromXmlFile(final String pathToInputFile,
final String uri, final ControllerContext controllerContext) {
- final InstanceIdentifierContext<?> iiContext = controllerContext.toInstanceIdentifier(uri);
+ final InstanceIdentifierContext iiContext = controllerContext.toInstanceIdentifier(uri);
final InputStream inputStream = TestJsonBodyWriter.class.getResourceAsStream(pathToInputFile);
try {
final Document doc = UntrustedXML.newDocumentBuilder().parse(inputStream);
return null;
}
- private static NormalizedNode parse(final InstanceIdentifierContext<?> iiContext, final Document doc)
+ private static NormalizedNode parse(final InstanceIdentifierContext iiContext, final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final SchemaNode schemaNodeContext = iiContext.getSchemaNode();
DataSchemaNode schemaNode = null;
*/
package org.opendaylight.controller.sal.rest.impl;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
final EffectiveModelContext schemaContext =
YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/instanceidentifier"));
ControllerContext controllerContext = TestRestconfUtils.newControllerContext(schemaContext);
- final InstanceIdentifierContext<?> instanceIdentifier =
+ final InstanceIdentifierContext instanceIdentifier =
controllerContext.toInstanceIdentifier(
"/iid-value-module:cont-iid/iid-list/%2Fiid-value-module%3Acont-iid%2Fiid-value-module%3A"
+ "values-iid%5Biid-value-module:value-iid='value'%5D");
final YangInstanceIdentifier yiD = instanceIdentifier.getInstanceIdentifier();
- Assert.assertNotNull(yiD);
+ assertNotNull(yiD);
final PathArgument lastPathArgument = yiD.getLastPathArgument();
- Assert.assertTrue(lastPathArgument.getNodeType().getNamespace().toString().equals("iid:value:module"));
- Assert.assertTrue(lastPathArgument.getNodeType().getLocalName().equals("iid-list"));
+ assertTrue(lastPathArgument.getNodeType().getNamespace().toString().equals("iid:value:module"));
+ assertTrue(lastPathArgument.getNodeType().getLocalName().equals("iid-list"));
final NodeIdentifierWithPredicates list = (NodeIdentifierWithPredicates) lastPathArgument;
final YangInstanceIdentifier value = (YangInstanceIdentifier) list.getValue(
QName.create(lastPathArgument.getNodeType(), "iid-leaf"));
final PathArgument lastPathArgumentOfValue = value.getLastPathArgument();
- Assert.assertTrue(lastPathArgumentOfValue.getNodeType().getNamespace().toString().equals("iid:value:module"));
- Assert.assertTrue(lastPathArgumentOfValue.getNodeType().getLocalName().equals("values-iid"));
+ assertTrue(lastPathArgumentOfValue.getNodeType().getNamespace().toString().equals("iid:value:module"));
+ assertTrue(lastPathArgumentOfValue.getNodeType().getLocalName().equals("values-iid"));
final NodeIdentifierWithPredicates valueList = (NodeIdentifierWithPredicates) lastPathArgumentOfValue;
final String valueIid = (String) valueList.getValue(
QName.create(lastPathArgumentOfValue.getNodeType(), "value-iid"));
- Assert.assertEquals("value", valueIid);
+ assertEquals("value", valueIid);
}
}
testNodeContainer.withChild(leafKey2.build());
}
- final NormalizedNodeContext testCompositeContext = new NormalizedNodeContext(new InstanceIdentifierContext<>(
+ final NormalizedNodeContext testCompositeContext = new NormalizedNodeContext(new InstanceIdentifierContext(
null, testNodeSchemaNode, null, schemaContextTestModule), testNodeContainer.build());
final UriInfo uriInfo = Mockito.mock(UriInfo.class);
dataCont.withChild(dataCont1.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, schemaCont,
+ new InstanceIdentifierContext(null, schemaCont,
null, schemaContext), dataCont.build());
return testNormalizedNodeContext;
dataCont1.withChild(dataLst11.build());
dataCont.withChild(dataCont1.build());
- return new NormalizedNodeContext(new InstanceIdentifierContext<>(null, schemaCont, null, schemaContext),
+ return new NormalizedNodeContext(new InstanceIdentifierContext(null, schemaCont, null, schemaContext),
dataCont.build());
}
contData.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) schemaLf).withValue(object).build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
contData.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) schemaLf).withValue("true").build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
contData.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) schemaLf).withValue("value").build());
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext(null, contSchema, null, schemaContext), contData.build());
}
private static NormalizedNodeContext prepareIdrefData(final String prefix, final boolean valueAsQName) {
contData.withChild(cont1Data.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
dataContainerNodeAttrBuilder.withChild(dataChoice.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null,
- contSchemaNode, null, schemaContext),
+ new InstanceIdentifierContext(null, contSchemaNode, null, schemaContext),
dataContainerNodeAttrBuilder.build());
return testNormalizedNodeContext;
dataContSchemaContNode.withChild(modul2.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, schemaContext, null, schemaContext),
+ new InstanceIdentifierContext(null, schemaContext, null, schemaContext),
dataContSchemaContNode.build());
return testNormalizedNodeContext;
private BrokerFacade brokerFacade;
private final NormalizedNode dummyNode = createDummyNode("test:module", "2014-01-09", "interfaces");
- private final FluentFuture<Optional<NormalizedNode>> dummyNodeInFuture = wrapDummyNode(this.dummyNode);
+ private final FluentFuture<Optional<NormalizedNode>> dummyNodeInFuture = wrapDummyNode(dummyNode);
private final QName qname = TestUtils.buildQName("interfaces","test:module", "2014-01-09");
- private final YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(this.qname).build();
+ private final YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).build();
private ControllerContext controllerContext;
@Before
brokerFacade = BrokerFacade.newInstance(mockRpcService, domDataBroker, domNotification, controllerContext);
- when(this.domDataBroker.newReadOnlyTransaction()).thenReturn(this.readTransaction);
- when(this.domDataBroker.newReadWriteTransaction()).thenReturn(this.rwTransaction);
- when(this.domDataBroker.getExtensions()).thenReturn(ImmutableClassToInstanceMap.of(
+ when(domDataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
+ when(domDataBroker.newReadWriteTransaction()).thenReturn(rwTransaction);
+ when(domDataBroker.getExtensions()).thenReturn(ImmutableClassToInstanceMap.of(
DOMDataTreeChangeService.class, Mockito.mock(DOMDataTreeChangeService.class)));
}
@Test
public void testReadConfigurationData() {
- when(this.readTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
- this.dummyNodeInFuture);
+ when(readTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
+ dummyNodeInFuture);
- final NormalizedNode actualNode = this.brokerFacade.readConfigurationData(this.instanceID);
+ final NormalizedNode actualNode = brokerFacade.readConfigurationData(instanceID);
- assertSame("readConfigurationData", this.dummyNode, actualNode);
+ assertSame("readConfigurationData", dummyNode, actualNode);
}
@Test
public void testReadOperationalData() {
- when(this.readTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
- this.dummyNodeInFuture);
+ when(readTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
+ dummyNodeInFuture);
- final NormalizedNode actualNode = this.brokerFacade.readOperationalData(this.instanceID);
+ final NormalizedNode actualNode = brokerFacade.readOperationalData(instanceID);
- assertSame("readOperationalData", this.dummyNode, actualNode);
+ assertSame("readOperationalData", dummyNode, actualNode);
}
@Test
.when(readTransaction).read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class));
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> brokerFacade.readConfigurationData(this.instanceID, "explicit"));
+ () -> brokerFacade.readConfigurationData(instanceID, "explicit"));
final List<RestconfError> errors = ex.getErrors();
assertEquals(1, errors.size());
assertEquals("getErrorTag", ErrorTags.RESOURCE_DENIED_TRANSPORT, errors.get(0).getErrorTag());
@Test
public void testInvokeRpc() throws Exception {
final DOMRpcResult expResult = mock(DOMRpcResult.class);
- doReturn(immediateFluentFuture(expResult)).when(this.mockRpcService).invokeRpc(this.qname, this.dummyNode);
+ doReturn(immediateFluentFuture(expResult)).when(mockRpcService).invokeRpc(qname, dummyNode);
- final ListenableFuture<? extends DOMRpcResult> actualFuture = this.brokerFacade.invokeRpc(this.qname,
- this.dummyNode);
+ final ListenableFuture<? extends DOMRpcResult> actualFuture = brokerFacade.invokeRpc(qname,
+ dummyNode);
assertNotNull("Future is null", actualFuture);
final DOMRpcResult actualResult = actualFuture.get();
assertSame("invokeRpc", expResult, actualResult);
@Test
public void testCommitConfigurationDataPut() throws Exception {
- doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTransaction).commit();
- doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(this.rwTransaction)
- .read(LogicalDatastoreType.CONFIGURATION, this.instanceID);
+ doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(rwTransaction)
+ .read(LogicalDatastoreType.CONFIGURATION, instanceID);
- final PutResult result = this.brokerFacade.commitConfigurationDataPut(mock(EffectiveModelContext.class),
- this.instanceID, this.dummyNode, null, null);
+ final PutResult result = brokerFacade.commitConfigurationDataPut(mock(EffectiveModelContext.class),
+ instanceID, dummyNode, null, null);
assertSame("commitConfigurationDataPut", CommitInfo.emptyFluentFuture(), result.getFutureOfPutData());
- final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
- inOrder.verify(this.domDataBroker).newReadWriteTransaction();
- inOrder.verify(this.rwTransaction).put(LogicalDatastoreType.CONFIGURATION, this.instanceID, this.dummyNode);
- inOrder.verify(this.rwTransaction).commit();
+ final InOrder inOrder = inOrder(domDataBroker, rwTransaction);
+ inOrder.verify(domDataBroker).newReadWriteTransaction();
+ inOrder.verify(rwTransaction).put(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode);
+ inOrder.verify(rwTransaction).commit();
}
@Test
public void testCommitConfigurationDataPost() {
- when(this.rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, this.instanceID))
+ when(rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, instanceID))
.thenReturn(wrapExistence(false));
- doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTransaction).commit();
- final FluentFuture<? extends CommitInfo> actualFuture = this.brokerFacade
- .commitConfigurationDataPost(mock(EffectiveModelContext.class), this.instanceID, this.dummyNode, null,
+ final FluentFuture<? extends CommitInfo> actualFuture = brokerFacade
+ .commitConfigurationDataPost(mock(EffectiveModelContext.class), instanceID, dummyNode, null,
null);
assertSame("commitConfigurationDataPost", CommitInfo.emptyFluentFuture(), actualFuture);
- final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
- inOrder.verify(this.domDataBroker).newReadWriteTransaction();
- inOrder.verify(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.instanceID);
- inOrder.verify(this.rwTransaction).put(LogicalDatastoreType.CONFIGURATION, this.instanceID, this.dummyNode);
- inOrder.verify(this.rwTransaction).commit();
+ final InOrder inOrder = inOrder(domDataBroker, rwTransaction);
+ inOrder.verify(domDataBroker).newReadWriteTransaction();
+ inOrder.verify(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, instanceID);
+ inOrder.verify(rwTransaction).put(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode);
+ inOrder.verify(rwTransaction).commit();
}
@Test(expected = RestconfDocumentedException.class)
public void testCommitConfigurationDataPostAlreadyExists() {
- when(this.rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class)))
+ when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class)))
.thenReturn(immediateTrueFluentFuture());
try {
// Schema context is only necessary for ensuring parent structure
- this.brokerFacade.commitConfigurationDataPost((EffectiveModelContext) null, this.instanceID, this.dummyNode,
+ brokerFacade.commitConfigurationDataPost((EffectiveModelContext) null, instanceID, dummyNode,
null, null);
} catch (final RestconfDocumentedException e) {
assertEquals("getErrorTag", ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
prepareDataForDelete(true);
// expected result
- doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTransaction).commit();
// test
- final FluentFuture<? extends CommitInfo> actualFuture = this.brokerFacade
- .commitConfigurationDataDelete(this.instanceID);
+ final FluentFuture<? extends CommitInfo> actualFuture = brokerFacade
+ .commitConfigurationDataDelete(instanceID);
// verify result and interactions
assertSame("commitConfigurationDataDelete", CommitInfo.emptyFluentFuture(), actualFuture);
// check exists, delete, submit
- final InOrder inOrder = inOrder(this.domDataBroker, this.rwTransaction);
- inOrder.verify(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, this.instanceID);
- inOrder.verify(this.rwTransaction).delete(LogicalDatastoreType.CONFIGURATION, this.instanceID);
- inOrder.verify(this.rwTransaction).commit();
+ final InOrder inOrder = inOrder(domDataBroker, rwTransaction);
+ inOrder.verify(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, instanceID);
+ inOrder.verify(rwTransaction).delete(LogicalDatastoreType.CONFIGURATION, instanceID);
+ inOrder.verify(rwTransaction).commit();
}
/**
// try to delete and expect DATA_MISSING error
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> brokerFacade.commitConfigurationDataDelete(this.instanceID));
+ () -> brokerFacade.commitConfigurationDataDelete(instanceID));
final List<RestconfError> errors = ex.getErrors();
assertEquals(1, errors.size());
assertEquals(ErrorType.PROTOCOL, errors.get(0).getErrorType());
* @param assumeDataExists boolean to assume if data exists
*/
private void prepareDataForDelete(final boolean assumeDataExists) {
- when(this.rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, this.instanceID))
+ when(rwTransaction.exists(LogicalDatastoreType.CONFIGURATION, instanceID))
.thenReturn(immediateBooleanFluentFuture(assumeDataExists));
}
@Test
public void testRegisterToListenDataChanges() {
- final ListenerAdapter listener = Notificator.createListener(this.instanceID, "stream",
+ final ListenerAdapter listener = Notificator.createListener(instanceID, "stream",
NotificationOutputType.XML, controllerContext);
@SuppressWarnings("unchecked")
final ListenerRegistration<ListenerAdapter> mockRegistration = mock(ListenerRegistration.class);
- DOMDataTreeChangeService changeService = this.domDataBroker.getExtensions()
+ DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
- DOMDataTreeIdentifier loc = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, this.instanceID);
+ DOMDataTreeIdentifier loc = new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, instanceID);
when(changeService.registerDataTreeChangeListener(eq(loc), eq(listener))).thenReturn(mockRegistration);
- this.brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, Scope.BASE, listener);
+ brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, Scope.BASE, listener);
verify(changeService).registerDataTreeChangeListener(loc, listener);
assertEquals("isListening", true, listener.isListening());
- this.brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, Scope.BASE, listener);
+ brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, Scope.BASE, listener);
verifyNoMoreInteractions(changeService);
}
// mock registration
final ListenerRegistration<NotificationListenerAdapter> registration = mock(ListenerRegistration.class);
- when(this.domNotification.registerNotificationListener(listener,
+ when(domNotification.registerNotificationListener(listener,
Absolute.of(ImmutableList.copyOf(listener.getSchemaPath().getPathFromRoot()))))
.thenReturn(registration);
// test to register listener for the first time
- this.brokerFacade.registerToListenNotification(listener);
+ brokerFacade.registerToListenNotification(listener);
assertEquals("Registration was not successful", true, listener.isListening());
// try to register for the second time
- this.brokerFacade.registerToListenNotification(listener);
+ brokerFacade.registerToListenNotification(listener);
assertEquals("Registration was not successful", true, listener.isListening());
// registrations should be invoked only once
- verify(this.domNotification, times(1)).registerNotificationListener(listener,
+ verify(domNotification, times(1)).registerNotificationListener(listener,
Absolute.of(ImmutableList.copyOf(listener.getSchemaPath().getPathFromRoot())));
final DOMTransactionChain transactionChain = mock(DOMTransactionChain.class);
@Test
public void testPatchConfigurationDataWithinTransactionServer() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
when(patchContext.getData()).thenReturn(new ArrayList<>());
doReturn(identifierContext).when(patchContext).getInstanceIdentifierContext();
// no mount point
when(identifierContext.getMountPoint()).thenReturn(null);
- doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTransaction).commit();
- final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
+ final PatchStatusContext status = brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
// assert success
assertTrue("Patch operation should be successful on server", status.isOk());
@Test
public void testPatchConfigurationDataWithinTransactionMount() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
final DOMMountPoint mountPoint = mock(DOMMountPoint.class);
final DOMDataBroker mountDataBroker = mock(DOMDataBroker.class);
final DOMDataTreeReadWriteTransaction transaction = mock(DOMDataTreeReadWriteTransaction.class);
when(mountDataBroker.newReadWriteTransaction()).thenReturn(transaction);
doReturn(CommitInfo.emptyFluentFuture()).when(transaction).commit();
- final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
+ final PatchStatusContext status = brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
// assert success
assertTrue("Patch operation should be successful on mounted device", status.isOk());
@Test
public void testPatchConfigurationDataWithinTransactionMountFail() throws Exception {
final PatchContext patchContext = mock(PatchContext.class);
- final InstanceIdentifierContext<?> identifierContext = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext identifierContext = mock(InstanceIdentifierContext.class);
final DOMMountPoint mountPoint = mock(DOMMountPoint.class);
final DOMDataBroker mountDataBroker = mock(DOMDataBroker.class);
final DOMDataTreeReadWriteTransaction transaction = mock(DOMDataTreeReadWriteTransaction.class);
when(mountPoint.getService(DOMSchemaService.class)).thenReturn(Optional.empty());
- final PatchStatusContext status = this.brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
+ final PatchStatusContext status = brokerFacade.patchConfigurationDataWithinTransaction(patchContext);
// assert not successful operation with error
assertNotNull(status.getGlobalErrors());
final YangInstanceIdentifier node1IIexpected = YangInstanceIdentifier.of(CONT_QNAME)
.node(LST_WITH_LFREF_KEY_QNAME).node(NodeIdentifierWithPredicates.of(
LST_WITH_LFREF_KEY_QNAME, LFREF_KEY_QNAME, "node1"));
- final InstanceIdentifierContext<?> iiContext =
+ final InstanceIdentifierContext iiContext =
controllerContext.toInstanceIdentifier("leafref-module:cont/lst-with-lfref-key/node1");
iiContext.getInstanceIdentifier();
assertEquals(node1IIexpected, iiContext.getInstanceIdentifier());
@Test
public void testIdentityRefFromExternalModule() throws FileNotFoundException, ReactorException {
- final InstanceIdentifierContext<?> ctx = controllerContext.toInstanceIdentifier(
+ final InstanceIdentifierContext ctx = controllerContext.toInstanceIdentifier(
"simple-nodes:users/yang-ext:mount/test-module:modules/module/test-module:module-type/name");
final Map<QName, Object> keyValues = new HashMap<>();
public NormalizedNodeContext getData(@Encoded @PathParam("identifier") final String identifier,
@Context final UriInfo uriInfo) {
- final InstanceIdentifierContext<?> iiWithData = controllerContext.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiWithData = controllerContext.toInstanceIdentifier(identifier);
NormalizedNode data = null;
if (identifier.equals("nested-module:depth1-cont/depth2-cont1")) {
LOG.info("Instance identifier of payload: {}.",
payload.getInstanceIdentifierContext().getInstanceIdentifier());
LOG.info("Data of payload: {}.", payload.getData());
- CutDataToCorrectDepthTest.this.globalPayload = payload.getData();
+ globalPayload = payload.getData();
}
@PUT
}
private void verifyResponse(final NormalizedNode nodeData) throws WebApplicationException, IOException {
- assertNotNull(this.globalPayload);
- assertEquals(this.globalPayload, nodeData);
- this.globalPayload = null;
+ assertNotNull(globalPayload);
+ assertEquals(globalPayload, nodeData);
+ globalPayload = null;
}
@Override
container.withChild(contNode.build());
return new NormalizedNodeContext(
- new InstanceIdentifierContext<>(null, rpcInputSchemaNode, null, schema), container.build());
+ new InstanceIdentifierContext(null, rpcInputSchemaNode, null, schema), container.build());
}
@Test
.when(brokerFacade).invokeRpc(eq(qname), any());
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> this.restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
+ () -> restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
verifyRestconfDocumentedException(ex, 0, ErrorType.APPLICATION, ErrorTag.OPERATION_NOT_SUPPORTED,
Optional.empty(), Optional.empty());
}
doReturn(immediateFluentFuture(result)).when(brokerFacade).invokeRpc(eq(path), any());
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> this.restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
+ () -> restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
// We are performing pass-through here of error-tag, hence the tag remains as specified, but we want to make
// sure the HTTP status remains the same as
doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(qname), any());
- final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo);
+ final NormalizedNodeContext output = restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo);
assertNotNull(output);
assertEquals(null, output.getData());
// additional validation in the fact that the restconfImpl does not
doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(qname), any());
WebApplicationException exceptionToBeThrown = assertThrows(WebApplicationException.class,
- () -> this.restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
+ () -> restconfImpl.invokeRpc("toaster:cancel-toast", null, uriInfo));
assertEquals(Response.Status.NO_CONTENT.getStatusCode(), exceptionToBeThrown.getResponse().getStatus());
}
@Test
public void testInvokeRpcMethodWithBadMethodName() {
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> this.restconfImpl.invokeRpc("toaster:bad-method", null, uriInfo));
+ () -> restconfImpl.invokeRpc("toaster:bad-method", null, uriInfo));
verifyRestconfDocumentedException(ex, 0, ErrorType.RPC, ErrorTag.UNKNOWN_ELEMENT,
Optional.empty(), Optional.empty());
}
SchemaAwareBuilders.containerBuilder(rpcInputSchemaNode);
final NormalizedNodeContext payload =
- new NormalizedNodeContext(new InstanceIdentifierContext<>(null, rpcInputSchemaNode,
+ new NormalizedNodeContext(new InstanceIdentifierContext(null, rpcInputSchemaNode,
null, schemaContext), containerBuilder.build());
doReturn(immediateFluentFuture(expResult)).when(brokerFacade).invokeRpc(eq(path), any(NormalizedNode.class));
- final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:make-toast", payload, uriInfo);
+ final NormalizedNodeContext output = restconfImpl.invokeRpc("toaster:make-toast", payload, uriInfo);
assertNotNull(output);
assertEquals(null, output.getData());
// additional validation in the fact that the restconfImpl does not
@Test
public void testThrowExceptionWhenSlashInModuleName() {
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
- () -> this.restconfImpl.invokeRpc("toaster/slash", null, uriInfo));
+ () -> restconfImpl.invokeRpc("toaster/slash", null, uriInfo));
verifyRestconfDocumentedException(ex, 0, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE,
Optional.empty(), Optional.empty());
}
doReturn(immediateFluentFuture(result)).when(brokerFacade).invokeRpc(eq(rpcDef.getQName()), any());
- final NormalizedNodeContext output = this.restconfImpl.invokeRpc("toaster:testOutput", null, uriInfo);
+ final NormalizedNodeContext output = restconfImpl.invokeRpc("toaster:testOutput", null, uriInfo);
assertNotNull(output);
assertNotNull(output.getData());
assertSame(container, output.getData());
@Test
public void augmentedNodesInUri() {
- InstanceIdentifierContext<?> iiWithData =
+ InstanceIdentifierContext iiWithData =
controllerContext.toInstanceIdentifier("main:cont/augment-main-a:cont1");
assertEquals(XMLNamespace.of("ns:augment:main:a"), iiWithData.getSchemaNode().getQName().getNamespace());
iiWithData = controllerContext.toInstanceIdentifier("main:cont/augment-main-b:cont1");
@Before
public void init() {
- this.controllerCx = TestRestconfUtils.newControllerContext(schemaContext);
- this.restconfService = RestconfImpl.newInstance(brokerFacade, controllerCx);
+ controllerCx = TestRestconfUtils.newControllerContext(schemaContext);
+ restconfService = RestconfImpl.newInstance(brokerFacade, controllerCx);
}
@Test
public void testPutConfigData() {
final String identifier = "test-interface:interfaces/interface/key";
- final InstanceIdentifierContext<?> iiCx = this.controllerCx.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiCx = controllerCx.toInstanceIdentifier(identifier);
final MapEntryNode data = Mockito.mock(MapEntryNode.class);
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "interface");
final QName qNameKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "name");
final MultivaluedMap<String, String> value = Mockito.mock(MultivaluedMap.class);
Mockito.when(value.entrySet()).thenReturn(new HashSet<>());
Mockito.when(uriInfo.getQueryParameters()).thenReturn(value);
- this.restconfService.updateConfigurationData(identifier, payload, uriInfo);
+ restconfService.updateConfigurationData(identifier, payload, uriInfo);
}
@Test
public void testPutConfigDataCheckOnlyLastElement() {
final String identifier = "test-interface:interfaces/interface/key/sub-interface/subkey";
- final InstanceIdentifierContext<?> iiCx = this.controllerCx.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiCx = controllerCx.toInstanceIdentifier(identifier);
final MapEntryNode data = Mockito.mock(MapEntryNode.class);
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "sub-interface");
final QName qNameSubKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "sub-name");
final MultivaluedMap<String, String> value = Mockito.mock(MultivaluedMap.class);
Mockito.when(value.entrySet()).thenReturn(new HashSet<>());
Mockito.when(uriInfo.getQueryParameters()).thenReturn(value);
- this.restconfService.updateConfigurationData(identifier, payload, uriInfo);
+ restconfService.updateConfigurationData(identifier, payload, uriInfo);
}
@Test(expected = RestconfDocumentedException.class)
public void testPutConfigDataMissingUriKey() {
final String identifier = "test-interface:interfaces/interface";
- this.controllerCx.toInstanceIdentifier(identifier);
+ controllerCx.toInstanceIdentifier(identifier);
}
@Test(expected = RestconfDocumentedException.class)
public void testPutConfigDataDiferentKey() {
final String identifier = "test-interface:interfaces/interface/key";
- final InstanceIdentifierContext<?> iiCx = this.controllerCx.toInstanceIdentifier(identifier);
+ final InstanceIdentifierContext iiCx = controllerCx.toInstanceIdentifier(identifier);
final MapEntryNode data = Mockito.mock(MapEntryNode.class);
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "interface");
final QName qNameKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "name");
final MultivaluedMap<String, String> value = Mockito.mock(MultivaluedMap.class);
Mockito.when(value.entrySet()).thenReturn(new HashSet<>());
Mockito.when(uriInfo.getQueryParameters()).thenReturn(value);
- this.restconfService.updateConfigurationData(identifier, payload, uriInfo);
+ restconfService.updateConfigurationData(identifier, payload, uriInfo);
}
private void mockingBrokerPut(final YangInstanceIdentifier yii, final NormalizedNode data) {
final PutResult result = Mockito.mock(PutResult.class);
- Mockito.when(this.brokerFacade.commitConfigurationDataPut(schemaContext, yii, data, null, null))
+ Mockito.when(brokerFacade.commitConfigurationDataPut(schemaContext, yii, data, null, null))
.thenReturn(result);
Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(result).getFutureOfPutData();
Mockito.when(result.getStatus()).thenReturn(Status.OK);
doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters(anyBoolean());
final NormalizedNodeContext ctx = mock(NormalizedNodeContext.class);
- final InstanceIdentifierContext<?> iiCtx = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext iiCtx = mock(InstanceIdentifierContext.class);
doReturn(iiCtx).when(ctx).getInstanceIdentifierContext();
final SchemaNode schemaNode = mock(SchemaNode.class);
doReturn(schemaNode).when(iiCtx).getSchemaNode();
doReturn(Optional.of(rpcService)).when(mount).getService(DOMRpcService.class);
doReturn(immediateFluentFuture(mock(DOMRpcResult.class))).when(rpcService)
.invokeRpc(any(QName.class), any(NormalizedNode.class));
- this.restconfImpl.invokeRpc("randomId", ctx, uriInfo);
- this.restconfImpl.invokeRpc("ietf-netconf", ctx, uriInfo);
+ restconfImpl.invokeRpc("randomId", ctx, uriInfo);
+ restconfImpl.invokeRpc("ietf-netconf", ctx, uriInfo);
verify(rpcService, times(2)).invokeRpc(any(QName.class), any());
}
@Test
public void createNotificationStreamTest() {
final NormalizedNodeContext payload = mock(NormalizedNodeContext.class);
- final InstanceIdentifierContext<?> iiCtx = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext iiCtx = mock(InstanceIdentifierContext.class);
doReturn(iiCtx).when(payload).getInstanceIdentifierContext();
final SchemaNode schemaNode = mock(SchemaNode.class,
doReturn(children).when(normalizedNode).body();
// register notification
- final NormalizedNodeContext context = this.restconfImpl
+ final NormalizedNodeContext context = restconfImpl
.invokeRpc("sal-remote:create-notification-stream", payload, null);
assertNotNull(context);
}
*/
@Test
public void toStreamEntryNodeTest() {
- final Module restconfModule = this.controllerContext.getRestconfModule();
- final DataSchemaNode streamSchemaNode = this.controllerContext
+ final Module restconfModule = controllerContext.getRestconfModule();
+ final DataSchemaNode streamSchemaNode = controllerContext
.getRestconfModuleRestConfSchemaNode(restconfModule, Draft02.RestConfModule.STREAM_LIST_SCHEMA_NODE);
final ListSchemaNode listStreamSchemaNode = (ListSchemaNode) streamSchemaNode;
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamNodeValues =
when(uriInfo.getQueryParameters()).thenReturn(map);
// subscribe to stream and verify response
- final NormalizedNodeContext response = this.restconfImpl.subscribeToStream(identifier, uriInfo);
+ final NormalizedNodeContext response = restconfImpl.subscribeToStream(identifier, uriInfo);
// remove test notification stream
Notificator.removeAllListeners();
@Before
public void init() throws FileNotFoundException, ReactorException {
- this.mockedBrokerFacade = mock(BrokerFacade.class);
- this.controllerContext = TestRestconfUtils.newControllerContext(
+ mockedBrokerFacade = mock(BrokerFacade.class);
+ controllerContext = TestRestconfUtils.newControllerContext(
TestUtils.loadSchemaContext("/datastore-and-scope-specification"));
- this.restconf = RestconfImpl.newInstance(mockedBrokerFacade, controllerContext);
+ restconf = RestconfImpl.newInstance(mockedBrokerFacade, controllerContext);
}
@Test
final UriBuilder uriBuilder = UriBuilder.fromUri("www.whatever.com");
when(mockedUriInfo.getAbsolutePathBuilder()).thenReturn(uriBuilder);
- this.restconf.invokeRpc("sal-remote:create-data-change-event-subscription",
+ restconf.invokeRpc("sal-remote:create-data-change-event-subscription",
prepareDomRpcNode(datastoreValue, scopeValue), mockedUriInfo);
final ListenerAdapter listener =
}
private NormalizedNodeContext prepareDomRpcNode(final String datastore, final String scope) {
- final EffectiveModelContext schema = this.controllerContext.getGlobalSchema();
+ final EffectiveModelContext schema = controllerContext.getGlobalSchema();
final Module rpcSalRemoteModule = schema.findModule("sal-remote", Revision.of("2014-01-14")).get();
final QName rpcQName =
QName.create(rpcSalRemoteModule.getQNameModule(), "create-data-change-event-subscription");
when(rpcDef.getPath()).thenReturn(SchemaPath.create(true, rpcQName));
when(rpcDef.getQName()).thenReturn(rpcQName);
- return new NormalizedNodeContext(new InstanceIdentifierContext<>(null, rpcDef, null, schema),
+ return new NormalizedNodeContext(new InstanceIdentifierContext(null, rpcDef, null, schema),
container.build());
}
}
@Test
public void testToInstanceIdentifierList() {
- InstanceIdentifierContext<?> instanceIdentifier = controllerContext
+ InstanceIdentifierContext instanceIdentifier = controllerContext
.toInstanceIdentifier("simple-nodes:userWithoutClass/foo");
assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "userWithoutClass");
@Test
public void testToInstanceIdentifierWithDoubleSlash() {
- InstanceIdentifierContext<?> instanceIdentifier = controllerContext
+ InstanceIdentifierContext instanceIdentifier = controllerContext
.toInstanceIdentifier("simple-nodes:food//nonalcoholic");
assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "nonalcoholic");
@Test
public void testToInstanceIdentifierContainer() {
- final InstanceIdentifierContext<?> instanceIdentifier =
+ final InstanceIdentifierContext instanceIdentifier =
controllerContext.toInstanceIdentifier("simple-nodes:users");
assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "users");
assertTrue(instanceIdentifier.getSchemaNode() instanceof ContainerSchemaNode);
@Test
public void testToInstanceIdentifierChoice() {
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext
+ final InstanceIdentifierContext instanceIdentifier = controllerContext
.toInstanceIdentifier("simple-nodes:food/nonalcoholic");
assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "nonalcoholic");
}
@Test
public void testMountPointWithExternModul() {
initSchemaService();
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext
+ final InstanceIdentifierContext instanceIdentifier = controllerContext
.toInstanceIdentifier("simple-nodes:users/yang-ext:mount/test-interface2:class/student/name");
assertEquals(
"[(urn:ietf:params:xml:ns:yang:test-interface2?revision=2014-08-01)class, "
@Test
public void testMountPointWithoutExternModul() {
initSchemaService();
- final InstanceIdentifierContext<?> instanceIdentifier = controllerContext
+ final InstanceIdentifierContext instanceIdentifier = controllerContext
.toInstanceIdentifier("simple-nodes:users/yang-ext:mount/");
assertTrue(Iterables.isEmpty(instanceIdentifier.getInstanceIdentifier().getPathArguments()));
}
}
public static QueryParameters newQueryParameters(final ReadDataParams params,
- final InstanceIdentifierContext<?> identifier) {
+ final InstanceIdentifierContext identifier) {
final var fields = params.fields();
if (fields == null) {
return QueryParameters.of(params);
}
@Override
- protected final NormalizedNodePayload emptyBody(final InstanceIdentifierContext<?> path) {
+ protected final NormalizedNodePayload emptyBody(final InstanceIdentifierContext path) {
return NormalizedNodePayload.empty(path);
}
}
import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
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.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected NormalizedNodePayload readBody(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ protected NormalizedNodePayload readBody(final InstanceIdentifierContext path, final InputStream entityStream)
throws WebApplicationException {
try {
return readFrom(path, entityStream, isPost());
}
public static NormalizedNodePayload readFrom(
- final InstanceIdentifierContext<?> path, final InputStream entityStream, final boolean isPost) {
+ final InstanceIdentifierContext path, final InputStream entityStream, final boolean isPost) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
NormalizedNode result = resultHolder.getResult();
final List<YangInstanceIdentifier.PathArgument> iiToDataList = new ArrayList<>();
- InstanceIdentifierContext<? extends SchemaNode> newIIContext;
+ InstanceIdentifierContext newIIContext;
while (result instanceof AugmentationNode || result instanceof ChoiceNode) {
final Object childNode = ((DataContainerNode) result).body().iterator().next();
final YangInstanceIdentifier fullIIToData = YangInstanceIdentifier.create(Iterables.concat(
path.getInstanceIdentifier().getPathArguments(), iiToDataList));
- newIIContext = new InstanceIdentifierContext<>(fullIIToData, path.getSchemaNode(), path.getMountPoint(),
+ newIIContext = new InstanceIdentifierContext(fullIIToData, path.getSchemaNode(), path.getMountPoint(),
path.getSchemaContext());
// FIXME: can result really be null?
return;
}
- @SuppressWarnings("unchecked")
- final InstanceIdentifierContext<SchemaNode> identifierCtx =
- (InstanceIdentifierContext<SchemaNode>) context.getInstanceIdentifierContext();
+ final InstanceIdentifierContext identifierCtx = context.getInstanceIdentifierContext();
final SchemaPath path = identifierCtx.getSchemaNode().getPath();
final var pretty = context.getWriterParameters().prettyPrint();
}
private static void writeNormalizedNode(final JsonWriter jsonWriter,
- final SchemaPath path, final InstanceIdentifierContext<SchemaNode> context, final NormalizedNode data,
+ final SchemaPath path, final InstanceIdentifierContext context, final NormalizedNode data,
final DepthParam depth, final List<Set<QName>> fields) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
}
private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(
- final InstanceIdentifierContext<SchemaNode> context, final SchemaPath path, final JsonWriter jsonWriter,
+ final InstanceIdentifierContext context, final SchemaPath path, final JsonWriter jsonWriter,
final DepthParam depth, final List<Set<QName>> fields) {
final SchemaNode schema = context.getSchemaNode();
return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8));
}
- private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
+ private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext context) {
// TODO: Performance: Cache JSON Codec factory and schema context
return JSONCodecFactorySupplier.RFC7951.getShared(context.getSchemaContext());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected NormalizedNodePayload readBody(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ protected NormalizedNodePayload readBody(final InstanceIdentifierContext path, final InputStream entityStream)
throws WebApplicationException {
try {
final Document doc = UntrustedXML.newDocumentBuilder().parse(entityStream);
}
}
- private NormalizedNodePayload parse(final InstanceIdentifierContext<?> pathContext, final Document doc)
+ private NormalizedNodePayload parse(final InstanceIdentifierContext pathContext, final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final SchemaNode schemaNodeContext = pathContext.getSchemaNode();
DataSchemaNode schemaNode;
final YangInstanceIdentifier fullIIToData = YangInstanceIdentifier.create(Iterables.concat(
pathContext.getInstanceIdentifier().getPathArguments(), iiToDataList));
- final InstanceIdentifierContext<? extends SchemaNode> outIIContext = new InstanceIdentifierContext<>(
+ final InstanceIdentifierContext outIIContext = new InstanceIdentifierContext(
fullIIToData, pathContext.getSchemaNode(), pathContext.getMountPoint(), pathContext.getSchemaContext());
// FIXME: can result really be null?
final MediaType mediaType,
final MultivaluedMap<String, Object> httpHeaders,
final OutputStream entityStream) throws IOException, WebApplicationException {
- final InstanceIdentifierContext<?> pathContext = context.getInstanceIdentifierContext();
+ final InstanceIdentifierContext pathContext = context.getInstanceIdentifierContext();
if (context.getData() == null) {
return;
}
}
private static void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath path,
- final InstanceIdentifierContext<?> pathContext, final NormalizedNode data, final DepthParam depth,
+ final InstanceIdentifierContext pathContext, final NormalizedNode data, final DepthParam depth,
final List<Set<QName>> fields) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
final EffectiveModelContext schemaCtx = pathContext.getSchemaContext();
}
@Override
- protected final PatchContext emptyBody(final InstanceIdentifierContext<?> path) {
+ protected final PatchContext emptyBody(final InstanceIdentifierContext path) {
return new PatchContext(path, null, null);
}
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected PatchContext readBody(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ protected PatchContext readBody(final InstanceIdentifierContext path, final InputStream entityStream)
throws WebApplicationException {
try {
return readFrom(path, entityStream);
}
}
- private PatchContext readFrom(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ private PatchContext readFrom(final InstanceIdentifierContext path, final InputStream entityStream)
throws IOException {
final JsonReader jsonReader = new JsonReader(new InputStreamReader(entityStream, StandardCharsets.UTF_8));
AtomicReference<String> patchId = new AtomicReference<>();
ErrorTag.MALFORMED_MESSAGE, exception);
}
- private List<PatchEntity> read(final JsonReader in, final InstanceIdentifierContext<?> path,
+ private List<PatchEntity> read(final JsonReader in, final InstanceIdentifierContext path,
final AtomicReference<String> patchId) throws IOException {
final DataSchemaContextTree schemaTree = DataSchemaContextTree.from(path.getSchemaContext());
final List<PatchEntity> resultCollection = new ArrayList<>();
* @throws IOException if operation fails
*/
private void parseByName(final @NonNull String name, final @NonNull PatchEdit edit,
- final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext path,
final @NonNull DataSchemaContextTree schemaTree,
final @NonNull List<PatchEntity> resultCollection,
final @NonNull AtomicReference<String> patchId) throws IOException {
* @throws IOException if operation fails
*/
private void readEditDefinition(final @NonNull PatchEdit edit, final @NonNull JsonReader in,
- final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull InstanceIdentifierContext path,
final @NonNull DataSchemaContextTree schemaTree) throws IOException {
String deferredValue = null;
in.beginObject();
* @return NormalizedNode representing data
*/
private static NormalizedNode readEditData(final @NonNull JsonReader in,
- final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext<?> path) {
+ final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
JsonParserStream.create(writer, JSONCodecFactorySupplier.RFC7951.getShared(path.getSchemaContext()),
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected PatchContext readBody(final InstanceIdentifierContext<?> path, final InputStream entityStream)
+ protected PatchContext readBody(final InstanceIdentifierContext path, final InputStream entityStream)
throws WebApplicationException {
try {
final Document doc = UntrustedXML.newDocumentBuilder().parse(entityStream);
}
}
- private static PatchContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc)
+ private static PatchContext parse(final InstanceIdentifierContext pathContext, final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final List<PatchEntity> resultCollection = new ArrayList<>();
final String patchId = doc.getElementsByTagName("patch-id").item(0).getFirstChild().getNodeValue();
final Annotation[] annotations, final MediaType mediaType,
final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException,
WebApplicationException {
- final InstanceIdentifierContext<?> path = getInstanceIdentifierContext();
+ final InstanceIdentifierContext path = getInstanceIdentifierContext();
final PushbackInputStream pushbackInputStream = new PushbackInputStream(entityStream);
* @param path Request path
* @return empty body type
*/
- protected abstract T emptyBody(InstanceIdentifierContext<?> path);
+ protected abstract T emptyBody(InstanceIdentifierContext path);
- protected abstract T readBody(InstanceIdentifierContext<?> path, InputStream entityStream)
+ protected abstract T readBody(InstanceIdentifierContext path, InputStream entityStream)
throws WebApplicationException;
-
private String getIdentifier() {
return this.uriInfo.getPathParameters(false).getFirst("identifier");
}
- private InstanceIdentifierContext<?> getInstanceIdentifierContext() {
+ private InstanceIdentifierContext getInstanceIdentifierContext() {
return ParserIdentifier.toInstanceIdentifier(getIdentifier(), getSchemaContext(),
Optional.ofNullable(getMountPointService()));
}
* messy details needed to deal with the payload.
*/
public final class NormalizedNodePayload {
- private final InstanceIdentifierContext<?> context;
+ private final InstanceIdentifierContext context;
private final ImmutableMap<String, Object> headers;
private final QueryParameters writerParameters;
private final NormalizedNode data;
- private NormalizedNodePayload(final InstanceIdentifierContext<?> context,
- final NormalizedNode data, final QueryParameters writerParameters,
- final ImmutableMap<String, Object> headers) {
+ private NormalizedNodePayload(final InstanceIdentifierContext context, final NormalizedNode data,
+ final QueryParameters writerParameters, final ImmutableMap<String, Object> headers) {
this.context = context;
this.data = data;
this.writerParameters = requireNonNull(writerParameters);
this.headers = requireNonNull(headers);
}
- public static @NonNull NormalizedNodePayload empty(final InstanceIdentifierContext<?> path) {
+ public static @NonNull NormalizedNodePayload empty(final InstanceIdentifierContext path) {
return new NormalizedNodePayload(requireNonNull(path), null, QueryParameters.empty(), ImmutableMap.of());
}
- public static @NonNull NormalizedNodePayload of(final InstanceIdentifierContext<?> path,
- final NormalizedNode data) {
+ public static @NonNull NormalizedNodePayload of(final InstanceIdentifierContext path, final NormalizedNode data) {
return new NormalizedNodePayload(requireNonNull(path), requireNonNull(data), QueryParameters.empty(),
ImmutableMap.of());
}
- public static @NonNull NormalizedNodePayload ofNullable(final InstanceIdentifierContext<?> path,
+ public static @NonNull NormalizedNodePayload ofNullable(final InstanceIdentifierContext path,
final NormalizedNode data) {
return data == null ? empty(path) : of(path, data);
}
- public static @NonNull NormalizedNodePayload ofLocation(final InstanceIdentifierContext<?> path,
+ public static @NonNull NormalizedNodePayload ofLocation(final InstanceIdentifierContext path,
final NodeIdentifier leafId, final URI location) {
return new NormalizedNodePayload(requireNonNull(path), ImmutableNodes.leafNode(leafId, location.toString()),
QueryParameters.empty(), ImmutableMap.of("Location", location));
}
- public static Object ofReadData(final InstanceIdentifierContext<?> path, final NormalizedNode data,
+ public static Object ofReadData(final InstanceIdentifierContext path, final NormalizedNode data,
final QueryParameters parameters) {
return new NormalizedNodePayload(requireNonNull(path), requireNonNull(data), parameters, ImmutableMap.of());
}
- public InstanceIdentifierContext<?> getInstanceIdentifierContext() {
+ public InstanceIdentifierContext getInstanceIdentifierContext() {
return context;
}
final ReadDataParams readParams = QueryParams.newReadDataParams(uriInfo);
final EffectiveModelContext schemaContextRef = schemaContextHandler.get();
- final InstanceIdentifierContext<?> instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
identifier, schemaContextRef, Optional.of(mountPointService));
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
final WriteDataParams params = QueryParams.newWriteDataParams(uriInfo);
- final InstanceIdentifierContext<? extends SchemaNode> iid = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iid = payload.getInstanceIdentifierContext();
validInputData(iid.getSchemaNode(), payload);
validTopLevelNodeName(iid.getInstanceIdentifier(), payload);
@Override
public Response deleteData(final String identifier) {
- final InstanceIdentifierContext<?> instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
identifier, schemaContextHandler.get(), Optional.of(mountPointService));
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
public Response patchData(final String identifier, final NormalizedNodePayload payload, final UriInfo uriInfo) {
requireNonNull(payload);
- final InstanceIdentifierContext<? extends SchemaNode> iid = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iid = payload.getInstanceIdentifierContext();
validInputData(iid.getSchemaNode(), payload);
validTopLevelNodeName(iid.getInstanceIdentifier(), payload);
validateListKeysEqualityInPayloadAndUri(payload);
* @return {@link NormalizedNodePayload} wrapped in {@link Response}
*/
public Response invokeAction(final NormalizedNodePayload payload) {
- final InstanceIdentifierContext<?> context = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext context = payload.getInstanceIdentifierContext();
final YangInstanceIdentifier yangIIdContext = context.getInstanceIdentifier();
final NormalizedNode data = payload.getData();
return Response.status(Status.OK)
.entity(NormalizedNodePayload.ofNullable(
- new InstanceIdentifierContext<>(yangIIdContext, resultNodeSchema, mountPoint, schemaContextRef),
+ new InstanceIdentifierContext(yangIIdContext, resultNodeSchema, mountPoint, schemaContextRef),
resultData))
.build();
}
*/
@VisibleForTesting
public static void validateListKeysEqualityInPayloadAndUri(final NormalizedNodePayload payload) {
- final InstanceIdentifierContext<?> iiWithData = payload.getInstanceIdentifierContext();
+ final InstanceIdentifierContext iiWithData = payload.getInstanceIdentifierContext();
final PathArgument lastPathArgument = iiWithData.getInstanceIdentifier().getLastPathArgument();
final SchemaNode schemaNode = iiWithData.getSchemaNode();
final NormalizedNode data = payload.getData();
(LeafSchemaNode) ((ContainerSchemaNode) grouping.getDataChildByName(Restconf.QNAME))
.getDataChildByName(YANG_LIBRARY_VERSION);
- return NormalizedNodePayload.of(new InstanceIdentifierContext<>(
+ return NormalizedNodePayload.of(new InstanceIdentifierContext(
YangInstanceIdentifier.of(YANG_LIBRARY_VERSION), schemaNode, null, context),
ImmutableNodes.leafNode(YANG_LIBRARY_VERSION, IetfYangLibrary.REVISION.toString()));
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (resultData == null || ((ContainerNode) resultData).isEmpty()) {
ar.resume(new WebApplicationException(Status.NO_CONTENT));
} else {
- ar.resume(NormalizedNodePayload.of(new InstanceIdentifierContext<>(null, (RpcDefinition) schema,
+ ar.resume(NormalizedNodePayload.of(new InstanceIdentifierContext(null, schema,
mountPoint, schemaContextRef), resultData));
}
}
ErrorTag.INVALID_VALUE);
}
- final InstanceIdentifierContext<?> mountPointIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
+ final InstanceIdentifierContext mountPointIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
schemaContextHandler.get(), Optional.of(mountPointService));
final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint();
final var entry = OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint);
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @param schemaHandler Schema context handler.
* @return InstanceIdentifier of Location leaf.
*/
- private static InstanceIdentifierContext<?> prepareIIDSubsStreamOutput(final SchemaContextHandler schemaHandler) {
+ private static InstanceIdentifierContext prepareIIDSubsStreamOutput(final SchemaContextHandler schemaHandler) {
final Optional<Module> module = schemaHandler.get().findModule(NOTIFI_QNAME.getModule());
checkState(module.isPresent());
final DataSchemaNode notify = module.get().dataChildByName(NOTIFI_QNAME);
final DataSchemaNode location = ((ContainerSchemaNode) notify).dataChildByName(LOCATION_QNAME);
checkState(location != null, "Missing location");
- return new InstanceIdentifierContext<SchemaNode>(LOCATION_PATH, location, null, schemaHandler.get());
+ return new InstanceIdentifierContext(LOCATION_PATH, location, null, schemaHandler.get());
}
/**
final RestconfTransaction transaction) {
final YangInstanceIdentifier parent = path.getParent().getParent();
transaction.remove(parent);
- final InstanceIdentifierContext<?> instanceIdentifier =
+ final InstanceIdentifierContext instanceIdentifier =
// FIXME: Point should be able to give us this method
ParserIdentifier.toInstanceIdentifier(point.value(), schemaContext, Optional.empty());
int lastItemPosition = 0;
final EffectiveModelContext schemaContext, final PointParam point,
final NormalizedNodeContainer<?> readList, final boolean before) {
transaction.remove(path.getParent());
- final InstanceIdentifierContext<?> instanceIdentifier =
+ final InstanceIdentifierContext instanceIdentifier =
// FIXME: Point should be able to give us this method
ParserIdentifier.toInstanceIdentifier(point.value(), schemaContext, Optional.empty());
int lastItemPosition = 0;
* @param input input value of fields parameter
* @return {@link List} of levels; each level contains {@link Set} of identifiers of type {@link T}
*/
- protected final @NonNull List<Set<T>> parseFields(final @NonNull InstanceIdentifierContext<?> identifier,
+ protected final @NonNull List<Set<T>> parseFields(final @NonNull InstanceIdentifierContext identifier,
final @NonNull FieldsParam input) {
final DataSchemaContextNode<?> startNode = DataSchemaContextNode.fromDataSchemaNode(
(DataSchemaNode) identifier.getSchemaNode());
* of provided {@code identifier}
*/
public static @NonNull List<YangInstanceIdentifier> translate(
- final @NonNull InstanceIdentifierContext<?> identifier, final @NonNull FieldsParam input) {
+ final @NonNull InstanceIdentifierContext identifier, final @NonNull FieldsParam input) {
final List<Set<LinkedPathElement>> levels = INSTANCE.parseFields(identifier, input);
final List<Map<PathArgument, LinkedPathElement>> mappedLevels = mapLevelsContentByIdentifiers(levels);
return buildPaths(mappedLevels);
//
// @NonNull InstanceIdentifierContext forUrl(identifier, schemaContexxt, mountPointService)
//
- public static InstanceIdentifierContext<?> toInstanceIdentifier(final String identifier,
+ public static InstanceIdentifierContext toInstanceIdentifier(final String identifier,
final EffectiveModelContext schemaContext, final Optional<DOMMountPointService> mountPointService) {
if (identifier == null || !identifier.contains(RestconfConstants.MOUNT)) {
return createIIdContext(schemaContext, identifier, null);
* @return {@link InstanceIdentifierContext}
* @throws RestconfDocumentedException if the path cannot be resolved
*/
- private static InstanceIdentifierContext<?> createIIdContext(final EffectiveModelContext schemaContext,
+ private static InstanceIdentifierContext createIIdContext(final EffectiveModelContext schemaContext,
final String url, final @Nullable DOMMountPoint mountPoint) {
final YangInstanceIdentifier urlPath = IdentifierCodec.deserialize(url, schemaContext);
- return new InstanceIdentifierContext<>(urlPath, getPathSchema(schemaContext, urlPath), mountPoint,
- schemaContext);
+ return new InstanceIdentifierContext(urlPath, getPathSchema(schemaContext, urlPath), mountPoint, schemaContext);
}
private static SchemaNode getPathSchema(final EffectiveModelContext schemaContext,
pathBuilder.append(current);
}
- final InstanceIdentifierContext<?> point = toInstanceIdentifier(pathBuilder.toString(), schemaContext,
+ final InstanceIdentifierContext point = toInstanceIdentifier(pathBuilder.toString(), schemaContext,
Optional.of(domMountPointService));
final String moduleName = validateAndGetModulName(componentIter);
final Revision revision = validateAndGetRevision(componentIter);
}
}
- public static YangInstanceIdentifier parserPatchTarget(final InstanceIdentifierContext<?> context,
+ public static YangInstanceIdentifier parserPatchTarget(final InstanceIdentifierContext context,
final String target) {
final var schemaContext = context.getSchemaContext();
final var urlPath = context.getInstanceIdentifier();
* @param input input value of fields parameter
* @return {@link List} of levels; each level contains set of {@link QName}
*/
- public static @NonNull List<Set<QName>> translate(final @NonNull InstanceIdentifierContext<?> identifier,
+ public static @NonNull List<Set<QName>> translate(final @NonNull InstanceIdentifierContext identifier,
final @NonNull FieldsParam input) {
return INSTANCE.parseFields(identifier, input);
}
@SuppressWarnings("checkstyle:IllegalCatch")
public static NormalizedNodePayload loadNormalizedContextFromXmlFile(final String pathToInputFile,
final String uri, final EffectiveModelContext schemaContext) {
- final InstanceIdentifierContext<?> iiContext =
+ final InstanceIdentifierContext iiContext =
ParserIdentifier.toInstanceIdentifier(uri, schemaContext, Optional.empty());
final InputStream inputStream = TestRestconfUtils.class.getResourceAsStream(pathToInputFile);
try {
final NormalizedNode nn = parse(iiContext, doc);
return NormalizedNodePayload.of(iiContext, nn);
} catch (final Exception e) {
- LOG.error("Load xml file " + pathToInputFile + " fail.", e);
+ LOG.error("Load xml file {} fail.", pathToInputFile, e);
}
return null;
}
- private static NormalizedNode parse(final InstanceIdentifierContext<?> iiContext, final Document doc)
+ private static NormalizedNode parse(final InstanceIdentifierContext iiContext, final Document doc)
throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final SchemaNode schemaNodeContext = iiContext.getSchemaNode();
DataSchemaNode schemaNode = null;
doReturn(SchemaPath.ROOT).when(schemaNode).getPath();
final NormalizedNodePayload nodePayload = NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(YangInstanceIdentifier.empty(), schemaNode, null, schemaContext),
+ new InstanceIdentifierContext(YangInstanceIdentifier.empty(), schemaNode, null, schemaContext),
Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME)).build());
final ByteArrayOutputStream output = new ByteArrayOutputStream();
doReturn(SchemaPath.ROOT).when(schemaNode).getPath();
final NormalizedNodePayload nodePayload = NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(YangInstanceIdentifier.empty(), schemaNode, null, schemaContext),
+ new InstanceIdentifierContext(YangInstanceIdentifier.empty(), schemaNode, null, schemaContext),
Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME))
.withChild(Builders.containerBuilder()
.withValue(o).build();
container.withChild(lfNode);
- return NormalizedNodePayload.of(new InstanceIdentifierContext<>(null, rpcInputSchemaNode, null, schema),
+ return NormalizedNodePayload.of(new InstanceIdentifierContext(null, rpcInputSchemaNode, null, schema),
container.build());
}
}
final var schemaNode = loadAction(contextRef, RESET_QNAME, ACTION_YII).orElseThrow();
final var response = dataService.invokeAction(NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(ACTION_YII, schemaNode, null, contextRef),
+ new InstanceIdentifierContext(ACTION_YII, schemaNode, null, contextRef),
Builders.containerBuilder()
.withNodeIdentifier(NodeIdentifier.create(INPUT_QNAME))
.withChild(ImmutableNodes.leafNode(DELAY_QNAME, Uint32.TEN))
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
@Test
public void testPutData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateTrueFluentFuture()).when(read)
@Test
public void testPutDataWithMountPoint() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidBase, schemaNode, mountPoint, contextRef);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidBase, schemaNode, mountPoint, contextRef);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateTrueFluentFuture()).when(read)
NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidBase, null, null, contextRef);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidBase, null, null, contextRef);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, Builders.mapBuilder()
.withNodeIdentifier(new NodeIdentifier(listQname))
.withChild(Builders.mapEntryBuilder()
@Test
public void testPatchData() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef);
final List<PatchEntity> entity = new ArrayList<>();
final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
.node(containerPlayerQname)
@Test
public void testPatchDataMountPoint() throws Exception {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
+ final InstanceIdentifierContext iidContext = new InstanceIdentifierContext(
iidBase, schemaNode, mountPoint, contextRef);
final List<PatchEntity> entity = new ArrayList<>();
final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
@Test
public void testPatchDataDeleteNotExist() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef);
final List<PatchEntity> entity = new ArrayList<>();
final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
.node(containerPlayerQname)
}
private NormalizedNodePayload prepNNC(final NormalizedNode result) {
- final InstanceIdentifierContext<?> context = mock(InstanceIdentifierContext.class);
+ final InstanceIdentifierContext context = mock(InstanceIdentifierContext.class);
final RpcDefinition schemaNode = mock(RpcDefinition.class);
final QName qname = QName.create("invoke:rpc:module", "2013-12-03", "rpcTest");
doReturn(qname).when(schemaNode).getQName();
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class DeleteDataTransactionUtilTest {
@Mock
- private InstanceIdentifierContext<?> context;
+ private InstanceIdentifierContext context;
@Mock
private DOMDataTreeReadWriteTransaction readWrite;
@Mock
@Before
public void init() {
- doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
+ doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).discardChanges();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.delete(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
- doReturn(YangInstanceIdentifier.empty()).when(this.context).getInstanceIdentifier();
+ doReturn(YangInstanceIdentifier.empty()).when(context).getInstanceIdentifier();
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
}
ret.setException(new TransactionCommitFailedException(
String.format("Commit of transaction %s failed", this), exception));
- doReturn(ret).when(this.netconfService).commit();
+ doReturn(ret).when(netconfService).commit();
// test and assert error
deleteFail(new MdsalRestconfStrategy(mockDataBroker));
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
@Before
public void setUp() throws Exception {
- this.refSchemaCtx = YangParserTestUtils.parseYangFiles(
+ refSchemaCtx = YangParserTestUtils.parseYangFiles(
TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
final QName baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
final QName containerPlayerQName = QName.create(baseQName, "player");
"name of artist");
/* instance identifier for accessing container node "player" */
- this.instanceIdContainer = YangInstanceIdentifier.builder()
+ instanceIdContainer = YangInstanceIdentifier.builder()
.node(baseQName)
.node(containerPlayerQName)
.build();
/* instance identifier for accessing leaf node "gap" */
- this.instanceIdCreateAndDelete = instanceIdContainer.node(leafGapQName);
+ instanceIdCreateAndDelete = instanceIdContainer.node(leafGapQName);
/* values that are used for creating leaf for testPatchDataCreateAndDelete test */
final LeafNode<?> buildGapLeaf = Builders.leafBuilder()
.withChild(buildGapLeaf)
.build();
- this.buildBaseContainerForTests = Builders.containerBuilder()
+ buildBaseContainerForTests = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildPlayerContainer)
.build();
- this.targetNodeForCreateAndDelete = YangInstanceIdentifier.builder(this.instanceIdCreateAndDelete)
+ targetNodeForCreateAndDelete = YangInstanceIdentifier.builder(instanceIdCreateAndDelete)
.node(containerPlayerQName)
.node(leafGapQName)
.build();
/* instance identifier for accessing leaf node "name" in list "artist" */
- this.instanceIdMerge = YangInstanceIdentifier.builder()
+ instanceIdMerge = YangInstanceIdentifier.builder()
.node(baseQName)
.node(containerLibraryQName)
.node(listArtistQName)
.withChild(contentDescription)
.build();
- this.buildArtistList = Builders.mapBuilder()
+ buildArtistList = Builders.mapBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listArtistQName))
.withChild(mapEntryNode)
.build();
- this.targetNodeMerge = YangInstanceIdentifier.builder()
+ targetNodeMerge = YangInstanceIdentifier.builder()
.node(baseQName)
.node(containerLibraryQName)
.node(listArtistQName)
.build();
/* Mocks */
- doReturn(this.rwTransaction).when(this.mockDataBroker).newReadWriteTransaction();
- doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).merge(any(), any(),
+ doReturn(rwTransaction).when(mockDataBroker).newReadWriteTransaction();
+ doReturn(CommitInfo.emptyFluentFuture()).when(rwTransaction).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).discardChanges();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).merge(any(), any(),
any(), any());
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).replace(any(), any(),
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).replace(any(), any(),
any(), any());
}
@Test
public void testPatchDataReplaceMergeAndRemove() {
final PatchEntity entityReplace =
- new PatchEntity("edit1", REPLACE, this.targetNodeMerge, this.buildArtistList);
- final PatchEntity entityMerge = new PatchEntity("edit2", MERGE, this.targetNodeMerge, this.buildArtistList);
- final PatchEntity entityRemove = new PatchEntity("edit3", REMOVE, this.targetNodeMerge);
+ new PatchEntity("edit1", REPLACE, targetNodeMerge, buildArtistList);
+ final PatchEntity entityMerge = new PatchEntity("edit2", MERGE, targetNodeMerge, buildArtistList);
+ final PatchEntity entityRemove = new PatchEntity("edit3", REMOVE, targetNodeMerge);
final List<PatchEntity> entities = new ArrayList<>();
entities.add(entityReplace);
entities.add(entityMerge);
entities.add(entityRemove);
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.instanceIdMerge, null, null, this.refSchemaCtx);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(instanceIdMerge, null, null, refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchRMRm");
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.remove(LogicalDatastoreType.CONFIGURATION, targetNodeMerge);
patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), false);
@Test
public void testPatchDataCreateAndDelete() {
- doReturn(immediateFalseFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
- this.instanceIdContainer);
- doReturn(immediateTrueFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
- this.targetNodeForCreateAndDelete);
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
- .create(LogicalDatastoreType.CONFIGURATION, this.instanceIdContainer, this.buildBaseContainerForTests,
+ doReturn(immediateFalseFluentFuture()).when(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ instanceIdContainer);
+ doReturn(immediateTrueFluentFuture()).when(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ targetNodeForCreateAndDelete);
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
+ .create(LogicalDatastoreType.CONFIGURATION, instanceIdContainer, buildBaseContainerForTests,
Optional.empty());
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
- .delete(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
+ .delete(LogicalDatastoreType.CONFIGURATION, targetNodeForCreateAndDelete);
final PatchEntity entityCreate =
- new PatchEntity("edit1", CREATE, this.instanceIdContainer, this.buildBaseContainerForTests);
+ new PatchEntity("edit1", CREATE, instanceIdContainer, buildBaseContainerForTests);
final PatchEntity entityDelete =
- new PatchEntity("edit2", DELETE, this.targetNodeForCreateAndDelete);
+ new PatchEntity("edit2", DELETE, targetNodeForCreateAndDelete);
final List<PatchEntity> entities = new ArrayList<>();
entities.add(entityCreate);
entities.add(entityDelete);
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(instanceIdCreateAndDelete, null, null, refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchCD");
patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), true);
patch(patchContext, new NetconfRestconfStrategy(netconfService), true);
@Test
public void deleteNonexistentDataTest() {
- doReturn(immediateFalseFluentFuture()).when(this.rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
- this.targetNodeForCreateAndDelete);
+ doReturn(immediateFalseFluentFuture()).when(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION,
+ targetNodeForCreateAndDelete);
final NetconfDocumentedException exception = new NetconfDocumentedException("id",
ErrorType.RPC, ErrorTag.DATA_MISSING, ErrorSeverity.ERROR);
final SettableFuture<? extends DOMRpcResult> ret = SettableFuture.create();
ret.setException(new TransactionCommitFailedException(
String.format("Commit of transaction %s failed", this), exception));
- doReturn(ret).when(this.netconfService).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
- .delete(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
+ doReturn(ret).when(netconfService).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
+ .delete(LogicalDatastoreType.CONFIGURATION, targetNodeForCreateAndDelete);
- final PatchEntity entityDelete = new PatchEntity("edit", DELETE, this.targetNodeForCreateAndDelete);
+ final PatchEntity entityDelete = new PatchEntity("edit", DELETE, targetNodeForCreateAndDelete);
final List<PatchEntity> entities = new ArrayList<>();
entities.add(entityDelete);
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(instanceIdCreateAndDelete, null, null, refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchD");
deleteMdsal(patchContext, new MdsalRestconfStrategy(mockDataBroker));
deleteNetconf(patchContext, new NetconfRestconfStrategy(netconfService));
@Test
public void testPatchMergePutContainer() {
final PatchEntity entityMerge =
- new PatchEntity("edit1", MERGE, this.instanceIdContainer, this.buildBaseContainerForTests);
+ new PatchEntity("edit1", MERGE, instanceIdContainer, buildBaseContainerForTests);
final List<PatchEntity> entities = new ArrayList<>();
entities.add(entityMerge);
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(instanceIdCreateAndDelete, null, null, refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchM");
patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), false);
patch(patchContext, new NetconfRestconfStrategy(netconfService), false);
private void patch(final PatchContext patchContext, final RestconfStrategy strategy,
final boolean failed) {
final PatchStatusContext patchStatusContext =
- PatchDataTransactionUtil.patchData(patchContext, strategy, this.refSchemaCtx);
+ PatchDataTransactionUtil.patchData(patchContext, strategy, refSchemaCtx);
for (final PatchStatusEntity entity : patchStatusContext.getEditCollection()) {
if (failed) {
assertTrue("Edit " + entity.getEditId() + " failed", entity.isOk());
private void deleteMdsal(final PatchContext patchContext, final RestconfStrategy strategy) {
final PatchStatusContext patchStatusContext =
- PatchDataTransactionUtil.patchData(patchContext, strategy, this.refSchemaCtx);
+ PatchDataTransactionUtil.patchData(patchContext, strategy, refSchemaCtx);
assertFalse(patchStatusContext.isOk());
assertEquals(ErrorType.PROTOCOL,
private void deleteNetconf(final PatchContext patchContext, final RestconfStrategy strategy) {
final PatchStatusContext patchStatusContext =
- PatchDataTransactionUtil.patchData(patchContext, strategy, this.refSchemaCtx);
+ PatchDataTransactionUtil.patchData(patchContext, strategy, refSchemaCtx);
assertFalse(patchStatusContext.isOk());
assertEquals(ErrorType.PROTOCOL,
@Test
public void testPatchContainerData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidJukebox, schemaNodeForJukebox, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidJukebox, schemaNodeForJukebox, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, jukeboxContainerWithPlayer);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
@Test
public void testPatchLeafData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidGap, schemaNodeForGap, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidGap, schemaNodeForGap, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, leafGap);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
@Test
public void testPatchListData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidJukebox, schemaNodeForJukebox, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iidJukebox, schemaNodeForJukebox, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, jukeboxContainerWithPlaylist);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.DOMException;
@Test
public void testPostContainerData() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, null, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, null, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iid2);
@Test
public void testPostListData() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iidList, null, null, schema);
+ final InstanceIdentifierContext iidContext = new InstanceIdentifierContext(iidList, null, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildList);
final MapNode data = (MapNode) payload.getData();
@Test
public void testPostDataFail() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, null, null, schema);
+ final InstanceIdentifierContext iidContext = new InstanceIdentifierContext(iid2, null, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
@Test
public void testValidInputData() {
RestconfDataServiceImpl.validInputData(schemaNode, NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema), buildLeaf));
+ new InstanceIdentifierContext(iid, schemaNode, null, schema), buildLeaf));
}
@Test
public void testValidTopLevelNodeName() {
RestconfDataServiceImpl.validTopLevelNodeName(iid, NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema), buildLeaf));
+ new InstanceIdentifierContext(iid, schemaNode, null, schema), buildLeaf));
RestconfDataServiceImpl.validTopLevelNodeName(iid2, NormalizedNodePayload.of(
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema), buildBaseCont));
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema), buildBaseCont));
}
@Test
public void testValidTopLevelNodeNamePathEmpty() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid, schemaNode, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
// FIXME: more asserts
@Test
public void testValidTopLevelNodeNameWrongTopIdentifier() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid, schemaNode, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
// FIXME: more asserts
@Test
public void testValidateListKeysEqualityInPayloadAndUri() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid3, schemaNode3, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid3, schemaNode3, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildListEntry);
RestconfDataServiceImpl.validateListKeysEqualityInPayloadAndUri(payload);
}
@Test
public void testPutContainerData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
@Test
public void testPutCreateContainerData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid2);
@Test
public void testPutReplaceContainerData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService).getConfig(iid2);
@Test
public void testPutLeafData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid, schemaNode, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
@Test
public void testPutCreateLeafData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid, schemaNode, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid);
@Test
public void testPutReplaceLeafData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid, schemaNode, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService).getConfig(iid);
@Test
public void testPutListData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
@Test
public void testPutCreateListData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService)
@Test
public void testPutReplaceListData() {
- final InstanceIdentifierContext<DataSchemaNode> iidContext =
- new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
+ final InstanceIdentifierContext iidContext =
+ new InstanceIdentifierContext(iid2, schemaNode2, null, schema);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService)
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
@Mock
private NetconfDataTreeService netconfService;
@Mock
- private InstanceIdentifierContext<ContainerSchemaNode> context;
+ private InstanceIdentifierContext context;
@Mock
private DOMDataTreeReadTransaction read;
@Mock
public abstract class AbstractFieldsTranslatorTest<T> {
@Mock
- private InstanceIdentifierContext<ContainerSchemaNode> identifierJukebox;
+ private InstanceIdentifierContext identifierJukebox;
@Mock
- private InstanceIdentifierContext<ContainerSchemaNode> identifierTestServices;
+ private InstanceIdentifierContext identifierTestServices;
private static final QNameModule Q_NAME_MODULE_JUKEBOX = QNameModule.create(
XMLNamespace.of("http://example.com/ns/example-jukebox"), Revision.of("2015-04-04"));
when(containerNextData.dataChildByName(NEXT_SERVICE_Q_NAME)).thenReturn(leafNextService);
}
- protected abstract List<T> translateFields(InstanceIdentifierContext<?> context, FieldsParam fields);
+ protected abstract List<T> translateFields(InstanceIdentifierContext context, FieldsParam fields);
/**
* Test parse fields parameter containing only one child selected.
@RunWith(MockitoJUnitRunner.class)
public class NetconfFieldsTranslatorTest extends AbstractFieldsTranslatorTest<YangInstanceIdentifier> {
@Override
- protected List<YangInstanceIdentifier> translateFields(final InstanceIdentifierContext<?> context,
+ protected List<YangInstanceIdentifier> translateFields(final InstanceIdentifierContext context,
final FieldsParam fields) {
return NetconfFieldsTranslator.translate(context, fields);
}
@Before
public void setup() throws Exception {
- this.mountPointService = new DOMMountPointServiceImpl();
+ mountPointService = new DOMMountPointServiceImpl();
// create and register mount point
final YangInstanceIdentifier mountPointId = YangInstanceIdentifier.builder()
.getInstance();
// register mount point with null schema context
- when(this.mockMountPointService.getMountPoint(YangInstanceIdentifier.empty()))
- .thenReturn(Optional.of(this.mockMountPoint));
+ when(mockMountPointService.getMountPoint(YangInstanceIdentifier.empty()))
+ .thenReturn(Optional.of(mockMountPoint));
}
/**
*/
@Test
public void toInstanceIdentifierTest() {
- final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext context = ParserIdentifier.toInstanceIdentifier(
TEST_IDENT, SCHEMA_CONTEXT, Optional.empty());
assertEquals("Returned not expected identifier",
*/
@Test
public void toInstanceIdentifierOtherModulesTest() {
- final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext context = ParserIdentifier.toInstanceIdentifier(
TEST_IDENT_OTHERS, SCHEMA_CONTEXT, Optional.empty());
assertEquals("Returned not expected identifier",
*/
@Test
public void toInstanceIdentifierMountPointTest() {
- final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
- MOUNT_POINT_IDENT + "/" + TEST_IDENT, SCHEMA_CONTEXT, Optional.of(this.mountPointService));
+ final InstanceIdentifierContext context = ParserIdentifier.toInstanceIdentifier(
+ MOUNT_POINT_IDENT + "/" + TEST_IDENT, SCHEMA_CONTEXT, Optional.of(mountPointService));
assertEquals("Returned not expected identifier",
TEST_IDENT_RESULT.toString(), context.getInstanceIdentifier().toString());
assertEquals("Mount point not found",
- this.mountPoint, context.getMountPoint());
+ mountPoint, context.getMountPoint());
assertEquals("Schema context from mount point expected",
SCHEMA_CONTEXT_ON_MOUNT_POINT, context.getSchemaContext());
*/
@Test
public void toInstanceIdentifierNullIdentifierTest() {
- final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext context = ParserIdentifier.toInstanceIdentifier(
null, SCHEMA_CONTEXT, Optional.empty());
assertEquals("Returned not expected identifier",
YangInstanceIdentifier.empty(), context.getInstanceIdentifier());
*/
@Test
public void toInstanceIdentifierEmptyIdentifierTest() {
- final InstanceIdentifierContext<?> context = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext context = ParserIdentifier.toInstanceIdentifier(
"", SCHEMA_CONTEXT, Optional.empty());
assertEquals("Returned not expected identifier",
YangInstanceIdentifier.empty(), context.getInstanceIdentifier());
public void toInstanceIdentifierMountPointInvalidIdentifierNegativeTest() {
RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
() -> ParserIdentifier.toInstanceIdentifier(INVALID_MOUNT_POINT_IDENT, SCHEMA_CONTEXT,
- Optional.of(this.mountPointService)));
+ Optional.of(mountPointService)));
}
/**
public void toInstanceIdentifierMissingMountPointNegativeTest() {
RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
() -> ParserIdentifier.toInstanceIdentifier("/yang-ext:mount", SCHEMA_CONTEXT,
- Optional.of(this.mountPointService)));
+ Optional.of(mountPointService)));
final List<RestconfError> errors = ex.getErrors();
assertEquals(1, errors.size());
assertEquals("Not expected error type", ErrorType.PROTOCOL, errors.get(0).getErrorType());
final SchemaExportContext exportContext = ParserIdentifier.toSchemaExportContextFromIdentifier(
SCHEMA_CONTEXT,
MOUNT_POINT_IDENT + "/" + TEST_MODULE_NAME + "/" + TEST_MODULE_REVISION,
- this.mountPointService, sourceProvider);
+ mountPointService, sourceProvider);
final Module module = exportContext.getModule();
assertNotNull("Export context should contains test module", module);
final SchemaExportContext exportContext = ParserIdentifier.toSchemaExportContextFromIdentifier(
SCHEMA_CONTEXT,
MOUNT_POINT_IDENT + "/" + "not-existing-module" + "/" + "2016-01-01",
- this.mountPointService, sourceProvider);
+ mountPointService, sourceProvider);
assertNotNull("Export context should be parsed", exportContext);
assertNull("Not-existing module should be null", exportContext.getModule());
public void toSchemaExportContextFromIdentifierMountPointInvalidIdentifierNegativeTest() {
RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
() -> ParserIdentifier.toSchemaExportContextFromIdentifier(SCHEMA_CONTEXT,
- MOUNT_POINT_IDENT + "/" + TEST_MODULE_REVISION + "/" + TEST_MODULE_NAME, this.mountPointService,
+ MOUNT_POINT_IDENT + "/" + TEST_MODULE_REVISION + "/" + TEST_MODULE_NAME, mountPointService,
sourceProvider));
assertEquals("Not expected error type", ErrorType.PROTOCOL, ex.getErrors().get(0).getErrorType());
@Test
public void toSchemaExportContextFromIdentifierMountPointNullSchemaContextNegativeTest() {
assertThrows(NullPointerException.class, () -> ParserIdentifier.toSchemaExportContextFromIdentifier(null,
- MOUNT_POINT_IDENT + "/" + TEST_MODULE_NAME + "/" + TEST_MODULE_REVISION, this.mountPointService,
+ MOUNT_POINT_IDENT + "/" + TEST_MODULE_NAME + "/" + TEST_MODULE_REVISION, mountPointService,
sourceProvider));
}
public void toSchemaExportContextFromIdentifierNullSchemaContextBehindMountPointNegativeTest() {
assertThrows(IllegalStateException.class, () -> ParserIdentifier.toSchemaExportContextFromIdentifier(
SCHEMA_CONTEXT, "/yang-ext:mount/" + TEST_MODULE_NAME + "/" + TEST_MODULE_REVISION,
- this.mockMountPointService, sourceProvider));
+ mockMountPointService, sourceProvider));
}
/**
*/
@Test
public void invokeRpcTest() {
- final InstanceIdentifierContext<?> result = ParserIdentifier.toInstanceIdentifier(
+ final InstanceIdentifierContext result = ParserIdentifier.toInstanceIdentifier(
INVOKE_RPC, SCHEMA_CONTEXT, Optional.empty());
// RPC schema node
*/
@Test
public void invokeRpcOnMountPointTest() {
- final InstanceIdentifierContext<?> result = ParserIdentifier.toInstanceIdentifier(
- MOUNT_POINT_IDENT + "/" + INVOKE_RPC, SCHEMA_CONTEXT, Optional.of(this.mountPointService));
+ final InstanceIdentifierContext result = ParserIdentifier.toInstanceIdentifier(
+ MOUNT_POINT_IDENT + "/" + INVOKE_RPC, SCHEMA_CONTEXT, Optional.of(mountPointService));
// RPC schema node
final QName rpcQName = result.getSchemaNode().getQName();
// other fields
assertEquals(IdentifierCodec.deserialize(INVOKE_RPC, SCHEMA_CONTEXT), result.getInstanceIdentifier());
- assertEquals(this.mountPoint, result.getMountPoint());
+ assertEquals(mountPoint, result.getMountPoint());
assertEquals(SCHEMA_CONTEXT_ON_MOUNT_POINT, result.getSchemaContext());
}
*/
@Test
public void invokeActionTest() {
- final InstanceIdentifierContext<?> result = ParserIdentifier
+ final InstanceIdentifierContext result = ParserIdentifier
.toInstanceIdentifier(INVOKE_ACTION, SCHEMA_CONTEXT, Optional.empty());
// Action schema node
*/
@Test
public void invokeActionOnMountPointTest() {
- final InstanceIdentifierContext<?> result = ParserIdentifier
+ final InstanceIdentifierContext result = ParserIdentifier
.toInstanceIdentifier(MOUNT_POINT_IDENT + "/" + INVOKE_ACTION, SCHEMA_CONTEXT,
- Optional.of(this.mountPointService));
+ Optional.of(mountPointService));
// Action schema node
final QName actionQName = result.getSchemaNode().getQName();
// other fields
assertEquals(IdentifierCodec.deserialize(INVOKE_ACTION, SCHEMA_CONTEXT), result.getInstanceIdentifier());
- assertEquals(this.mountPoint, result.getMountPoint());
+ assertEquals(mountPoint, result.getMountPoint());
assertEquals(SCHEMA_CONTEXT_ON_MOUNT_POINT, result.getSchemaContext());
}
}
@RunWith(MockitoJUnitRunner.class)
public class WriterFieldsTranslatorTest extends AbstractFieldsTranslatorTest<Set<QName>> {
@Override
- protected List<Set<QName>> translateFields(final InstanceIdentifierContext<?> context, final FieldsParam fields) {
+ protected List<Set<QName>> translateFields(final InstanceIdentifierContext context, final FieldsParam fields) {
return WriterFieldsTranslator.translate(context, fields);
}
Code Review / netconf.git / commitdiff