import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
public final class JsonPatchBody extends PatchBody {
}
@Override
- PatchContext toPatchContext(final EffectiveModelContext context, final YangInstanceIdentifier urlPath,
+ PatchContext toPatchContext(final DatabindContext databind, final YangInstanceIdentifier urlPath,
final InputStream inputStream) throws IOException {
try (var jsonReader = new JsonReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
final var patchId = new AtomicReference<String>();
- final var resultList = read(jsonReader, context, urlPath, patchId);
+ final var resultList = read(jsonReader, databind, urlPath, patchId);
// Note: patchId side-effect of above
return new PatchContext(patchId.get(), resultList);
}
}
- private static ImmutableList<PatchEntity> read(final JsonReader in, final EffectiveModelContext context,
+ private static ImmutableList<PatchEntity> read(final JsonReader in, final DatabindContext databind,
final YangInstanceIdentifier urlPath, final AtomicReference<String> patchId) throws IOException {
- final var schemaTree = DataSchemaContextTree.from(context);
final var edits = ImmutableList.<PatchEntity>builder();
final var edit = new PatchEdit();
case END_DOCUMENT:
break;
case NAME:
- parseByName(in.nextName(), edit, in, urlPath, schemaTree, edits, patchId);
+ parseByName(in.nextName(), edit, in, urlPath, databind, edits, patchId);
break;
case END_OBJECT:
in.endObject();
// Switch value of parsed JsonToken.NAME and read edit definition or patch id
private static void parseByName(final @NonNull String name, final @NonNull PatchEdit edit,
final @NonNull JsonReader in, final @NonNull YangInstanceIdentifier urlPath,
- final @NonNull Data
SchemaContextTree schemaTree, final @NonNull Builder<PatchEntity> resultCollection,
+ final @NonNull Data
bindContext databind, final @NonNull Builder<PatchEntity> resultCollection,
final @NonNull AtomicReference<String> patchId) throws IOException {
switch (name) {
case "edit":
in.beginArray();
while (in.hasNext()) {
- readEditDefinition(edit, in, urlPath, schemaTree);
+ readEditDefinition(edit, in, urlPath, databind);
resultCollection.add(prepareEditOperation(edit));
edit.clear();
}
in.endArray();
} else {
- readEditDefinition(edit, in, urlPath, schemaTree);
+ readEditDefinition(edit, in, urlPath, databind);
resultCollection.add(prepareEditOperation(edit));
edit.clear();
}
// Read one patch edit object from JSON input
private static void readEditDefinition(final @NonNull PatchEdit edit, final @NonNull JsonReader in,
- final @NonNull YangInstanceIdentifier urlPath, final @NonNull DataSchemaContextTree schemaTree)
+ final @NonNull YangInstanceIdentifier urlPath, final @NonNull DatabindContext databind)
throws IOException {
String deferredValue = null;
in.beginObject();
break;
case "target":
// target can be specified completely in request URI
- edit.setTarget(parsePatchTarget(schemaTree.getEffectiveModelContext(), urlPath, in.nextString()));
- final var stack = schemaTree.enterPath(edit.getTarget()).orElseThrow().stack();
+ edit.setTarget(parsePatchTarget(databind, urlPath, in.nextString()));
+ final var stack = databind.schemaTree().enterPath(edit.getTarget()).orElseThrow().stack();
if (!stack.isEmpty()) {
stack.exit();
}
if (!stack.isEmpty()) {
- final EffectiveStatement<?, ?> parentStmt = stack.currentStatement();
+ final var parentStmt = stack.currentStatement();
verify(parentStmt instanceof SchemaNode, "Unexpected parent %s", parentStmt);
}
edit.setTargetSchemaNode(stack.toInference());
deferredValue = readValueNode(in);
} else {
// We have a target schema node, reuse this reader without buffering the value.
- edit.setData(readEditData(in, edit.getTargetSchemaNode(),
- schemaTree.getEffectiveModelContext()));
+ edit.setData(readEditData(in, edit.getTargetSchemaNode(), databind.modelContext()));
}
break;
default:
if (deferredValue != null) {
// read saved data to normalized node when target schema is already known
edit.setData(readEditData(new JsonReader(new StringReader(deferredValue)), edit.getTargetSchemaNode(),
- schemaTree.getEffectiveModelContext()));
+ databind.modelContext()));
}
}
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* A YANG Patch body.
super(inputStream);
}
- public final @NonNull PatchContext toPatchContext(final @NonNull EffectiveModelContext context,
+ public final @NonNull PatchContext toPatchContext(final @NonNull DatabindContext databind,
final @NonNull YangInstanceIdentifier urlPath) throws IOException {
try (var is = acquireStream()) {
- return toPatchContext(context, urlPath, is);
+ return toPatchContext(databind, urlPath, is);
}
}
- abstract @NonNull PatchContext toPatchContext(@NonNull EffectiveModelContext context,
+ abstract @NonNull PatchContext toPatchContext(@NonNull DatabindContext databind,
@NonNull YangInstanceIdentifier urlPath, @NonNull InputStream inputStream) throws IOException;
- static final YangInstanceIdentifier parsePatchTarget(final EffectiveModelContext context,
+ static final YangInstanceIdentifier parsePatchTarget(final DatabindContext databind,
final YangInstanceIdentifier urlPath, final String target) {
if (target.equals("/")) {
verify(!urlPath.isEmpty(),
if (urlPath.isEmpty()) {
targetUrl = target.startsWith("/") ? target.substring(1) : target;
} else {
- targetUrl = IdentifierCodec.serialize(urlPath, context) + target;
+ targetUrl = IdentifierCodec.serialize(urlPath, databind.modelContext()) + target;
}
try {
- return InstanceIdentifierContext.ofApiPath(ApiPath.parse(targetUrl), context, null).getInstanceIdentifier();
+ return InstanceIdentifierContext.ofApiPath(ApiPath.parse(targetUrl), databind, null)
+ .getInstanceIdentifier();
} catch (ParseException | RestconfDocumentedException e) {
throw new RestconfDocumentedException("Failed to parse target " + target,
ErrorType.RPC, ErrorTag.MALFORMED_MESSAGE, e);
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
}
@Override
- PatchContext toPatchContext(final EffectiveModelContext context, final YangInstanceIdentifier urlPath,
+ PatchContext toPatchContext(final DatabindContext databind, final YangInstanceIdentifier urlPath,
final InputStream inputStream) throws IOException {
try {
- return parse(context, urlPath, UntrustedXML.newDocumentBuilder().parse(inputStream));
+ return parse(databind, urlPath, UntrustedXML.newDocumentBuilder().parse(inputStream));
} catch (XMLStreamException | SAXException | URISyntaxException e) {
LOG.debug("Failed to parse YANG Patch XML", e);
throw new RestconfDocumentedException("Error parsing YANG Patch XML: " + e.getMessage(), ErrorType.PROTOCOL,
}
}
- private static @NonNull PatchContext parse(final EffectiveModelContext context,
- final YangInstanceIdentifier urlPath, final Document doc)
- throws XMLStreamException, IOException, SAXException, URISyntaxException {
+ private static @NonNull PatchContext parse(final DatabindContext databind, final YangInstanceIdentifier urlPath,
+ final Document doc) throws XMLStreamException, IOException, SAXException, URISyntaxException {
final var entities = ImmutableList.<PatchEntity>builder();
final var patchId = doc.getElementsByTagName("patch-id").item(0).getFirstChild().getNodeValue();
final var editNodes = doc.getElementsByTagName("edit");
- final var schemaTree = DataSchemaContextTree.from(context);
for (int i = 0; i < editNodes.getLength(); i++) {
final Element element = (Element) editNodes.item(i);
final Element firstValueElement = values != null ? values.get(0) : null;
// find complete path to target, it can be also empty (only slash)
- final var targetII = parsePatchTarget(context, urlPath, target);
+ final var targetII = parsePatchTarget(databind, urlPath, target);
// move schema node
- final var lookup = schemaTree.enterPath(targetII).orElseThrow();
+ final var lookup = databind.schemaTree().enterPath(targetII).orElseThrow();
final var stack = lookup.stack();
final var inference = stack.toInference();
}
if (requiresValue(oper)) {
- final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
- final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, inference);
+ final var resultHolder = new NormalizationResultHolder();
+ final var writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
+ final var xmlParser = XmlParserStream.create(writer, inference);
xmlParser.traverse(new DOMSource(firstValueElement));
final var result = resultHolder.getResult().data();
import org.opendaylight.restconf.api.ApiPath;
import org.opendaylight.restconf.api.ApiPath.Step;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.IdentifierCodec;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.YangInstanceIdentifierDeserializer;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
public abstract class InstanceIdentifierContext {
private static final class Root extends InstanceIdentifierContext {
- private final @NonNull EffectiveModelContext context;
-
- Root(final EffectiveModelContext context, final DOMMountPoint mountPoint) {
- super(context, mountPoint);
- this.context = requireNonNull(context);
- }
-
- @Override
- public EffectiveModelContext getSchemaContext() {
- return context;
+ Root(final DatabindContext databind, final DOMMountPoint mountPoint) {
+ super(databind, databind.modelContext(), mountPoint);
}
@Override
@Override
public Inference inference() {
- return SchemaInferenceStack.of(context).toInference();
+ return SchemaInferenceStack.of(getSchemaContext()).toInference();
}
}
private final @NonNull YangInstanceIdentifier path;
private final @NonNull SchemaInferenceStack stack;
- private DataPath(final SchemaNode schemaNode, final DOMMountPoint mountPoint,
+ private DataPath(final DatabindContext databind, final SchemaNode schemaNode, final DOMMountPoint mountPoint,
final SchemaInferenceStack stack, final YangInstanceIdentifier path) {
- super(schemaNode, mountPoint);
+ super(databind, schemaNode, mountPoint);
this.stack = requireNonNull(stack);
this.path = requireNonNull(path);
}
- static @NonNull DataPath of(final EffectiveModelContext context, final YangInstanceIdentifier path,
+ static @NonNull DataPath of(final DatabindContext databind, final YangInstanceIdentifier path,
final DOMMountPoint mountPoint) {
- final var nodeAndStack = DataSchemaContextTree.from(context).enterPath(path).orElseThrow();
- return new DataPath(nodeAndStack.node().dataSchemaNode(), mountPoint, nodeAndStack.stack(), path);
+ final var nodeAndStack = databind.schemaTree().enterPath(path).orElseThrow();
+ return new DataPath(databind, nodeAndStack.node().dataSchemaNode(), mountPoint, nodeAndStack.stack(), path);
}
@Override
private static final class WithoutDataPath extends InstanceIdentifierContext {
private final @NonNull SchemaInferenceStack stack;
- private WithoutDataPath(final SchemaNode schemaNode, final DOMMountPoint mountPoint,
- final SchemaInferenceStack stack) {
- super(schemaNode, mountPoint);
+ private WithoutDataPath(final DatabindContext databind, final SchemaNode schemaNode,
+ final DOMMountPoint mountPoint, final SchemaInferenceStack stack) {
+ super(databind, schemaNode, mountPoint);
this.stack = requireNonNull(stack);
}
}
}
+ private final @NonNull DatabindContext databind;
private final @NonNull SchemaNode schemaNode;
private final @Nullable DOMMountPoint mountPoint;
- InstanceIdentifierContext(final SchemaNode schemaNode, final DOMMountPoint mountPoint) {
+ InstanceIdentifierContext(final DatabindContext databind, final SchemaNode schemaNode,
+ final DOMMountPoint mountPoint) {
+ this.databind = requireNonNull(databind);
this.schemaNode = requireNonNull(schemaNode);
this.mountPoint = mountPoint;
}
// FIXME: NETCONF-773: this recursion should really live in MdsalRestconfServer
- public static @NonNull InstanceIdentifierContext ofApiPath(final ApiPath path,
- final EffectiveModelContext modelContext, final DOMMountPointService mountPointService) {
+ public static @NonNull InstanceIdentifierContext ofApiPath(final ApiPath path, final DatabindContext databind,
+ final DOMMountPointService mountPointService) {
final var steps = path.steps();
final var limit = steps.size() - 1;
var prefix = 0;
DOMMountPoint currentMountPoint = null;
- var currentModelContext = modelContext;
+ var currentDatabind = databind;
while (prefix <= limit) {
final var mount = indexOfMount(steps, prefix, limit);
if (mount == -1) {
ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED);
}
- final var mountPath = IdentifierCodec.deserialize(path.subPath(prefix, mount), modelContext);
+ final var mountPath = IdentifierCodec.deserialize(path.subPath(prefix, mount), databind.modelContext());
final var userPath = path.subPath(0, mount);
final var nextMountPoint = mountService.getMountPoint(mountPath)
.orElseThrow(() -> new RestconfDocumentedException("Mount point '" + userPath + "' does not exist",
}
prefix = mount + 1;
- currentModelContext = nextModelContext;
+ currentDatabind = DatabindContext.ofModel(nextModelContext);
currentMountPoint = nextMountPoint;
}
- final var result = YangInstanceIdentifierDeserializer.create(currentModelContext, path.subPath(prefix));
- return InstanceIdentifierContext.ofPath(result.stack, result.node, result.path, currentMountPoint);
+ final var result = YangInstanceIdentifierDeserializer.create(currentDatabind.modelContext(),
+ path.subPath(prefix));
+ return InstanceIdentifierContext.ofPath(currentDatabind, result.stack, result.node, result.path,
+ currentMountPoint);
}
private static int indexOfMount(final ImmutableList<Step> steps, final int fromIndex, final int limit) {
return -1;
}
- public static @NonNull InstanceIdentifierContext ofLocalRoot(final EffectiveModelContext context) {
- return new Root(context, null);
+ public static @NonNull InstanceIdentifierContext ofLocalRoot(final DatabindContext databind) {
+ return new Root(databind, null);
}
@VisibleForTesting
- public static @NonNull InstanceIdentifierContext ofLocalPath(final EffectiveModelContext context,
+ public static @NonNull InstanceIdentifierContext ofLocalPath(final DatabindContext databind,
final YangInstanceIdentifier path) {
- return DataPath.of(context, path, null);
+ return DataPath.of(databind, path, null);
}
// Invocations of various identifier-less details
- public static @NonNull InstanceIdentifierContext ofStack(final SchemaInferenceStack stack) {
- return ofStack(stack, null);
+ public static @NonNull InstanceIdentifierContext ofStack(final DatabindContext databind,
+ final SchemaInferenceStack stack) {
+ return ofStack(databind, stack, null);
}
// Invocations of various identifier-less details, potentially having a mount point
- public static @NonNull InstanceIdentifierContext ofStack(final SchemaInferenceStack stack,
- final @Nullable DOMMountPoint mountPoint) {
+ public static @NonNull InstanceIdentifierContext ofStack(final DatabindContext databind,
+ final SchemaInferenceStack stack, final @Nullable DOMMountPoint mountPoint) {
final SchemaNode schemaNode;
if (!stack.isEmpty()) {
final var stmt = stack.currentStatement();
schemaNode = stack.getEffectiveModelContext();
}
- return new WithoutDataPath(schemaNode, mountPoint, stack);
+ return new WithoutDataPath(databind, schemaNode, mountPoint, stack);
}
- public static @NonNull InstanceIdentifierContext ofPath(final SchemaInferenceStack stack,
- final SchemaNode schemaNode, final YangInstanceIdentifier path,
+ public static @NonNull InstanceIdentifierContext ofPath(final DatabindContext databind,
+ final SchemaInferenceStack stack, final SchemaNode schemaNode, final YangInstanceIdentifier path,
final @Nullable DOMMountPoint mountPoint) {
- return new DataPath(schemaNode, mountPoint, stack, path);
+ return new DataPath(databind, schemaNode, mountPoint, stack, path);
}
- public static @NonNull InstanceIdentifierContext ofMountPointRoot(final DOMMountPoint mountPoint,
- final EffectiveModelContext mountContext) {
- return new Root(mountContext, requireNonNull(mountPoint));
+ public static @NonNull InstanceIdentifierContext ofMountPointRoot(final DatabindContext databind,
+ final DOMMountPoint mountPoint) {
+ return new Root(databind, requireNonNull(mountPoint));
}
@VisibleForTesting
- public static @NonNull InstanceIdentifierContext ofMountPointPath(final DOMMountPoint mountPoint,
- final EffectiveModelContext context, final YangInstanceIdentifier path) {
- return DataPath.of(context, path, requireNonNull(mountPoint));
+ public static @NonNull InstanceIdentifierContext ofMountPointPath(final DatabindContext databind,
+ final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
+ return DataPath.of(databind, path, requireNonNull(mountPoint));
+ }
+
+ public final @NonNull DatabindContext databind() {
+ return databind;
}
public final @NonNull SchemaNode getSchemaNode() {
return mountPoint;
}
- public @NonNull EffectiveModelContext getSchemaContext() {
- return inference().getEffectiveModelContext();
+ @Deprecated(forRemoval = true)
+ public final @NonNull EffectiveModelContext getSchemaContext() {
+ return databind.modelContext();
}
public abstract @NonNull Inference inference();
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.SettableRestconfFuture;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.server.spi.RpcImplementation;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Implementation of RESTCONF operations using {@link DOMTransactionChain} and related concepts.
public final class MdsalRestconfStrategy extends RestconfStrategy {
private final DOMDataBroker dataBroker;
- public MdsalRestconfStrategy(final EffectiveModelContext modelContext, final DOMDataBroker dataBroker,
+ public MdsalRestconfStrategy(final DatabindContext databind, final DOMDataBroker dataBroker,
final @Nullable DOMRpcService rpcService, final @Nullable DOMYangTextSourceProvider sourceProvider,
final ImmutableMap<QName, RpcImplementation> localRpcs) {
- super(modelContext, localRpcs, rpcService, sourceProvider);
+ super(databind, localRpcs, rpcService, sourceProvider);
this.dataBroker = requireNonNull(dataBroker);
}
- public MdsalRestconfStrategy(final EffectiveModelContext modelContext, final DOMDataBroker dataBroker,
+ public MdsalRestconfStrategy(final DatabindContext databind, final DOMDataBroker dataBroker,
final @Nullable DOMRpcService rpcService, final @Nullable DOMYangTextSourceProvider sourceProvider) {
- this(modelContext, dataBroker, rpcService, sourceProvider, ImmutableMap.of());
+ this(databind, dataBroker, rpcService, sourceProvider, ImmutableMap.of());
}
@Override
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.errors.SettableRestconfFuture;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Implementation of RESTCONF operations on top of a raw NETCONF backend.
public final class NetconfRestconfStrategy extends RestconfStrategy {
private final NetconfDataTreeService netconfService;
- public NetconfRestconfStrategy(final EffectiveModelContext modelContext,
- final NetconfDataTreeService netconfService, final @Nullable DOMRpcService rpcService,
- final @Nullable DOMYangTextSourceProvider sourceProvider) {
- super(modelContext, ImmutableMap.of(), rpcService, sourceProvider);
+ public NetconfRestconfStrategy(final DatabindContext databind, final NetconfDataTreeService netconfService,
+ final @Nullable DOMRpcService rpcService, final @Nullable DOMYangTextSourceProvider sourceProvider) {
+ super(databind, ImmutableMap.of(), rpcService, sourceProvider);
this.netconfService = requireNonNull(netconfService);
}
private final DOMYangTextSourceProvider sourceProvider;
private final DOMRpcService rpcService;
- RestconfStrategy(final EffectiveModelContext modelContext, final ImmutableMap<QName, RpcImplementation> localRpcs,
+ RestconfStrategy(final DatabindContext databind, final ImmutableMap<QName, RpcImplementation> localRpcs,
final @Nullable DOMRpcService rpcService, final DOMYangTextSourceProvider sourceProvider) {
- // FIXME: pass this down
- databind = DatabindContext.ofModel(modelContext);
+ this.databind = requireNonNull(databind);
this.localRpcs = requireNonNull(localRpcs);
this.rpcService = rpcService;
this.sourceProvider = sourceProvider;
/**
* Look up the appropriate strategy for a particular mount point.
*
- * @param modelContext {@link EffectiveModelContext} of target mount point
+ * @param databind {@link DatabindContext} of target mount point
* @param mountPoint Target mount point
* @return A strategy, or null if the mount point does not expose a supported interface
* @throws NullPointerException if any argument is {@code null}
*/
- public static @Nullable RestconfStrategy forMountPoint(final EffectiveModelContext modelContext,
+ public static @Nullable RestconfStrategy forMountPoint(final DatabindContext databind,
final DOMMountPoint mountPoint) {
final var rpcService = mountPoint.getService(DOMRpcService.class).orElse(null);
final var sourceProvider = mountPoint.getService(DOMSchemaService.class)
final var netconfService = mountPoint.getService(NetconfDataTreeService.class);
if (netconfService.isPresent()) {
- return new NetconfRestconfStrategy(modelContext, netconfService.orElseThrow(), rpcService, sourceProvider);
+ return new NetconfRestconfStrategy(databind, netconfService.orElseThrow(), rpcService, sourceProvider);
}
final var dataBroker = mountPoint.getService(DOMDataBroker.class);
if (dataBroker.isPresent()) {
- return new MdsalRestconfStrategy(modelContext, dataBroker.orElseThrow(), rpcService, sourceProvider);
+ return new MdsalRestconfStrategy(databind, dataBroker.orElseThrow(), rpcService, sourceProvider);
}
return null;
}
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.api.ApiPath;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
throw new RestconfDocumentedException(e.getMessage(), ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, e);
}
- return InstanceIdentifierContext.ofApiPath(apiPath, schemaContext, mountPointService);
+ return InstanceIdentifierContext.ofApiPath(apiPath, DatabindContext.ofModel(schemaContext), mountPointService);
}
}
this.localRpcs = Maps.uniqueIndex(localRpcs, RpcImplementation::qname);
sourceProvider = schemaService.getExtensions().getInstance(DOMYangTextSourceProvider.class);
- localStrategy = new MdsalRestconfStrategy(schemaService.getGlobalContext(), dataBroker, rpcService,
- sourceProvider, this.localRpcs);
+ localStrategy = createLocalStrategy(schemaService.getGlobalContext());
reg = schemaService.registerSchemaContextListener(this);
}
public void onModelContextUpdated(final EffectiveModelContext newModelContext) {
final var local = localStrategy();
if (!newModelContext.equals(local.modelContext())) {
- LOCAL_STRATEGY.setRelease(this,
- new MdsalRestconfStrategy(newModelContext, dataBroker, rpcService, sourceProvider, localRpcs));
+ LOCAL_STRATEGY.setRelease(this, createLocalStrategy(newModelContext));
}
}
+ private @NonNull MdsalRestconfStrategy createLocalStrategy(final EffectiveModelContext modelContext) {
+ return new MdsalRestconfStrategy(DatabindContext.ofModel(modelContext), dataBroker, rpcService, sourceProvider,
+ localRpcs);
+ }
+
private @NonNull MdsalRestconfStrategy localStrategy() {
return verifyNotNull((MdsalRestconfStrategy) LOCAL_STRATEGY.getAcquire(this));
}
@Deprecated(forRemoval = true)
- private @NonNull MdsalRestconfStrategy localStrategy(final EffectiveModelContext modelContext) {
+ private @NonNull MdsalRestconfStrategy localStrategy(final DatabindContext databind) {
final var local = localStrategy();
- if (local.modelContext().equals(modelContext)) {
- return local;
- }
- return new MdsalRestconfStrategy(modelContext, dataBroker, rpcService, sourceProvider, localRpcs);
+ return local.databind().equals(databind) ? local
+ : new MdsalRestconfStrategy(databind, dataBroker, rpcService, sourceProvider, localRpcs);
}
@PreDestroy
@Override
public RestconfFuture<Empty> dataDELETE(final ApiPath identifier) {
final var reqPath = bindRequestPath(identifier);
- final var strategy = getRestconfStrategy(reqPath.getSchemaContext(), reqPath.getMountPoint());
+ final var strategy = getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint());
return strategy.delete(reqPath.getInstanceIdentifier());
}
}
final var fieldPaths = queryParams.fieldPaths();
- final var strategy = getRestconfStrategy(reqPath.getSchemaContext(), reqPath.getMountPoint());
+ final var strategy = getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint());
final NormalizedNode node;
if (fieldPaths != null && !fieldPaths.isEmpty()) {
node = strategy.readData(readParams.content(), reqPath.getInstanceIdentifier(), readParams.withDefaults(),
private @NonNull RestconfFuture<PatchStatusContext> dataPATCH(final InstanceIdentifierContext reqPath,
final PatchBody body) {
- final var modelContext = reqPath.getSchemaContext();
final PatchContext patch;
try {
- patch = body.toPatchContext(modelContext, reqPath.getInstanceIdentifier());
+ patch = body.toPatchContext(reqPath.databind(), reqPath.getInstanceIdentifier());
} catch (IOException e) {
LOG.debug("Error parsing YANG Patch input", e);
return RestconfFuture.failed(new RestconfDocumentedException("Error parsing input: " + e.getMessage(),
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE, e));
}
- return getRestconfStrategy(modelContext, reqPath.getMountPoint()).patchData(patch);
+ return getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint()).patchData(patch);
}
@Override
private @NonNull RestconfFuture<CreateResource> dataCreatePOST(final InstanceIdentifierContext reqPath,
final ChildBody body, final Map<String, String> queryParameters) {
final var inference = reqPath.inference();
- final var modelContext = inference.getEffectiveModelContext();
final Insert insert;
try {
- insert = Insert.ofQueryParameters(modelContext, queryParameters);
+ insert = Insert.ofQueryParameters(inference.getEffectiveModelContext(), queryParameters);
} catch (IllegalArgumentException e) {
return RestconfFuture.failed(new RestconfDocumentedException(e.getMessage(),
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, e));
final var parentPath = reqPath.getInstanceIdentifier();
final var payload = body.toPayload(parentPath, inference);
- return getRestconfStrategy(modelContext, reqPath.getMountPoint())
+ return getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint())
.postData(concat(parentPath, payload.prefix()), payload.body(), insert);
}
final InstanceIdentifierContext point;
try {
- point = InstanceIdentifierContext.ofApiPath(mountPath, localStrategy().modelContext(), mountPointService);
+ point = InstanceIdentifierContext.ofApiPath(mountPath, localStrategy().databind(), mountPointService);
} catch (RestconfDocumentedException e) {
return RestconfFuture.failed(e);
}
- final var mountPoint = point.getMountPoint();
- final var modelContext = point.getSchemaContext();
final RestconfStrategy strategy;
try {
- strategy = forMountPoint(modelContext, mountPoint);
+ strategy = forMountPoint(point.databind(), point.getMountPoint());
} catch (RestconfDocumentedException e) {
return RestconfFuture.failed(e);
}
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE, e));
}
- final var strategy = getRestconfStrategy(reqPath.getSchemaContext(), reqPath.getMountPoint());
+ final var strategy = getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint());
return strategy.invokeRpc(restconfURI, reqPath.getSchemaNode().getQName(),
new OperationInput(strategy.databind(), inference, input));
}
private @NonNull InstanceIdentifierContext bindRequestPath(final @NonNull MdsalRestconfStrategy strategy,
final @NonNull ApiPath identifier) {
// FIXME: DatabindContext looks like it should be internal
- return InstanceIdentifierContext.ofApiPath(identifier, strategy.modelContext(), mountPointService);
+ return InstanceIdentifierContext.ofApiPath(identifier, strategy.databind(), mountPointService);
}
private @NonNull InstanceIdentifierContext bindRequestRoot() {
- return InstanceIdentifierContext.ofLocalRoot(localStrategy().modelContext());
+ return InstanceIdentifierContext.ofLocalRoot(localStrategy().databind());
}
private @NonNull ResourceRequest bindResourceRequest(final InstanceIdentifierContext reqPath,
final ResourceBody body) {
- final var inference = reqPath.inference();
final var path = reqPath.getInstanceIdentifier();
- final var data = body.toNormalizedNode(path, inference, reqPath.getSchemaNode());
+ final var data = body.toNormalizedNode(path, reqPath.inference(), reqPath.getSchemaNode());
- return new ResourceRequest(
- getRestconfStrategy(inference.getEffectiveModelContext(), reqPath.getMountPoint()), path, data);
+ return new ResourceRequest(getRestconfStrategy(reqPath.databind(), reqPath.getMountPoint()), path, data);
}
@VisibleForTesting
- @NonNull RestconfStrategy getRestconfStrategy(final EffectiveModelContext modelContext,
+ @NonNull RestconfStrategy getRestconfStrategy(final DatabindContext databind,
final @Nullable DOMMountPoint mountPoint) {
if (mountPoint == null) {
- return localStrategy(modelContext);
+ return localStrategy(databind);
}
- return forMountPoint(modelContext, mountPoint);
+ return forMountPoint(databind, mountPoint);
}
- private static @NonNull RestconfStrategy forMountPoint(final EffectiveModelContext modelContext,
+ private static @NonNull RestconfStrategy forMountPoint(final DatabindContext databind,
final DOMMountPoint mountPoint) {
- final var ret = RestconfStrategy.forMountPoint(modelContext, mountPoint);
+ final var ret = RestconfStrategy.forMountPoint(databind, mountPoint);
if (ret == null) {
final var mountId = mountPoint.getIdentifier();
LOG.warn("Mount point {} does not expose a suitable access interface", mountId);
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
protected static final EffectiveModelContext IID_SCHEMA =
YangParserTestUtils.parseYangResourceDirectory("/instanceidentifier/yang");
+ protected static final DatabindContext IID_DATABIND = DatabindContext.ofModel(IID_SCHEMA);
protected static final InputStream stringInputStream(final String str) {
return new ByteArrayInputStream(str.getBytes(StandardCharsets.UTF_8));
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
protected static final @NonNull EffectiveModelContext JUKEBOX_SCHEMA =
YangParserTestUtils.parseYangResourceDirectory("/jukebox");
+ protected static final @NonNull DatabindContext JUKEBOX_DATABIND = DatabindContext.ofModel(JUKEBOX_SCHEMA);
protected static final InputStream stringInputStream(final String str) {
return new ByteArrayInputStream(str.getBytes(StandardCharsets.UTF_8));
throw new AssertionError(e);
}
- final var iid = InstanceIdentifierContext.ofApiPath(apiPath, IID_SCHEMA, mountPointService);
+ final var iid = InstanceIdentifierContext.ofApiPath(apiPath, IID_DATABIND, mountPointService);
try (var body = bodyConstructor.apply(stringInputStream(patchBody))) {
- return body.toPatchContext(iid.getSchemaContext(), iid.getInstanceIdentifier());
+ return body.toPatchContext(iid.databind(), iid.getInstanceIdentifier());
}
}
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
abstract class AbstractResourceBodyTest extends AbstractBodyTest {
static final QName LF11 = QName.create("augment:module:leaf:list", "2014-01-27", "lf11");
static final QName LFLST11 = QName.create(LF11, "lflst11");
- static EffectiveModelContext MODEL_CONTEXT;
+ private static DatabindContext DATABIND;
private final Function<InputStream, ResourceBody> bodyConstructor;
private final DOMMountPointService mountPointService;
final var testFiles = loadFiles("/instanceidentifier/yang");
testFiles.addAll(loadFiles("/modules"));
testFiles.addAll(loadFiles("/foo-xml-test/yang"));
- MODEL_CONTEXT = YangParserTestUtils.parseYangFiles(testFiles);
+ DATABIND = DatabindContext.ofModel(YangParserTestUtils.parseYangFiles(testFiles));
}
// FIXME: migrate callers to use string literals
}
try (var body = bodyConstructor.apply(patchBody)) {
- final var context = InstanceIdentifierContext.ofApiPath(apiPath, MODEL_CONTEXT, mountPointService);
+ final var context = InstanceIdentifierContext.ofApiPath(apiPath, DATABIND, mountPointService);
return body.toNormalizedNode(context.getInstanceIdentifier(), context.inference(), context.getSchemaNode());
}
}
.node(PLAYLIST_QNAME)
.nodeWithKey(PLAYLIST_QNAME, NAME_QNAME, "name of band")
.build();
- final var iidContext = InstanceIdentifierContext.ofLocalPath(JUKEBOX_SCHEMA, path);
+ final var iidContext = InstanceIdentifierContext.ofLocalPath(JUKEBOX_DATABIND, path);
ResourceBody.validateListKeysEqualityInPayloadAndUri(iidContext.getSchemaNode(), path, BAND_ENTRY);
}
}
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.Insert;
import org.opendaylight.restconf.nb.rfc8040.ReceiveEventsParams;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.QueryParameters;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.WriterFieldsTranslator;
final var stack = SchemaInferenceStack.of(context);
stack.enterSchemaTree(containerQName);
- final var iid = InstanceIdentifierContext.ofStack(stack);
+ final var iid = InstanceIdentifierContext.ofStack(DatabindContext.ofModel(context), stack);
final var queryParameters = QueryParameters.ofFields(params, WriterFieldsTranslator.translate(
iid.getSchemaContext(), (DataSchemaNode) iid.getSchemaNode(), paramsFields));
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
import java.util.Optional;
-import org.junit.AfterClass;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.opendaylight.restconf.api.query.ContentParam;
import org.opendaylight.restconf.api.query.WithDefaultsParam;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.DOMException;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public final class MdsalRestconfStrategyTest extends AbstractRestconfStrategyTest {
- private static EffectiveModelContext MODULES_SCHEMA;
+ private static final DatabindContext MODULES_DATABIND = DatabindContext.ofModel(
+ YangParserTestUtils.parseYangResourceDirectory("/modules"));
@Mock
private DOMDataTreeReadWriteTransaction readWrite;
@Mock
private DOMRpcService rpcService;
- @BeforeClass
- public static void setupModulesSchema() {
- MODULES_SCHEMA = YangParserTestUtils.parseYangResourceDirectory("/modules");
- }
-
- @AfterClass
- public static void dropModulesSchema() {
- MODULES_SCHEMA = null;
- }
+ private DatabindContext mockDatabind;
@Before
public void before() {
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
+ mockDatabind = DatabindContext.ofModel(mockSchemaContext);
}
@Override
// assert that data to delete exists
when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of()))
.thenReturn(immediateTrueFluentFuture());
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
// assert that data to delete does NOT exist
when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of()))
.thenReturn(immediateFalseFluentFuture());
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doReturn(immediateFailedFluentFuture(domException)).when(readWrite).commit();
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Test
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null).putData(JUKEBOX_IID, EMPTY_JUKEBOX, null);
+ new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null)
+ .putData(JUKEBOX_IID, EMPTY_JUKEBOX, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
}
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null).putData(GAP_IID, GAP_LEAF, null);
+ new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null).putData(GAP_IID, GAP_LEAF, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, GAP_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF);
}
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null)
+ new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null)
.putData(JUKEBOX_IID, JUKEBOX_WITH_BANDS, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS);
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy testPatchContainerDataStrategy() {
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy testPatchLeafDataStrategy() {
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy testPatchListDataStrategy() {
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy testPatchDataReplaceMergeAndRemoveStrategy() {
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, PLAYER_IID);
doReturn(immediateTrueFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
CREATE_AND_DELETE_TARGET);
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy testPatchMergePutContainerStrategy() {
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
RestconfStrategy deleteNonexistentDataTestStrategy() {
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
CREATE_AND_DELETE_TARGET);
- return new MdsalRestconfStrategy(JUKEBOX_SCHEMA, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(JUKEBOX_DATABIND, mockDataBroker, null, null);
}
@Override
doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFluentFuture(Optional.of(DATA_3))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.CONFIGURATION, PATH);
doReturn(immediateFluentFuture(Optional.empty())).when(read)
.read(LogicalDatastoreType.OPERATIONAL, PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, PATH_2);
doReturn(immediateFluentFuture(Optional.empty())).when(read)
.read(LogicalDatastoreType.CONFIGURATION, PATH_2);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFluentFuture(Optional.of(DATA_2))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, PATH_2);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.CONFIGURATION, PATH);
doReturn(immediateFluentFuture(Optional.of(DATA_4))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.CONFIGURATION, PATH);
doReturn(immediateFluentFuture(Optional.of(DATA_4))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, PATH_3);
doReturn(immediateFluentFuture(Optional.of(LIST_DATA_2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, PATH_3);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, PATH_3);
doReturn(immediateFluentFuture(Optional.of(ORDERED_MAP_NODE_2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, PATH_3);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, PATH_3);
doReturn(immediateFluentFuture(Optional.of(UNKEYED_LIST_NODE_2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, PATH_3);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, LEAF_SET_NODE_PATH);
doReturn(immediateFluentFuture(Optional.of(LEAF_SET_NODE_2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, LEAF_SET_NODE_PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
.read(LogicalDatastoreType.OPERATIONAL, LEAF_SET_NODE_PATH);
doReturn(immediateFluentFuture(Optional.of(ORDERED_LEAF_SET_NODE_2))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, LEAF_SET_NODE_PATH);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Override
RestconfStrategy readDataWrongPathOrNoContentTestStrategy() {
doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFluentFuture(Optional.empty())).when(read).read(LogicalDatastoreType.CONFIGURATION, PATH_2);
- return new MdsalRestconfStrategy(mockSchemaContext, mockDataBroker, null, null);
+ return new MdsalRestconfStrategy(mockDatabind, mockDataBroker, null, null);
}
@Test
doReturn(immediateFluentFuture(Optional.of(data))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, path);
- assertEquals(data, new MdsalRestconfStrategy(MODULES_SCHEMA, mockDataBroker, null, null)
+ assertEquals(data, new MdsalRestconfStrategy(MODULES_DATABIND, mockDataBroker, null, null)
.readData(ContentParam.ALL, path, WithDefaultsParam.TRIM));
}
doReturn(immediateFluentFuture(Optional.of(data))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, path);
- assertEquals(data, new MdsalRestconfStrategy(MODULES_SCHEMA, mockDataBroker, null, null)
+ assertEquals(data, new MdsalRestconfStrategy(MODULES_DATABIND, mockDataBroker, null, null)
.readData(ContentParam.ALL, path, WithDefaultsParam.TRIM));
}
doReturn(immediateFluentFuture(Optional.of(content))).when(read)
.read(LogicalDatastoreType.OPERATIONAL, path);
- assertEquals(content, new MdsalRestconfStrategy(MODULES_SCHEMA, mockDataBroker, null, null)
+ assertEquals(content, new MdsalRestconfStrategy(MODULES_DATABIND, mockDataBroker, null, null)
.readData(ContentParam.ALL, path, WithDefaultsParam.TRIM));
}
}
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
@Mock
private NetconfDataTreeService netconfService;
+ private DatabindContext mockDatabind;
+
@Before
public void before() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
.delete(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of());
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).merge(any(), any(),
any(), any());
+ mockDatabind = DatabindContext.ofModel(mockSchemaContext);
}
@Override
RestconfStrategy testDeleteDataStrategy() {
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
doReturn(Futures.immediateFailedFuture(new TransactionCommitFailedException(
"Commit of transaction " + this + " failed", new NetconfDocumentedException("id",
ErrorType.RPC, ErrorTag.DATA_MISSING, ErrorSeverity.ERROR)))).when(netconfService).commit();
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.create(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX, Optional.empty());
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).create(
LogicalDatastoreType.CONFIGURATION, node, entryNode, Optional.empty());
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
.create(any(), any(), any(), any());
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).discardChanges();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock();
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
RestconfStrategy testPatchContainerDataStrategy() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).merge(any(), any(),any(),
any());
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.merge(any(), any(), any(), any());
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.merge(any(), any(),any(),any());
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Test
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null)
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null)
.putData(JUKEBOX_IID, EMPTY_JUKEBOX, null);
verify(netconfService).lock();
verify(netconfService).getConfig(JUKEBOX_IID);
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null)
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null)
.putData(JUKEBOX_IID, EMPTY_JUKEBOX, null);
verify(netconfService).getConfig(JUKEBOX_IID);
verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX,
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null).putData(GAP_IID, GAP_LEAF, null);
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null).putData(GAP_IID, GAP_LEAF, null);
verify(netconfService).getConfig(GAP_IID);
verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF, Optional.empty());
}
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null).putData(GAP_IID, GAP_LEAF, null);
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null).putData(GAP_IID, GAP_LEAF, null);
verify(netconfService).getConfig(GAP_IID);
verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF, Optional.empty());
}
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null)
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null)
.putData(JUKEBOX_IID, JUKEBOX_WITH_BANDS, null);
verify(netconfService).getConfig(JUKEBOX_IID);
verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS,
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS, Optional.empty());
- new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null)
+ new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null)
.putData(JUKEBOX_IID, JUKEBOX_WITH_BANDS, null);
verify(netconfService).getConfig(JUKEBOX_IID);
verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS,
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
// FIXME: exact match
.replace(any(), any(), any(), any());
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
.create(LogicalDatastoreType.CONFIGURATION, PLAYER_IID, EMPTY_JUKEBOX, Optional.empty());
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.delete(LogicalDatastoreType.CONFIGURATION, CREATE_AND_DELETE_TARGET);
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
RestconfStrategy testPatchMergePutContainerStrategy() {
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
.when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
.delete(LogicalDatastoreType.CONFIGURATION, CREATE_AND_DELETE_TARGET);
- return new NetconfRestconfStrategy(JUKEBOX_SCHEMA, netconfService, null, null);
+ return new NetconfRestconfStrategy(JUKEBOX_DATABIND, netconfService, null, null);
}
@Override
@Override
RestconfStrategy readDataConfigTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_3))).when(netconfService).getConfig(PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readAllHavingOnlyConfigTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_3))).when(netconfService).getConfig(PATH);
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).get(PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readAllHavingOnlyNonConfigTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_2))).when(netconfService).get(PATH_2);
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(PATH_2);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readDataNonConfigTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_2))).when(netconfService).get(PATH_2);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readContainerDataAllTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_3))).when(netconfService).getConfig(PATH);
doReturn(immediateFluentFuture(Optional.of(DATA_4))).when(netconfService).get(PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readContainerDataConfigNoValueOfContentTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(DATA_3))).when(netconfService).getConfig(PATH);
doReturn(immediateFluentFuture(Optional.of(DATA_4))).when(netconfService).get(PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readListDataAllTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(LIST_DATA))).when(netconfService).get(PATH_3);
doReturn(immediateFluentFuture(Optional.of(LIST_DATA_2))).when(netconfService).getConfig(PATH_3);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readOrderedListDataAllTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(ORDERED_MAP_NODE_1))).when(netconfService).get(PATH_3);
doReturn(immediateFluentFuture(Optional.of(ORDERED_MAP_NODE_2))).when(netconfService).getConfig(PATH_3);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readUnkeyedListDataAllTestStrategy() {
doReturn(immediateFluentFuture(Optional.of(UNKEYED_LIST_NODE_1))).when(netconfService).get(PATH_3);
doReturn(immediateFluentFuture(Optional.of(UNKEYED_LIST_NODE_2))).when(netconfService).getConfig(PATH_3);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
.get(LEAF_SET_NODE_PATH);
doReturn(immediateFluentFuture(Optional.of(LEAF_SET_NODE_2))).when(netconfService)
.getConfig(LEAF_SET_NODE_PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
.get(LEAF_SET_NODE_PATH);
doReturn(immediateFluentFuture(Optional.of(ORDERED_LEAF_SET_NODE_2))).when(netconfService)
.getConfig(LEAF_SET_NODE_PATH);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
@Override
RestconfStrategy readDataWrongPathOrNoContentTestStrategy() {
doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(PATH_2);
- return new NetconfRestconfStrategy(mockSchemaContext, netconfService, null, null);
+ return new NetconfRestconfStrategy(mockDatabind, netconfService, null, null);
}
}
import org.opendaylight.restconf.api.query.FieldsParam;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.AbstractJukeboxTest;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
private static final EffectiveModelContext TEST_SERVICES_SCHEMA =
YangParserTestUtils.parseYangResourceDirectory("/test-services");
+ private static final DatabindContext TEST_SERVICES_DATABIND = DatabindContext.ofModel(TEST_SERVICES_SCHEMA);
private static final EffectiveModelContext FOO_SCHEMA =
YangParserTestUtils.parseYangResourceDirectory("/same-qname-nodes");
+ private static final DatabindContext FOO_DATABIND = DatabindContext.ofModel(FOO_SCHEMA);
private DataSchemaNode jukeboxSchemaNode;
private DataSchemaNode testServices;
@Before
public void setUp() {
- jukeboxSchemaNode = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(
+ jukeboxSchemaNode = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(JUKEBOX_DATABIND,
SchemaInferenceStack.ofDataTreePath(JUKEBOX_SCHEMA, JUKEBOX_QNAME)).getSchemaNode());
- testServices = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(
+ testServices = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(TEST_SERVICES_DATABIND,
SchemaInferenceStack.ofDataTreePath(TEST_SERVICES_SCHEMA, TEST_DATA_Q_NAME)).getSchemaNode());
- foo = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(
+ foo = assertInstanceOf(DataSchemaNode.class, InstanceIdentifierContext.ofStack(FOO_DATABIND,
SchemaInferenceStack.ofDataTreePath(FOO_SCHEMA, FOO_Q_NAME)).getSchemaNode());
}
@Test
void testGetRestconfStrategyLocal() {
- assertInstanceOf(MdsalRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_SCHEMA, null));
+ assertInstanceOf(MdsalRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_DATABIND, null));
}
@Test
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.of(schemaService)).when(mountPoint).getService(DOMSchemaService.class);
doReturn(ImmutableClassToInstanceMap.of()).when(schemaService).getExtensions();
- assertInstanceOf(MdsalRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_SCHEMA, mountPoint));
+ assertInstanceOf(MdsalRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_DATABIND, mountPoint));
}
@Test
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.of(schemaService)).when(mountPoint).getService(DOMSchemaService.class);
doReturn(ImmutableClassToInstanceMap.of()).when(schemaService).getExtensions();
- assertInstanceOf(NetconfRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_SCHEMA, mountPoint));
+ assertInstanceOf(NetconfRestconfStrategy.class, server.getRestconfStrategy(JUKEBOX_DATABIND, mountPoint));
}
@Test
doReturn(Optional.of(schemaService)).when(mountPoint).getService(DOMSchemaService.class);
doReturn(ImmutableClassToInstanceMap.of()).when(schemaService).getExtensions();
final var ex = assertThrows(RestconfDocumentedException.class,
- () -> server.getRestconfStrategy(JUKEBOX_SCHEMA, mountPoint));
+ () -> server.getRestconfStrategy(JUKEBOX_DATABIND, mountPoint));
final var errors = ex.getErrors();
assertEquals(1, errors.size());
final var error = errors.get(0);
Code Review / netconf.git / commitdiff