X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=netconf%2Fsal-netconf-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnetconf%2Fsal%2Fconnect%2Fnetconf%2FNetconfStateSchemas.java;h=3061b8d17052d4a19ec0dbe2d2cd083f583302e9;hb=c3d40c5e4485e95b9307fcdff1833ca1568f9321;hp=92705dccedacb4377961da6b479bc7095dcfbe6d;hpb=3b5e41839346a83c1d8d54b3d869e19d9e417063;p=netconf.git diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/NetconfStateSchemas.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/NetconfStateSchemas.java index 92705dcced..3061b8d170 100644 --- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/NetconfStateSchemas.java +++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/NetconfStateSchemas.java @@ -10,6 +10,7 @@ package org.opendaylight.netconf.sal.connect.netconf; 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; @@ -22,7 +23,6 @@ import com.google.common.annotations.VisibleForTesting; 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; @@ -44,6 +44,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.mon 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; @@ -60,6 +61,10 @@ import org.slf4j.Logger; 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; /** @@ -69,8 +74,9 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { 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 { @@ -130,7 +136,7 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { 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); @@ -143,14 +149,14 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { return EMPTY; } - final Optional> optSchemasNode = findSchemasNode(schemasNodeResult.getResult(), + final Optional optSchemasNode = findSchemasNode(schemasNodeResult.getResult(), schemaContext); - if (!optSchemasNode.isPresent()) { + 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); @@ -163,54 +169,91 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { protected static NetconfStateSchemas create(final RemoteDeviceId id, final ContainerNode schemasNode) { final Set availableYangSchemas = new HashSet<>(); - final Optional> child = - schemasNode.getChild(toId(Schema.QNAME)); + final Optional 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 fromCompositeNode = RemoteYangSchema.createFromNormalizedNode(id, schemaNode); - if (fromCompositeNode.isPresent()) { - availableYangSchemas.add(fromCompositeNode.get()); - } + fromCompositeNode.ifPresent(availableYangSchemas::add); } return new NetconfStateSchemas(availableYangSchemas); } - private static Optional> findSchemasNode(final NormalizedNode result, + private static Optional findSchemasNode(final NormalizedNode result, final EffectiveModelContext schemaContext) { if (result == null) { return Optional.empty(); } - final Optional> rpcResultOpt = ((ContainerNode)result).getChild(NETCONF_DATA_NODEID); - if (!rpcResultOpt.isPresent()) { + // 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> nStateNode = ((DataContainerNode) dataNode).getChild( - toId(NetconfState.QNAME)); - if (!nStateNode.isPresent()) { + // 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 { @@ -226,7 +269,8 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { static Optional 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; @@ -246,7 +290,7 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_NAMESPACE; final Optional namespaceValue = getSingleChildNodeValue(schemaNode, childNode); - if (!namespaceValue.isPresent()) { + if (namespaceValue.isEmpty()) { LOG.warn("{}: Ignoring schema due to missing namespace", id); return Optional.empty(); } @@ -261,7 +305,7 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { 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)); } @@ -269,23 +313,21 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { /** * Extracts all values of a leaf-list node as a set of strings. */ - private static Set getAllChildNodeValues(final DataContainerNode schemaNode, + private static Set getAllChildNodeValues(final DataContainerNode schemaNode, final QName childNodeQName) { final Set extractedValues = new HashSet<>(); - final Optional> child = - schemaNode.getChild(toId(childNodeQName)); + final Optional 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 getSingleChildNodeValue(final DataContainerNode schemaNode, + private static Optional getSingleChildNodeValue(final DataContainerNode schemaNode, final QName childNode) { - final Optional> node = - schemaNode.getChild(toId(childNode)); + final Optional node = schemaNode.findChildByArg(toId(childNode)); if (node.isPresent()) { return getValueOfSimpleNode(node.get()); } @@ -293,9 +335,8 @@ public final class NetconfStateSchemas implements NetconfDeviceSchemas { return Optional.empty(); } - private static Optional getValueOfSimpleNode( - final NormalizedNode node) { - final String valueStr = node.getValue().toString(); + private static Optional getValueOfSimpleNode(final NormalizedNode node) { + final String valueStr = node.body().toString(); return Strings.isNullOrEmpty(valueStr) ? Optional.empty() : Optional.of(valueStr.trim()); }