This bumps yangtools to 4.0.1 as part of Magnesium MRI.
Change-Id: I6228c73d31721c8427e7f456afd5ab3ff715c88b
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>3.0.5</version>
+ <version>4.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-api" version="${project.version}">
- <feature version="[5,6)">odl-netty-4</feature>
- <feature version="[3,4)">odl-yangtools-parser-api</feature>
+ <feature version="[6,7)">odl-netty-4</feature>
+ <feature version="[4,5)">odl-yangtools-parser-api</feature>
<feature version="[2,3)">odl-mdsal-model-rfc7895</feature>
<feature version="[2,3)">odl-mdsal-model-rfc8342</feature>
</feature>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>odl-yangtools-codec</artifactId>
- <version>3.0.5</version>
+ <version>4.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<configfile finalname="etc/netconf.cfg">
mvn:org.opendaylight.netconf/netconf-util/${project.version}/cfg/config
</configfile>
- <feature version="[3,4)">odl-yangtools-codec</feature>
+ <feature version="[4,5)">odl-yangtools-codec</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>3.0.5</version>
+ <version>4.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-restconf-common" version="${project.version}">
- <feature version="[5,6)">odl-karaf-feat-jetty</feature>
- <feature version="[3,4)">odl-yangtools-export</feature>
+ <feature version="[6,7)">odl-karaf-feat-jetty</feature>
+ <feature version="[4,5)">odl-yangtools-export</feature>
<feature version="[2,3)">odl-mdsal-model-rfc7895</feature>
</feature>
</features>
import org.opendaylight.netconf.api.ModifyAction;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.EditConfigInput;
-import org.opendaylight.yangtools.rfc7952.data.api.NormalizedMetadataStreamWriter;
+import org.opendaylight.yangtools.rfc7952.data.api.StreamWriterMetadataExtension;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.slf4j.LoggerFactory;
final class SplittingNormalizedNodeMetadataStreamWriter implements NormalizedNodeStreamWriter,
- NormalizedMetadataStreamWriter {
+ StreamWriterMetadataExtension {
private static final Logger LOG = LoggerFactory.getLogger(SplittingNormalizedNodeMetadataStreamWriter.class);
private static final QName OPERATION_ATTRIBUTE = QName.create(EditConfigInput.QNAME.getNamespace(),
XmlNetconfConstants.OPERATION_ATTR_KEY);
@Override
public ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of(NormalizedMetadataStreamWriter.class, this);
+ return ImmutableClassToInstanceMap.of(StreamWriterMetadataExtension.class, this);
}
@Override
writer.metadata(filterMeta(metadata));
}
- private static ImmutableMap<QName, Object> filterMeta(ImmutableMap<QName, Object> metadata) {
+ private static ImmutableMap<QName, Object> filterMeta(final ImmutableMap<QName, Object> metadata) {
// FIXME: also remove prefixed attributes?
return ImmutableMap.copyOf(Maps.filterKeys(metadata,
key -> !XmlParserStream.LEGACY_ATTRIBUTE_NAMESPACE.equals(key.getModule())));
pushPath(identifier);
}
+
@Override
- public void startAnyxmlNode(final NodeIdentifier name) throws IOException {
- writer.startAnyxmlNode(name);
- pushPath(name);
+ public boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+ // FIXME: add anydata support
+ return false;
+ }
+
+ @Override
+ public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+ final boolean ret = writer.startAnyxmlNode(name, objectModel);
+ if (ret) {
+ pushPath(name);
+ }
+ return ret;
}
@Override
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
return dn;
}
- private static AnyXmlNode encapsulate(final EventSourceStatusNotification notification) {
+ private static DOMSourceAnyxmlNode encapsulate(final EventSourceStatusNotification notification) {
Document doc = UntrustedXML.newDocumentBuilder().newDocument();
final Element rootElement = XmlUtil.createElement(doc, "EventSourceStatusNotification",
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
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.NotificationDefinition;
}
}
- private AnyXmlNode encapsulate(final DOMNotification body) {
+ private DOMSourceAnyxmlNode encapsulate(final DOMNotification body) {
// FIXME: Introduce something like YangModeledAnyXmlNode in Yangtools
final Document doc = XmlUtil.newDocument();
final Optional<String> namespace = Optional.of(PAYLOAD_ARG.getNodeType().getNamespace().toString());
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
+import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
return new Choice((ChoiceSchemaNode) potential);
} else if (potential instanceof LeafListSchemaNode) {
return fromLeafListSchemaNode((LeafListSchemaNode) potential);
- } else if (potential instanceof AnyXmlSchemaNode) {
- return new AnyXml((AnyXmlSchemaNode) potential);
+ } else if (potential instanceof AnyxmlSchemaNode) {
+ return new AnyXml((AnyxmlSchemaNode) potential);
}
return null;
}
}
private static final class AnyXml extends AbstractSimple<NodeIdentifier> {
- AnyXml(final AnyXmlSchemaNode schema) {
+ AnyXml(final AnyxmlSchemaNode schema) {
super(NodeIdentifier.create(schema.getQName()));
}
@Override
void streamToWriter(final NormalizedNodeStreamWriter writer, final PathArgument first,
final Iterator<PathArgument> others) throws IOException {
- writer.startAnyxmlNode(getIdentifier());
+ writer.startAnyxmlNode(getIdentifier(), DOMSource.class);
// FIXME: why are we not emitting a value?
writer.endNode();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
}
final DataContainerChild<?, ?> rpcResult = rpcResultOpt.get();
- verify(rpcResult instanceof AnyXmlNode, "Unexpected result %s", rpcResult);
+ verify(rpcResult instanceof DOMSourceAnyxmlNode, "Unexpected result %s", rpcResult);
final NormalizedNode<?, ?> dataNode;
try {
dataNode = NetconfUtil.transformDOMSourceToNormalizedNode(schemaContext,
- ((AnyXmlNode) rpcResult).getValue()).getResult();
+ ((DOMSourceAnyxmlNode) rpcResult).getValue()).getResult();
} catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.warn("Failed to transform {}", rpcResult, e);
return Optional.empty();
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@Override
public ListenableFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
final MessageTransformer<NetconfMessage> transformer;
- if (input instanceof AnyXmlNode) {
+ if (input instanceof DOMSourceAnyxmlNode) {
transformer = schemalessTransformer;
} else if (isBaseRpc(type)) {
transformer = baseRpcTransformer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
final Optional<DataContainerChild<?, ?>> child = ((ContainerNode) result).getChild(NETCONF_DATA_PATHARG);
- checkState(child.isPresent() && child.get() instanceof AnyXmlNode,
+ checkState(child.isPresent() && child.get() instanceof DOMSourceAnyxmlNode,
"%s Unexpected response to get-schema, expected response with one child %s, but was %s", id,
NETCONF_DATA, result);
- final DOMSource wrappedNode = ((AnyXmlNode) child.get()).getValue();
+ final DOMSource wrappedNode = ((DOMSourceAnyxmlNode) child.get()).getValue();
final Element dataNode = (Element) requireNonNull(wrappedNode.getNode());
return Optional.of(dataNode.getTextContent().trim());
import org.opendaylight.netconf.sal.connect.util.MessageCounter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangConstants;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
final Element xmlData = NetconfMessageTransformUtil.getDataSubtree(message.getDocument());
final Document data = XmlUtil.newDocument();
data.appendChild(data.importNode(xmlData, true));
- AnyXmlNode xmlDataNode = Builders.anyXmlBuilder()
+ DOMSourceAnyxmlNode xmlDataNode = Builders.anyXmlBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
.withValue(new DOMSource(data))
.build();
import org.opendaylight.netconf.sal.connect.util.MessageCounter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+ message + ", cannot find namespace", e);
}
- final AnyXmlNode notificationPayload = Builders.anyXmlBuilder()
+ final DOMSourceAnyxmlNode notificationPayload = Builders.anyXmlBuilder()
.withNodeIdentifier(new NodeIdentifier(notificationNoRev))
.withValue(new DOMSource(stripped.getValue().getDomElement()))
.build();
public NetconfMessage toRpcRequest(final SchemaPath rpc, final NormalizedNode<?, ?> input) {
final DOMSource payload = (DOMSource) input.getValue();
wrapPayload((Document) payload.getNode());
- return new NetconfMessage((Document) ((AnyXmlNode) input).getValue().getNode());
+ return new NetconfMessage((Document) ((DOMSourceAnyxmlNode) input).getValue().getNode());
}
/**
@Override
public DOMRpcResult toRpcResult(final NetconfMessage rpcReply, final SchemaPath rpc) {
final Document document = rpcReply.getDocument();
- final AnyXmlNode result;
+ final DOMSourceAnyxmlNode result;
if (BaseRpcSchemalessTransformer.isOkPresent(document)) {
result = null;
} else {
import org.opendaylight.yangtools.yang.common.QName;
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.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
public DataContainerChild<?, ?> createEditConfigStrcture(final Optional<NormalizedNode<?, ?>> lastChild,
final Optional<ModifyAction> operation,
final YangInstanceIdentifier dataPath) {
- final AnyXmlNode configContent = transformer.createEditConfigStructure(lastChild, dataPath, operation);
+ final DOMSourceAnyxmlNode configContent = transformer.createEditConfigStructure(lastChild, dataPath, operation);
return Builders.choiceBuilder().withNodeIdentifier(EDIT_CONTENT_NODEID).withChild(configContent).build();
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
return Builders.containerBuilder().withNodeIdentifier(name).withValue(ImmutableList.copyOf(node)).build();
}
- public static AnyXmlNode createEditConfigAnyxml(
+ public static DOMSourceAnyxmlNode createEditConfigAnyxml(
final SchemaContext ctx, final YangInstanceIdentifier dataPath,
final Optional<ModifyAction> operation,
final Optional<NormalizedNode<?, ?>> lastChildOverride) {
import org.opendaylight.netconf.api.ModifyAction;
import org.opendaylight.netconf.util.NetconfUtil;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
public Optional<NormalizedNode<?, ?>> selectFromDataStructure(
final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> data,
final YangInstanceIdentifier path) {
- if (data instanceof AnyXmlNode) {
+ if (data instanceof DOMSourceAnyxmlNode) {
final NormalizedNodeResult node;
try {
- node = NetconfUtil.transformDOMSourceToNormalizedNode(schemaContext, ((AnyXmlNode)data).getValue());
+ node = NetconfUtil.transformDOMSourceToNormalizedNode(schemaContext,
+ ((DOMSourceAnyxmlNode)data).getValue());
return NormalizedNodes.findNode(node.getResult(), path.getPathArguments());
} catch (final XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.error("Cannot parse anyxml.", e);
}
@Override
- public AnyXmlNode createEditConfigStructure(final Optional<NormalizedNode<?, ?>> data,
- final YangInstanceIdentifier dataPath,
- final Optional<ModifyAction> operation) {
+ public DOMSourceAnyxmlNode createEditConfigStructure(final Optional<NormalizedNode<?, ?>> data,
+ final YangInstanceIdentifier dataPath,
+ final Optional<ModifyAction> operation) {
return NetconfMessageTransformUtil.createEditConfigAnyxml(schemaContext, dataPath, operation, data);
}
import java.util.Optional;
import org.opendaylight.netconf.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @param operation operation
* @return config structure
*/
- AnyXmlNode createEditConfigStructure(Optional<NormalizedNode<?, ?>> data,
- YangInstanceIdentifier dataPath, Optional<ModifyAction> operation);
+ DOMSourceAnyxmlNode createEditConfigStructure(Optional<NormalizedNode<?, ?>> data,
+ YangInstanceIdentifier dataPath, Optional<ModifyAction> operation);
/**
* Transforms path to filter structure.
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
public Optional<NormalizedNode<?, ?>> selectFromDataStructure(
final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> data,
final YangInstanceIdentifier path) {
- Preconditions.checkArgument(data instanceof AnyXmlNode);
- final List<XmlElement> xmlElements = selectMatchingNodes(getSourceElement(((AnyXmlNode)data).getValue()), path);
+ Preconditions.checkArgument(data instanceof DOMSourceAnyxmlNode);
+ final List<XmlElement> xmlElements = selectMatchingNodes(
+ getSourceElement(((DOMSourceAnyxmlNode)data).getValue()), path);
final Document result = XmlUtil.newDocument();
final Element dataElement =
result.createElementNS(NETCONF_DATA_QNAME.getNamespace().toString(), NETCONF_DATA_QNAME.getLocalName());
for (XmlElement xmlElement : xmlElements) {
dataElement.appendChild(result.importNode(xmlElement.getDomElement(), true));
}
- final AnyXmlNode resultAnyxml = Builders.anyXmlBuilder()
+ final DOMSourceAnyxmlNode resultAnyxml = Builders.anyXmlBuilder()
.withNodeIdentifier(NETCONF_DATA_NODEID)
.withValue(new DOMSource(result))
.build();
* @return config structure
*/
@Override
- public AnyXmlNode createEditConfigStructure(final Optional<NormalizedNode<?, ?>> data,
+ public DOMSourceAnyxmlNode createEditConfigStructure(final Optional<NormalizedNode<?, ?>> data,
final YangInstanceIdentifier dataPath,
final Optional<ModifyAction> operation) {
Preconditions.checkArgument(data.isPresent());
- Preconditions.checkArgument(data.get() instanceof AnyXmlNode);
+ Preconditions.checkArgument(data.get() instanceof DOMSourceAnyxmlNode);
- final AnyXmlNode anxmlData = (AnyXmlNode) data.get();
+ final DOMSourceAnyxmlNode anxmlData = (DOMSourceAnyxmlNode) data.get();
final Document document = XmlUtil.newDocument();
final Element dataNode = (Element) document.importNode(getSourceElement(anxmlData.getValue()), true);
checkDataValidForPath(dataPath, dataNode);
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
private static Node resolveNode(final DOMRpcResult result) {
DataContainerChild<?, ?> value = ((ContainerNode) result.getResult())
.getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).get();
- Node node = ((AnyXmlNode)value).getValue().getNode();
+ Node node = ((DOMSourceAnyxmlNode)value).getValue().getNode();
assertNotNull(node);
return node;
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.edit.config.input.target.config.target.Candidate;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public void toRpcRequest() throws Exception {
final Document doc =
XmlUtil.readXmlToDocument(getClass().getResourceAsStream("/schemaless/edit-config/container.xml"));
- final AnyXmlNode xml = Builders.anyXmlBuilder()
+ final DOMSourceAnyxmlNode xml = Builders.anyXmlBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
NetconfMessageTransformUtil.NETCONF_CONFIG_QNAME))
.withValue(new DOMSource(doc.getDocumentElement()))
Assert.assertEquals(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME, rpcReply.getNodeType());
final Optional<?> dataOpt = rpcReply.getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID);
Assert.assertTrue(dataOpt.isPresent());
- final AnyXmlNode data = (AnyXmlNode) dataOpt.get();
+ final DOMSourceAnyxmlNode data = (DOMSourceAnyxmlNode) dataOpt.get();
final Diff diff = XMLUnit.compareXML(dataElement.getOwnerDocument(), (Document) data.getValue().getNode());
Assert.assertTrue(diff.toString(), diff.similar());
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
final DOMRpcResult compositeNodeRpcResult = transformer.toRpcResult(response, toPath(GET_SCHEMA_QNAME));
assertTrue(compositeNodeRpcResult.getErrors().isEmpty());
assertNotNull(compositeNodeRpcResult.getResult());
- final DOMSource schemaContent =
- ((AnyXmlNode) ((ContainerNode) compositeNodeRpcResult.getResult()).getValue().iterator().next()).getValue();
+ final DOMSource schemaContent = ((DOMSourceAnyxmlNode) ((ContainerNode) compositeNodeRpcResult.getResult())
+ .getValue().iterator().next()).getValue();
assertThat(schemaContent.getNode().getTextContent(),
CoreMatchers.containsString("Random YANG SCHEMA"));
}
final MapEntryNode schemaNode =
Builders.mapEntryBuilder().withNodeIdentifier(identifierWithPredicates).withValue(values).build();
- final AnyXmlNode data = (AnyXmlNode) ((ContainerNode) compositeNodeRpcResult
- .getResult()).getChild(toId(NETCONF_DATA_QNAME)).get();
+ final DOMSourceAnyxmlNode data = (DOMSourceAnyxmlNode) ((ContainerNode) compositeNodeRpcResult.getResult())
+ .getChild(toId(NETCONF_DATA_QNAME)).get();
NormalizedNodeResult nodeResult =
NetconfUtil.transformDOMSourceToNormalizedNode(SCHEMA, data.getValue());
import org.opendaylight.netconf.sal.connect.util.MessageCounter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.w3c.dom.Document;
SchemalessMessageTransformer.SCHEMALESS_NOTIFICATION_PAYLOAD.getNodeType());
final QName qName =
QName.create("org:opendaylight:notification:test:ns:yang:user-notification", "user-visited-page");
- final AnyXmlNode dataContainerChild =
- (AnyXmlNode) domNotification.getBody().getChild(new YangInstanceIdentifier.NodeIdentifier(qName)).get();
+ final DOMSourceAnyxmlNode dataContainerChild = (DOMSourceAnyxmlNode) domNotification.getBody()
+ .getChild(new YangInstanceIdentifier.NodeIdentifier(qName)).get();
final Diff diff = XMLUnit.compareXML(payload, dataContainerChild.getValue().getNode().getOwnerDocument());
Assert.assertTrue(diff.toString(), diff.similar());
@Test
public void toRpcRequest() throws Exception {
final Node src = XmlUtil.readXmlToDocument("<test-rpc xmlns=\"test-ns\"><input>aaa</input></test-rpc>");
- final AnyXmlNode input = Builders.anyXmlBuilder()
+ final DOMSourceAnyxmlNode input = Builders.anyXmlBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_RPC))
.withValue(new DOMSource(src))
.build();
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
if (expectedException != null) {
thrown.expect(expectedException);
}
- AnyXmlNode data = Builders.anyXmlBuilder()
+ DOMSourceAnyxmlNode data = Builders.anyXmlBuilder()
.withNodeIdentifier(createNodeId(path.getLastPathArgument().getNodeType().getLocalName()))
.withValue(source)
.build();
- final AnyXmlNode anyXmlNode =
+ final DOMSourceAnyxmlNode anyXmlNode =
adapter.createEditConfigStructure(Optional.of(data), path, Optional.of(ModifyAction.REPLACE));
final String s = XmlUtil.toString((Element) anyXmlNode.getValue().getNode());
Diff diff = new Diff(expectedConfig, s);
@Test
public void testToFilterStructure() throws Exception {
- final AnyXmlNode anyXmlNode = (AnyXmlNode) adapter.toFilterStructure(path);
+ final DOMSourceAnyxmlNode anyXmlNode = (DOMSourceAnyxmlNode) adapter.toFilterStructure(path);
final String s = XmlUtil.toString((Element) anyXmlNode.getValue().getNode());
Diff diff = new Diff(expectedFilter, s);
Assert.assertTrue(String.format("Input %s: %s", testDataset, diff.toString()), diff.similar());
@Test
public void testSelectFromDataStructure() throws Exception {
- AnyXmlNode data = Builders.anyXmlBuilder()
+ DOMSourceAnyxmlNode data = Builders.anyXmlBuilder()
.withNodeIdentifier(createNodeId(path.getLastPathArgument().getNodeType().getLocalName()))
.withValue(new DOMSource(XmlUtil.readXmlToDocument(getConfigData).getDocumentElement()))
.build();
- final AnyXmlNode dataStructure = (AnyXmlNode) adapter.selectFromDataStructure(data, path).get();
+ final DOMSourceAnyxmlNode dataStructure = (DOMSourceAnyxmlNode) adapter.selectFromDataStructure(data, path)
+ .get();
final XmlElement s = XmlElement.fromDomDocument((Document) dataStructure.getValue().getNode());
final String dataFromReply = XmlUtil.toString(s.getOnlyChildElement().getDomElement());
final String expectedData = XmlUtil.toString((Element) source.getNode());
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
+import javax.xml.transform.dom.DOMSource;
import org.opendaylight.netconf.sal.rest.api.RestconfNormalizedNodeWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
writer.scalarValue(nodeAsLeaf.getValue());
writer.endNode();
return true;
- } else if (node instanceof AnyXmlNode) {
- final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
- writer.startAnyxmlNode(anyXmlNode.getIdentifier());
- writer.domSourceValue(anyXmlNode.getValue());
- writer.endNode();
+ } else if (node instanceof AnyxmlNode) {
+ final AnyxmlNode<?> anyxmlNode = (AnyxmlNode<?>)node;
+ final Class<?> objectModel = anyxmlNode.getValueObjectModel();
+ if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), objectModel)) {
+ if (DOMSource.class.isAssignableFrom(objectModel)) {
+ writer.domSourceValue((DOMSource) anyxmlNode.getValue());
+ } else {
+ writer.scalarValue(anyxmlNode.getValue());
+ }
+ writer.endNode();
+ }
return true;
}
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
nnWriter = createNormalizedNodeWriter(context,path,jsonWriter, depth);
if (data instanceof ContainerNode) {
writeChildren(nnWriter,(ContainerNode) data);
- } else if (data instanceof AnyXmlNode) {
+ } else if (data instanceof DOMSourceAnyxmlNode) {
try {
writeChildren(nnWriter,
(ContainerNode) NetconfUtil.transformDOMSourceToNormalizedNode(
- context.getSchemaContext(), ((AnyXmlNode)data).getValue()).getResult());
+ context.getSchemaContext(), ((DOMSourceAnyxmlNode)data).getValue()).getResult());
} catch (XMLStreamException | URISyntaxException | SAXException e) {
throw new IOException("Cannot write anyxml.", e);
}
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
final SchemaContext schemaCtx = pathContext.getSchemaContext();
if (SchemaPath.ROOT.equals(schemaPath)) {
nnWriter = createNormalizedNodeWriter(xmlWriter, schemaCtx, schemaPath, depth);
- if (data instanceof AnyXmlNode) {
+ if (data instanceof DOMSourceAnyxmlNode) {
try {
writeElements(xmlWriter, nnWriter,
(ContainerNode) NetconfUtil.transformDOMSourceToNormalizedNode(schemaCtx,
- ((AnyXmlNode)data).getValue()).getResult());
+ ((DOMSourceAnyxmlNode)data).getValue()).getResult());
} catch (XMLStreamException | URISyntaxException | SAXException e) {
throw new IOException("Cannot write anyxml", e);
}
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
import org.opendaylight.restconf.common.util.RestUtil;
-import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private String toUriString(final Object object, final LeafSchemaNode leafNode, final DOMMountPoint mount)
throws UnsupportedEncodingException {
- final Codec<Object, Object> codec = RestCodec.from(leafNode.getType(), mount, this);
+ final IllegalArgumentCodec<Object, Object> codec = RestCodec.from(leafNode.getType(), mount, this);
// FIXME: UrlEncoder looks up a well-known charset, we need something that will use it directly
return object == null ? "" : URLEncoder.encode(codec.serialize(object).toString(), URI_ENCODING_CHARSET.name());
}
public static boolean isInstantiatedDataSchema(final DataSchemaNode node) {
return node instanceof LeafSchemaNode || node instanceof LeafListSchemaNode
|| node instanceof ContainerSchemaNode || node instanceof ListSchemaNode
- || node instanceof AnyXmlSchemaNode;
+ || node instanceof AnyxmlSchemaNode;
}
private void addKeyValue(final HashMap<QName, Object> map, final DataSchemaNode node, final String uriValue,
if (baseType instanceof LeafrefTypeDefinition) {
typedef = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) baseType, schemaContext, node);
}
- final Codec<Object, Object> codec = RestCodec.from(typedef, mountPoint, this);
+ final IllegalArgumentCodec<Object, Object> codec = RestCodec.from(typedef, mountPoint, this);
Object decoded = codec.deserialize(urlDecoded);
String additionalInfo = "";
if (decoded == null) {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
return node;
}
- if (node instanceof LeafNode || node instanceof LeafSetNode || node instanceof AnyXmlNode
+ if (node instanceof LeafNode || node instanceof LeafSetNode || node instanceof AnyxmlNode
|| node instanceof OrderedLeafSetNode) {
return node;
} else if (node instanceof MixinNode) {
import org.opendaylight.restconf.common.util.IdentityValuesDTO.IdentityValue;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.Predicate;
import org.opendaylight.restconf.common.util.RestUtil;
-import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
private RestCodec() {
}
- public static Codec<Object, Object> from(final TypeDefinition<?> typeDefinition,
+ // FIXME: IllegalArgumentCodec is not quite accurate
+ public static IllegalArgumentCodec<Object, Object> from(final TypeDefinition<?> typeDefinition,
final DOMMountPoint mountPoint, final ControllerContext controllerContext) {
return new ObjectCodec(typeDefinition, mountPoint, controllerContext);
}
@SuppressWarnings("rawtypes")
- public static final class ObjectCodec implements Codec<Object, Object> {
+ public static final class ObjectCodec implements IllegalArgumentCodec<Object, Object> {
private static final Logger LOG = LoggerFactory.getLogger(ObjectCodec.class);
- public static final Codec LEAFREF_DEFAULT_CODEC = new LeafrefCodecImpl();
+ public static final IllegalArgumentCodec LEAFREF_DEFAULT_CODEC = new LeafrefCodecImpl();
private final ControllerContext controllerContext;
- private final Codec instanceIdentifier;
- private final Codec identityrefCodec;
+ private final IllegalArgumentCodec instanceIdentifier;
+ private final IllegalArgumentCodec identityrefCodec;
private final TypeDefinition<?> type;
*/
package org.opendaylight.controller.sal.restconf.impl.test;
-import java.util.Collection;
+import java.util.List;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
private final boolean isSuccessful;
private final T result;
- private final Collection<RpcError> errors;
+ private final List<RpcError> errors;
public DummyRpcResult() {
isSuccessful = false;
}
@Override
- public Collection<RpcError> getErrors() {
+ public List<RpcError> getErrors() {
return errors;
}
public static class Builder<T> {
private boolean isSuccessful;
private T result;
- private Collection<RpcError> errors;
+ private List<RpcError> errors;
public Builder<T> isSuccessful(final boolean successful) {
this.isSuccessful = successful;
return this;
}
- public Builder<T> errors(final Collection<RpcError> newErrors) {
+ public Builder<T> errors(final List<RpcError> newErrors) {
this.errors = newErrors;
return this;
}
import org.opendaylight.restconf.common.patch.PatchStatusEntity;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
assertTrue("Expected ContainerNode. Actual " + capturedNode.getValue().getClass(),
capturedNode.getValue() instanceof ContainerNode);
final ContainerNode actualNode = (ContainerNode) capturedNode.getValue();
- verifyLeafNode(actualNode, TOASTER_DONENESS_QNAME, 10L);
+ verifyLeafNode(actualNode, TOASTER_DONENESS_QNAME, Uint32.valueOf(10));
verifyLeafNode(actualNode, TOASTER_TYPE_QNAME, WHEAT_BREAD_QNAME);
}
void verifyLeafNode(final DataContainerNode<?> parent, final QName leafType, final Object leafValue) {
final java.util.Optional<DataContainerChild<?, ?>> leafChild = parent.getChild(new NodeIdentifier(leafType));
- assertEquals(leafType.toString() + " present", true, leafChild.isPresent());
+ assertTrue(leafType.toString() + " present", leafChild.isPresent());
assertEquals(leafType.toString() + " value", leafValue, leafChild.get().getValue());
}
import org.junit.Test;
import org.opendaylight.netconf.sal.restconf.impl.RestCodec;
-import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
@Test
public void serializeExceptionTest() {
- final Codec<Object, Object> codec = RestCodec.from(BaseTypes.bitsTypeBuilder(PATH).build(), null, null);
+ final IllegalArgumentCodec<Object, Object> codec = RestCodec.from(BaseTypes.bitsTypeBuilder(PATH).build(),
+ null, null);
final String serializedValue = (String) codec.serialize("incorrect value"); // set
// expected
assertEquals("incorrect value", serializedValue);
public void deserializeExceptionTest() {
final IdentityrefTypeDefinition mockedIidentityrefType = mock(IdentityrefTypeDefinition.class);
- final Codec<Object, Object> codec = RestCodec.from(mockedIidentityrefType, null, null);
+ final IllegalArgumentCodec<Object, Object> codec = RestCodec.from(mockedIidentityrefType, null, null);
assertNull(codec.deserialize("incorrect value"));
}
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
import org.opendaylight.netconf.sal.restconf.impl.RestCodec.InstanceIdentifierCodecImpl;
import org.opendaylight.restconf.common.util.IdentityValuesDTO;
-import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class InstanceIdentifierCodecImplTest {
private static SchemaContext schemaContext;
- private Codec<IdentityValuesDTO, YangInstanceIdentifier> instanceIdentifierDTO;
+ private InstanceIdentifierCodecImpl instanceIdentifierDTO;
private YangInstanceIdentifier instanceIdentifierBadNamespace;
private YangInstanceIdentifier instanceIdentifierOKList;
private YangInstanceIdentifier instanceIdentifierOKLeafList;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.IdentityValue;
import org.opendaylight.restconf.common.util.IdentityValuesDTO.Predicate;
import org.opendaylight.restconf.common.util.RestUtil;
-import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.codec.InstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.api.codec.LeafrefCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private RestCodec() {
}
- public static Codec<Object, Object> from(final TypeDefinition<?> typeDefinition,
+ // FIXME: IllegalArgumentCodec is not quite accurate
+ public static IllegalArgumentCodec<Object, Object> from(final TypeDefinition<?> typeDefinition,
final DOMMountPoint mountPoint, final SchemaContext schemaContext) {
return new ObjectCodec(typeDefinition, mountPoint, schemaContext);
}
@SuppressWarnings("rawtypes")
- public static final class ObjectCodec implements Codec<Object, Object> {
+ public static final class ObjectCodec implements IllegalArgumentCodec<Object, Object> {
private static final Logger LOG = LoggerFactory.getLogger(ObjectCodec.class);
- public static final Codec LEAFREF_DEFAULT_CODEC = new LeafrefCodecImpl();
- private final Codec instanceIdentifier;
- private final Codec identityrefCodec;
+ public static final IllegalArgumentCodec LEAFREF_DEFAULT_CODEC = new LeafrefCodecImpl();
+ private final IllegalArgumentCodec instanceIdentifier;
+ private final IllegalArgumentCodec identityrefCodec;
private final TypeDefinition<?> type;
private static boolean isInstantiatedDataSchema(final DataSchemaNode node) {
return node instanceof LeafSchemaNode || node instanceof LeafListSchemaNode
|| node instanceof ContainerSchemaNode || node instanceof ListSchemaNode
- || node instanceof AnyXmlSchemaNode;
+ || node instanceof AnyxmlSchemaNode;
}
}
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
+import javax.xml.transform.dom.DOMSource;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
writer.scalarValue(nodeAsLeaf.getValue());
writer.endNode();
return true;
- } else if (node instanceof AnyXmlNode) {
- final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
- writer.startAnyxmlNode(anyXmlNode.getIdentifier());
- writer.domSourceValue(anyXmlNode.getValue());
- writer.endNode();
+ } else if (node instanceof AnyxmlNode) {
+ final AnyxmlNode<?> anyxmlNode = (AnyxmlNode<?>)node;
+ final Class<?> objectModel = anyxmlNode.getValueObjectModel();
+ if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), objectModel)) {
+ if (DOMSource.class.isAssignableFrom(objectModel)) {
+ writer.domSourceValue((DOMSource) anyxmlNode.getValue());
+ } else {
+ writer.scalarValue(anyxmlNode.getValue());
+ }
+ writer.endNode();
+ }
return true;
}
import org.opendaylight.restconf.nb.rfc8040.services.wrapper.ServicesWrapper;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
assertTrue("Expected ContainerNode. Actual " + capturedNode.getValue().getClass(),
capturedNode.getValue() instanceof ContainerNode);
final ContainerNode actualNode = (ContainerNode) capturedNode.getValue();
- verifyLeafNode(actualNode, TOASTER_DONENESS_QNAME, 10L);
+ verifyLeafNode(actualNode, TOASTER_DONENESS_QNAME, Uint32.valueOf(10L));
verifyLeafNode(actualNode, TOASTER_TYPE_QNAME, WHEAT_BREAD_QNAME);
}
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import java.util.Collection;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.references.SchemaContextRef;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper;
-import org.opendaylight.yangtools.util.SingletonSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
this.iid2);
final NodeIdentifier identifier =
- ((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
+ ((ContainerNode) ((Collection<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
this.iid2);
final NodeIdentifier identifier =
- ((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
+ ((ContainerNode) ((Collection<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
((NodeIdentifierWithPredicates)result.getLastPathArgument()).entrySet().iterator();
assertEquals(":foo", resultListKeys.next().getValue());
- assertEquals(new Short("1"), resultListKeys.next().getValue());
+ assertEquals(Uint8.ONE, resultListKeys.next().getValue());
assertEquals(true, resultListKeys.next().getValue());
}
import org.opendaylight.netconf.sal.rest.doc.swagger.ApiDeclaration;
import org.opendaylight.netconf.sal.rest.doc.swagger.Resource;
import org.opendaylight.netconf.sal.rest.doc.swagger.ResourceList;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang2sources.spi.BasicCodeGenerator;
import org.opendaylight.yangtools.yang2sources.spi.MavenProjectAware;
import org.slf4j.Logger;
@Override
@SuppressFBWarnings("DM_DEFAULT_ENCODING")
- public Collection<File> generateSources(final SchemaContext context, final File outputBaseDir,
+ public Collection<File> generateSources(final EffectiveModelContext context, final File outputBaseDir,
final Set<Module> currentModules, final Function<Module, Optional<String>> moduleResourcePathResolver)
throws IOException {
List<File> result = new ArrayList<>();
import org.opendaylight.netconf.sal.rest.doc.model.builder.OperationBuilder;
import org.opendaylight.netconf.sal.rest.doc.model.builder.OperationBuilder.Post;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
}
continue;
- } else if (node instanceof AnyXmlSchemaNode) {
- property = processAnyXMLNode((AnyXmlSchemaNode) node);
+ } else if (node instanceof AnyxmlSchemaNode) {
+ property = processAnyXMLNode((AnyxmlSchemaNode) node);
- } else if (node instanceof AnyDataSchemaNode) {
- property = processAnydataNode((AnyDataSchemaNode) node);
+ } else if (node instanceof AnydataSchemaNode) {
+ property = processAnydataNode((AnydataSchemaNode) node);
} else if (node instanceof ContainerSchemaNode) {
property = processDataNodeContainer((ContainerSchemaNode) node, parentName, models, isConfig,
}
continue;
- } else if (node instanceof AnyXmlSchemaNode) {
- property = processAnyXMLNode((AnyXmlSchemaNode) node);
+ } else if (node instanceof AnyxmlSchemaNode) {
+ property = processAnyXMLNode((AnyxmlSchemaNode) node);
- } else if (node instanceof AnyDataSchemaNode) {
- property = processAnydataNode((AnyDataSchemaNode) node);
+ } else if (node instanceof AnydataSchemaNode) {
+ property = processAnydataNode((AnydataSchemaNode) node);
} else if (node instanceof ContainerSchemaNode) {
property = processDataNodeContainer((ContainerSchemaNode) node, moduleName, models, isConfig,
return property;
}
- private static ObjectNode processAnydataNode(final AnyDataSchemaNode leafNode) {
+ private static ObjectNode processAnydataNode(final AnydataSchemaNode leafNode) {
final ObjectNode property = JsonNodeFactory.instance.objectNode();
final String leafDescription = leafNode.getDescription().orElse(null);
return property;
}
- private static ObjectNode processAnyXMLNode(final AnyXmlSchemaNode leafNode) {
+ private static ObjectNode processAnyXMLNode(final AnyxmlSchemaNode leafNode) {
final ObjectNode property = JsonNodeFactory.instance.objectNode();
final String leafDescription = leafNode.getDescription().orElse(null);
Code Review / netconf.git / commitdiff