import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.base.Verify.verify;
+import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.IETF_NETCONF_MONITORING;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DATA_NODEID;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_FILTER_NODEID;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_FILTER_QNAME;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashSet;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
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.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.traversal.DocumentTraversal;
+import org.w3c.dom.traversal.NodeFilter;
+import org.w3c.dom.traversal.TreeWalker;
import org.xml.sax.SAXException;
/**
public static final NetconfStateSchemas EMPTY = new NetconfStateSchemas(ImmutableSet.of());
private static final Logger LOG = LoggerFactory.getLogger(NetconfStateSchemas.class);
- private static final YangInstanceIdentifier STATE_SCHEMAS_IDENTIFIER =
- YangInstanceIdentifier.builder().node(NetconfState.QNAME).node(Schemas.QNAME).build();
+ private static final YangInstanceIdentifier STATE_SCHEMAS_IDENTIFIER = YangInstanceIdentifier.builder()
+ .node(NetconfState.QNAME).node(Schemas.QNAME).build();
+ private static final String MONITORING_NAMESPACE = IETF_NETCONF_MONITORING.getNamespace().toString();
private static final @NonNull ContainerNode GET_SCHEMAS_RPC;
static {
schemasNodeResult = deviceRpc.invokeRpc(NETCONF_GET_QNAME, GET_SCHEMAS_RPC).get();
} catch (final InterruptedException e) {
Thread.currentThread().interrupt();
- throw new RuntimeException(id
+ throw new IllegalStateException(id
+ ": Interrupted while waiting for response to " + STATE_SCHEMAS_IDENTIFIER, e);
} catch (final ExecutionException e) {
LOG.warn("{}: Unable to detect available schemas, get to {} failed", id, STATE_SCHEMAS_IDENTIFIER, e);
return EMPTY;
}
- final Optional<? extends NormalizedNode<?, ?>> optSchemasNode = findSchemasNode(schemasNodeResult.getResult(),
+ final Optional<? extends NormalizedNode> optSchemasNode = findSchemasNode(schemasNodeResult.getResult(),
schemaContext);
if (optSchemasNode.isEmpty()) {
LOG.warn("{}: Unable to detect available schemas, get to {} was empty", id, STATE_SCHEMAS_IDENTIFIER);
return EMPTY;
}
- final NormalizedNode<?, ?> schemasNode = optSchemasNode.get();
+ final NormalizedNode schemasNode = optSchemasNode.get();
checkState(schemasNode instanceof ContainerNode, "Expecting container containing schemas, but was %s",
schemasNode);
return create(id, (ContainerNode) schemasNode);
protected static NetconfStateSchemas create(final RemoteDeviceId id, final ContainerNode schemasNode) {
final Set<RemoteYangSchema> availableYangSchemas = new HashSet<>();
- final Optional<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> child =
- schemasNode.getChild(toId(Schema.QNAME));
+ final Optional<DataContainerChild> child =
+ schemasNode.findChildByArg(toId(Schema.QNAME));
checkState(child.isPresent(), "Unable to find list: %s in response: %s", Schema.QNAME.withoutRevision(),
schemasNode);
checkState(child.get() instanceof MapNode,
"Unexpected structure for container: %s in response: %s. Expecting a list",
Schema.QNAME.withoutRevision(), schemasNode);
- for (final MapEntryNode schemaNode : ((MapNode) child.get()).getValue()) {
+ for (final MapEntryNode schemaNode : ((MapNode) child.get()).body()) {
final Optional<RemoteYangSchema> fromCompositeNode =
RemoteYangSchema.createFromNormalizedNode(id, schemaNode);
fromCompositeNode.ifPresent(availableYangSchemas::add);
return new NetconfStateSchemas(availableYangSchemas);
}
- private static Optional<? extends NormalizedNode<?, ?>> findSchemasNode(final NormalizedNode<?, ?> result,
+ private static Optional<? extends NormalizedNode> findSchemasNode(final NormalizedNode result,
final EffectiveModelContext schemaContext) {
if (result == null) {
return Optional.empty();
}
- final Optional<DataContainerChild<?, ?>> rpcResultOpt = ((ContainerNode)result).getChild(NETCONF_DATA_NODEID);
+ // FIXME: unchecked cast
+ final var rpcResultOpt = ((ContainerNode) result).findChildByArg(NETCONF_DATA_NODEID);
if (rpcResultOpt.isEmpty()) {
return Optional.empty();
}
- final DataContainerChild<?, ?> rpcResult = rpcResultOpt.get();
+ final var rpcResult = rpcResultOpt.get();
verify(rpcResult instanceof DOMSourceAnyxmlNode, "Unexpected result %s", rpcResult);
- final NormalizedNode<?, ?> dataNode;
+ // Server may include additional data which we do not understand. Make sure we trim the input before we try
+ // to interpret it.
+ // FIXME: this is something NetconfUtil.transformDOMSourceToNormalizedNode(), and more generally, NormalizedNode
+ // codecs should handle. We really want to a NormalizedNode tree which can be directly queried for known
+ // things while completely ignoring XML content (and hence its semantics) of other elements.
+ final var filteredBody = ietfMonitoringCopy(((DOMSourceAnyxmlNode) rpcResult).body());
+
+ final NormalizedNode dataNode;
try {
- dataNode = NetconfUtil.transformDOMSourceToNormalizedNode(schemaContext,
- ((DOMSourceAnyxmlNode) rpcResult).getValue()).getResult();
+ dataNode = NetconfUtil.transformDOMSourceToNormalizedNode(schemaContext, filteredBody).getResult();
} catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.warn("Failed to transform {}", rpcResult, e);
return Optional.empty();
}
- final Optional<DataContainerChild<?, ?>> nStateNode = ((DataContainerNode<?>) dataNode).getChild(
- toId(NetconfState.QNAME));
+ // FIXME: unchecked cast
+ final var nStateNode = ((DataContainerNode) dataNode).findChildByArg(toId(NetconfState.QNAME));
if (nStateNode.isEmpty()) {
return Optional.empty();
}
- return ((DataContainerNode<?>) nStateNode.get()).getChild(toId(Schemas.QNAME));
+ // FIXME: unchecked cast
+ return ((DataContainerNode) nStateNode.get()).findChildByArg(toId(Schemas.QNAME));
+ }
+
+ @VisibleForTesting
+ static DOMSource ietfMonitoringCopy(final DOMSource domSource) {
+ final var sourceDoc = XmlUtil.newDocument();
+ sourceDoc.appendChild(sourceDoc.importNode(domSource.getNode(), true));
+
+ final var treeWalker = ((DocumentTraversal) sourceDoc).createTreeWalker(sourceDoc.getDocumentElement(),
+ NodeFilter.SHOW_ALL, node -> {
+ final var namespace = node.getNamespaceURI();
+ return namespace == null || MONITORING_NAMESPACE.equals(namespace)
+ ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+ }, false);
+
+ final var filteredDoc = XmlUtil.newDocument();
+ filteredDoc.appendChild(filteredDoc.importNode(treeWalker.getRoot(), false));
+ final var filteredElement = filteredDoc.getDocumentElement();
+ copyChildren(treeWalker, filteredDoc, filteredElement);
+
+ return new DOMSource(filteredElement);
+ }
+
+ private static void copyChildren(final TreeWalker walker, final Document targetDoc, final Node targetNode) {
+ if (walker.firstChild() != null) {
+ for (var node = walker.getCurrentNode(); node != null; node = walker.nextSibling()) {
+ final var importedNode = targetDoc.importNode(node, false);
+ targetNode.appendChild(importedNode);
+ copyChildren(walker, targetDoc, importedNode);
+ walker.setCurrentNode(node);
+ }
+ }
}
public static final class RemoteYangSchema {
static Optional<RemoteYangSchema> createFromNormalizedNode(final RemoteDeviceId id,
final MapEntryNode schemaNode) {
- checkArgument(schemaNode.getNodeType().equals(Schema.QNAME), "Wrong QName %s", schemaNode.getNodeType());
+ final QName schemaNodeId = schemaNode.getIdentifier().getNodeType();
+ checkArgument(schemaNodeId.equals(Schema.QNAME), "Wrong QName %s", schemaNodeId);
QName childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_FORMAT;
final QName moduleQName = revisionAsString.isPresent()
? QName.create(namespaceAsString, revisionAsString.get(), moduleNameAsString)
- : QName.create(URI.create(namespaceAsString), moduleNameAsString);
+ : QName.create(XMLNamespace.of(namespaceAsString), moduleNameAsString);
return Optional.of(new RemoteYangSchema(moduleQName));
}
/**
* Extracts all values of a leaf-list node as a set of strings.
*/
- private static Set<String> getAllChildNodeValues(final DataContainerNode<?> schemaNode,
+ private static Set<String> getAllChildNodeValues(final DataContainerNode schemaNode,
final QName childNodeQName) {
final Set<String> extractedValues = new HashSet<>();
- final Optional<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> child =
- schemaNode.getChild(toId(childNodeQName));
+ final Optional<DataContainerChild> child = schemaNode.findChildByArg(toId(childNodeQName));
checkArgument(child.isPresent(), "Child nodes %s not present", childNodeQName);
checkArgument(child.get() instanceof LeafSetNode<?>, "Child nodes %s not present", childNodeQName);
- for (final LeafSetEntryNode<?> childNode : ((LeafSetNode<?>) child.get()).getValue()) {
+ for (final LeafSetEntryNode<?> childNode : ((LeafSetNode<?>) child.get()).body()) {
extractedValues.add(getValueOfSimpleNode(childNode).get());
}
return extractedValues;
}
- private static Optional<String> getSingleChildNodeValue(final DataContainerNode<?> schemaNode,
+ private static Optional<String> getSingleChildNodeValue(final DataContainerNode schemaNode,
final QName childNode) {
- final Optional<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> node =
- schemaNode.getChild(toId(childNode));
+ final Optional<DataContainerChild> node = schemaNode.findChildByArg(toId(childNode));
if (node.isPresent()) {
return getValueOfSimpleNode(node.get());
}
return Optional.empty();
}
- private static Optional<String> getValueOfSimpleNode(
- final NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?> node) {
- final String valueStr = node.getValue().toString();
+ private static Optional<String> getValueOfSimpleNode(final NormalizedNode node) {
+ final String valueStr = node.body().toString();
return Strings.isNullOrEmpty(valueStr) ? Optional.empty() : Optional.of(valueStr.trim());
}
Code Review / netconf.git / blobdiff