X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-netconf-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fconnect%2Fnetconf%2Fschema%2Fmapping%2FNetconfMessageTransformer.java;h=303f3e692390ff8a396781377da9c2b99f2e4cd3;hb=cbf7f08ade1ef9ea49e8587188ca2fa58e09731c;hp=cfb302d871d0e1a560eb99ba572625b464cdc8e1;hpb=8ce853c0627e829d40fe18e550bc807efbcbafee;p=controller.git diff --git a/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java b/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java index cfb302d871..303f3e6923 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java @@ -7,15 +7,10 @@ */ package org.opendaylight.controller.sal.connect.netconf.schema.mapping; -import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_CONFIG_QNAME; -import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_FILTER_QNAME; import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RPC_QNAME; -import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_TYPE_QNAME; import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_URI; -import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.toId; import com.google.common.base.Function; -import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.base.Predicate; import com.google.common.collect.Iterables; @@ -30,29 +25,26 @@ import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; -import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import javax.xml.transform.dom.DOMResult; import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult; import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult; import org.opendaylight.controller.netconf.api.NetconfMessage; +import org.opendaylight.controller.netconf.util.OrderedNormalizedNodeWriter; import org.opendaylight.controller.netconf.util.exception.MissingNameSpaceException; import org.opendaylight.controller.netconf.util.xml.XmlElement; import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.opendaylight.controller.sal.connect.api.MessageTransformer; import org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil; import org.opendaylight.controller.sal.connect.util.MessageCounter; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.edit.config.input.EditContent; import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -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.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; import org.opendaylight.yangtools.yang.data.impl.codec.xml.XMLStreamNormalizedNodeStreamWriter; import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlUtils; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; @@ -67,7 +59,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; -import org.w3c.dom.Node; public class NetconfMessageTransformer implements MessageTransformer { @@ -75,7 +66,6 @@ public class NetconfMessageTransformer implements MessageTransformer QNAME_FUNCTION = new Function() { @Override @@ -95,7 +85,6 @@ public class NetconfMessageTransformer implements MessageTransformer MAPPED_BASE_RPCS = Maps.uniqueIndex(BASE_NETCONF_CTX.getOperations(), QNAME_FUNCTION); private final SchemaContext schemaContext; private final MessageCounter counter; private final Map mappedRpcs; private final Multimap mappedNotifications; + private final DomToNormalizedNodeParserFactory parserFactory; public NetconfMessageTransformer(final SchemaContext schemaContext) { this.counter = new MessageCounter(); this.schemaContext = schemaContext; + parserFactory = DomToNormalizedNodeParserFactory.getInstance(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext); mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), QNAME_FUNCTION); mappedNotifications = Multimaps.index(schemaContext.getNotifications(), QNAME_NOREV_FUNCTION); @@ -139,7 +131,7 @@ public class NetconfMessageTransformer implements MessageTransformer payload) { // In case no input for rpc is defined, we can simply construct the payload here final QName rpcQName = rpc.getLastComponent(); - Preconditions.checkNotNull(mappedRpcs.get(rpcQName), "Unknown rpc %s, available rpcs: %s", rpcQName, mappedRpcs.keySet()); - if(mappedRpcs.get(rpcQName).getInput() == null) { - final Document document = XmlUtil.newDocument(); - final Element elementNS = document.createElementNS(rpcQName.getNamespace().toString(), rpcQName.getLocalName()); - document.appendChild(elementNS); - return new NetconfMessage(document); + Map currentMappedRpcs = mappedRpcs; + + // Determine whether a base netconf operation is being invoked and also check if the device exposed model for base netconf + // If no, use pre built base netconf operations model + final boolean needToUseBaseCtx = mappedRpcs.get(rpcQName) == null && isBaseRpc(rpcQName); + if(needToUseBaseCtx) { + currentMappedRpcs = MAPPED_BASE_RPCS; + } + + Preconditions.checkNotNull(currentMappedRpcs.get(rpcQName), "Unknown rpc %s, available rpcs: %s", rpcQName, currentMappedRpcs.keySet()); + if(currentMappedRpcs.get(rpcQName).getInput() == null) { + return new NetconfMessage(prepareDomResultForRpcRequest(rpcQName).getNode().getOwnerDocument()); } + Preconditions.checkNotNull(payload, "Transforming an rpc with input: %s, payload cannot be null", rpcQName); + Preconditions.checkArgument(payload instanceof ContainerNode, + "Transforming an rpc with input: %s, payload has to be a container, but was: %s", rpcQName, payload); + // Set the path to the input of rpc for the node stream writer rpc = rpc.createChild(QName.cachedReference(QName.create(rpcQName, "input"))); final DOMResult result = prepareDomResultForRpcRequest(rpcQName); try { - final SchemaContext baseNetconfCtx = schemaContext.findModuleByNamespace(NETCONF_URI).isEmpty() ? BASE_NETCONF_CTX : schemaContext; - if(NetconfMessageTransformUtil.isDataEditOperation(rpcQName)) { - writeNormalizedEdit(payload, result, rpc, baseNetconfCtx); - } else if(NetconfMessageTransformUtil.isDataRetrievalOperation(rpcQName)) { - writeNormalizedGet(payload, result, rpc, baseNetconfCtx); - } else { - writeNormalizedRpc(payload, result, rpc, schemaContext); - } + // If the schema context for netconf device does not contain model for base netconf operations, use default pre build context with just the base model + // This way operations like lock/unlock are supported even if the source for base model was not provided + writeNormalizedRpc(((ContainerNode) payload), result, rpc, needToUseBaseCtx ? BASE_NETCONF_CTX : schemaContext); } catch (final XMLStreamException | IOException | IllegalStateException e) { throw new IllegalStateException("Unable to serialize " + rpc, e); } final Document node = result.getNode().getOwnerDocument(); - node.getDocumentElement().setAttribute(NetconfMessageTransformUtil.MESSAGE_ID_ATTR, counter.getNewMessageId(MESSAGE_ID_PREFIX)); return new NetconfMessage(node); } + private static boolean isBaseRpc(final QName rpc) { + return rpc.getNamespace().equals(NETCONF_URI); + } + private DOMResult prepareDomResultForRpcRequest(final QName rpcQName) { final Document document = XmlUtil.newDocument(); final Element rpcNS = document.createElementNS(NETCONF_RPC_QNAME.getNamespace().toString(), NETCONF_RPC_QNAME.getLocalName()); + // set msg id + rpcNS.setAttribute(NetconfMessageTransformUtil.MESSAGE_ID_ATTR, counter.getNewMessageId(MESSAGE_ID_PREFIX)); final Element elementNS = document.createElementNS(rpcQName.getNamespace().toString(), rpcQName.getLocalName()); rpcNS.appendChild(elementNS); document.appendChild(rpcNS); return new DOMResult(elementNS); } - static final XMLOutputFactory XML_FACTORY; - static { - XML_FACTORY = XMLOutputFactory.newFactory(); - XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true); - } - - // FIXME similar code is in netconf-notifications-impl , DRY - private void writeNormalizedNode(final NormalizedNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext context) - throws IOException, XMLStreamException { - NormalizedNodeWriter normalizedNodeWriter = null; - NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; - XMLStreamWriter writer = null; - try { - writer = XML_FACTORY.createXMLStreamWriter(result); - normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath); - normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter); - - normalizedNodeWriter.write(normalized); - - normalizedNodeWriter.flush(); - } finally { - try { - if(normalizedNodeWriter != null) { - normalizedNodeWriter.close(); - } - if(normalizedNodeStreamWriter != null) { - normalizedNodeStreamWriter.close(); - } - if(writer != null) { - writer.close(); - } - } catch (final Exception e) { - LOG.warn("Unable to close resource properly", e); - } - } - } - - private void writeNormalizedEdit(final ContainerNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext baseNetconfCtx) throws IOException, XMLStreamException { - final NormalizedNodeWriter normalizedNodeWriter; - NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; - XMLStreamWriter writer = null; - try { - writer = XML_FACTORY.createXMLStreamWriter(result); - normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath); - normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter); - - Optional> editDataElements = Optional.absent(); - for (final DataContainerChild editElement : normalized.getValue()) { - if(editElement.getNodeType().getLocalName().equals(EditContent.QNAME.getLocalName())) { - Preconditions.checkState(editElement instanceof ChoiceNode, - "Edit content element is expected to be %s, not %s", ChoiceNode.class, editElement); - final Optional> configContentHolder = - ((ChoiceNode) editElement).getChild(toId(NETCONF_CONFIG_QNAME)); - // TODO The config element inside the EditContent should be AnyXml not Container, but AnyXml is based on outdated API - Preconditions.checkState(configContentHolder.isPresent() && configContentHolder.get() instanceof ContainerNode, - "Edit content/config element is expected to be present as a container node"); - normalizedNodeStreamWriter.startChoiceNode(toId(editElement.getNodeType()), 1); - normalizedNodeStreamWriter.anyxmlNode(toId(NETCONF_CONFIG_QNAME), null); - normalizedNodeStreamWriter.endNode(); - - editDataElements = Optional.of(serializeAnyXmlAccordingToSchema(((ContainerNode) configContentHolder.get()).getValue())); - } else { - normalizedNodeWriter.write(editElement); - } - } - - normalizedNodeWriter.flush(); - - // FIXME this is a workaround for filter content serialization - // Any xml is not supported properly by the stream writer - if(editDataElements.isPresent()) { - appendEditData(result, editDataElements.get()); - } - } finally { - try { - if(normalizedNodeStreamWriter != null) { - normalizedNodeStreamWriter.close(); - } - if(writer != null) { - writer.close(); - } - } catch (final Exception e) { - LOG.warn("Unable to close resource properly", e); - } - } - } - private void writeNormalizedRpc(final ContainerNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext baseNetconfCtx) throws IOException, XMLStreamException { - final NormalizedNodeWriter normalizedNodeWriter; - NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; - XMLStreamWriter writer = null; - try { - writer = XML_FACTORY.createXMLStreamWriter(result); - normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath); - normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter); - - for (final DataContainerChild editElement : normalized.getValue()) { - normalizedNodeWriter.write(editElement); - } - normalizedNodeWriter.flush(); - } finally { - try { - if(normalizedNodeStreamWriter != null) { - normalizedNodeStreamWriter.close(); - } - if(writer != null) { - writer.close(); - } - } catch (final Exception e) { - LOG.warn("Unable to close resource properly", e); - } - } - } - - private void writeNormalizedGet(final ContainerNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext baseNetconfCtx) throws IOException, XMLStreamException { - final NormalizedNodeWriter normalizedNodeWriter; + final OrderedNormalizedNodeWriter normalizedNodeWriter; NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; XMLStreamWriter writer = null; try { - writer = XML_FACTORY.createXMLStreamWriter(result); + writer = NetconfMessageTransformUtil.XML_FACTORY.createXMLStreamWriter(result); normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath); - normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter); - - Optional> filterElements = Optional.absent(); - - for (final DataContainerChild editElement : normalized.getValue()) { - Preconditions.checkState(editElement instanceof ContainerNode); - if(editElement.getNodeType().getLocalName().equals(NETCONF_FILTER_QNAME.getLocalName())) { - Preconditions.checkState(editElement instanceof ContainerNode, - "Filter element is expected to be %s, not %s", ContainerNode.class, editElement); - normalizedNodeStreamWriter.anyxmlNode(toId(editElement.getNodeType()), null); - filterElements = Optional.of(serializeAnyXmlAccordingToSchema(((ContainerNode) editElement).getValue())); - } else { - normalizedNodeWriter.write(editElement); - } - } - + normalizedNodeWriter = new OrderedNormalizedNodeWriter(normalizedNodeStreamWriter, baseNetconfCtx, schemaPath); + Collection> value = (Collection) normalized.getValue(); + normalizedNodeWriter.write(value); normalizedNodeWriter.flush(); - - // FIXME this is a workaround for filter content serialization - // Any xml is not supported properly by the stream writer - if(filterElements.isPresent()) { - appendFilter(result, filterElements.get()); - } } finally { try { if(normalizedNodeStreamWriter != null) { @@ -361,63 +230,39 @@ public class NetconfMessageTransformer implements MessageTransformer filterElements) { - final Element rpcElement = ((Element) result.getNode()); - final Node filterParent = rpcElement.getElementsByTagNameNS(NETCONF_FILTER_QNAME.getNamespace().toString(), NETCONF_FILTER_QNAME.getLocalName()).item(0); - final Document ownerDocument = rpcElement.getOwnerDocument(); - // TODO workaround, add subtree attribute, since it is not serialized by the caller of this method - ((Element) filterParent).setAttributeNS(NETCONF_TYPE_QNAME.getNamespace().toString(), NETCONF_TYPE_QNAME.getLocalName(), "subtree"); - for (final Element element : filterElements) { - filterParent.appendChild(ownerDocument.importNode(element, true)); - } - } - - private void appendEditData(final DOMResult result, final Iterable filterElements) { - final Element rpcElement = ((Element) result.getNode()); - final Node configParent = rpcElement.getElementsByTagNameNS(NETCONF_CONFIG_QNAME.getNamespace().toString(), NETCONF_CONFIG_QNAME.getLocalName()).item(0); - for (final Element element : filterElements) { - configParent.appendChild(rpcElement.getOwnerDocument().importNode(element, true)); - } - } - - private Iterable serializeAnyXmlAccordingToSchema(final Iterable> values) throws IOException, XMLStreamException { - return Iterables.transform(values, new Function, Element>() { - @Override - public Element apply(final DataContainerChild input) { - final DOMResult domResult = new DOMResult(XmlUtil.newDocument()); - try { - writeNormalizedNode(input, domResult, SchemaPath.ROOT, schemaContext); - } catch (IOException | XMLStreamException e) { - throw new IllegalStateException(e); - } - return ((Document) domResult.getNode()).getDocumentElement(); - } - }); - } - @Override public synchronized DOMRpcResult toRpcResult(final NetconfMessage message, final SchemaPath rpc) { final NormalizedNode normalizedNode; - if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpc.getLastComponent())) { + final QName rpcQName = rpc.getLastComponent(); + if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpcQName)) { final Element xmlData = NetconfMessageTransformUtil.getDataSubtree(message.getDocument()); final ContainerSchemaNode schemaForDataRead = NetconfMessageTransformUtil.createSchemaForDataRead(schemaContext); - final ContainerNode dataNode = NORMALIZED_NODE_PARSER_FACTORY.getContainerNodeParser().parse(Collections.singleton(xmlData), schemaForDataRead); + final ContainerNode dataNode = parserFactory.getContainerNodeParser().parse(Collections.singleton(xmlData), schemaForDataRead); - // TODO check if the response is wrapper correctly normalizedNode = Builders.containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME)) .withChild(dataNode).build(); } else { final Set documentElement = Collections.singleton(message.getDocument().getDocumentElement()); - final RpcDefinition rpcDefinition = mappedRpcs.get(rpc.getLastComponent()); - Preconditions.checkArgument(rpcDefinition != null, "Unable to parse response of %s, the rpc is unknown", rpc.getLastComponent()); + + Map currentMappedRpcs = mappedRpcs; + + // Determine whether a base netconf operation is being invoked and also check if the device exposed model for base netconf + // If no, use pre built base netconf operations model + final boolean needToUseBaseCtx = mappedRpcs.get(rpcQName) == null && isBaseRpc(rpcQName); + if(needToUseBaseCtx) { + currentMappedRpcs = MAPPED_BASE_RPCS; + } + + final RpcDefinition rpcDefinition = currentMappedRpcs.get(rpcQName); + Preconditions.checkArgument(rpcDefinition != null, "Unable to parse response of %s, the rpc is unknown", rpcQName); // In case no input for rpc is defined, we can simply construct the payload here - if(rpcDefinition.getOutput() == null) { + if (rpcDefinition.getOutput() == null) { Preconditions.checkArgument(XmlElement.fromDomDocument(message.getDocument()).getOnlyChildElementWithSameNamespaceOptionally("ok").isPresent(), "Unexpected content in response of rpc: %s, %s", rpcDefinition.getQName(), message); normalizedNode = null; } else { - normalizedNode = NORMALIZED_NODE_PARSER_FACTORY.getContainerNodeParser().parse(documentElement, rpcDefinition.getOutput()); + normalizedNode = parserFactory.getContainerNodeParser().parse(documentElement, rpcDefinition.getOutput()); } } return new DefaultDOMRpcResult(normalizedNode);