X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-netconf-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fconnect%2Fnetconf%2Fschema%2Fmapping%2FNetconfMessageTransformer.java;h=e768b5eb5b62ba66d81c3e0c731ee2364577c145;hp=80d0f67ac49c72b47d35e6ca094ec4610099c1b1;hb=effca64cb7086d4518602474f4b2047eff693646;hpb=d89bf60857d94ac982ea52e163a5e61a71b52330 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 80d0f67ac4..e768b5eb5b 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,29 +7,56 @@ */ package org.opendaylight.controller.sal.connect.netconf.schema.mapping; -import com.google.common.base.Optional; +import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RPC_QNAME; +import static org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_URI; +import com.google.common.base.Function; +import com.google.common.base.Preconditions; +import com.google.common.base.Predicate; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multimaps; +import java.io.IOException; +import java.util.Collection; +import java.util.Collections; import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; import java.util.Set; - -import javax.activation.UnsupportedDataTypeException; - +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.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.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.common.RpcResult; -import org.opendaylight.yangtools.yang.common.RpcResultBuilder; -import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl; -import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode; -import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider; -import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils; -import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder; -import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; +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.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; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.DomToNormalizedNodeParserFactory; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; @@ -37,89 +64,212 @@ public class NetconfMessageTransformer implements MessageTransformer schemaContext = Optional.absent(); + private static final Logger LOG= LoggerFactory.getLogger(NetconfMessageTransformer.class); + + + private static final Function QNAME_FUNCTION = new Function() { + @Override + public QName apply(final SchemaNode rpcDefinition) { + return rpcDefinition.getQName(); + } + }; + + private static final Function QNAME_NOREV_FUNCTION = new Function() { + @Override + public QName apply(final SchemaNode notification) { + return QNAME_FUNCTION.apply(notification).withoutRevision(); + } + }; + private static final SchemaContext BASE_NETCONF_CTX; + + static { + try { + final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create(); + moduleInfoBackedContext.addModuleInfos( + Lists.newArrayList(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.$YangModuleInfoImpl.getInstance())); + BASE_NETCONF_CTX = moduleInfoBackedContext.tryToCreateSchemaContext().get(); + } catch (final RuntimeException e) { + LOG.error("Unable to prepare schema context for base netconf ops", e); + throw new ExceptionInInitializerError(e); + } + } + private static final Map 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() { + 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); } @Override - public synchronized CompositeNode toNotification(final NetconfMessage message) { - if(schemaContext.isPresent()) { - return toNotification(message, schemaContext.get()); - } else { - return XmlDocumentUtils.notificationToDomNodes(message.getDocument(), Optional.>absent()); + public synchronized ContainerNode toNotification(final NetconfMessage message) { + final XmlElement stripped = stripNotification(message); + final QName notificationNoRev; + try { + // How to construct QName with no revision ? + notificationNoRev = QName.cachedReference(QName.create(stripped.getNamespace(), "0000-00-00", stripped.getName()).withoutRevision()); + } catch (final MissingNameSpaceException e) { + throw new IllegalArgumentException("Unable to parse notification " + message + ", cannot find namespace", e); } - } - private static CompositeNode toNotification(final NetconfMessage message, final SchemaContext ctx) { - final Set notifications = ctx.getNotifications(); - final Document document = message.getDocument(); - return XmlDocumentUtils.notificationToDomNodes(document, Optional.fromNullable(notifications), ctx); + final Collection notificationDefinitions = mappedNotifications.get(notificationNoRev); + Preconditions.checkArgument(notificationDefinitions.size() > 0, + "Unable to parse notification %s, unknown notification. Available notifications: %s", notificationDefinitions, mappedNotifications.keySet()); + + // FIXME if multiple revisions for same notifications are present, we should pick the most recent. Or ? + // We should probably just put the most recent notification versions into our map. We can expect that the device sends the data according to the latest available revision of a model. + final NotificationDefinition next = notificationDefinitions.iterator().next(); + + // We wrap the notification as a container node in order to reuse the parsers and builders for container node + final ContainerSchemaNode notificationAsContainerSchemaNode = NetconfMessageTransformUtil.createSchemaForNotification(next); + return parserFactory.getContainerNodeParser().parse(Collections.singleton(stripped.getDomElement()), notificationAsContainerSchemaNode); } - @Override - public NetconfMessage toRpcRequest(final QName rpc, final CompositeNode node) { - final CompositeNodeTOImpl rpcPayload = NetconfMessageTransformUtil.wrap( - NetconfMessageTransformUtil.NETCONF_RPC_QNAME, NetconfMessageTransformUtil.flattenInput(node)); - final Document w3cPayload; + // FIXME move somewhere to util + private static XmlElement stripNotification(final NetconfMessage message) { + final XmlElement xmlElement = XmlElement.fromDomDocument(message.getDocument()); + final List childElements = xmlElement.getChildElements(); + Preconditions.checkArgument(childElements.size() == 2, "Unable to parse notification %s, unexpected format", message); try { - final XmlCodecProvider codecProvider = XmlDocumentUtils.defaultValueCodecProvider(); - if(schemaContext.isPresent()) { - if (NetconfMessageTransformUtil.isDataEditOperation(rpc)) { - final DataNodeContainer schemaForEdit = NetconfMessageTransformUtil.createSchemaForEdit(schemaContext.get()); - w3cPayload = XmlDocumentUtils.toDocument(rpcPayload, schemaForEdit, codecProvider); - } else { - // FIXME get and get-config needs schema as well to transform filter using schema context - // e.g. Identityref nodes in filter fail to serialize properly to xml without schema - w3cPayload = XmlDocumentUtils.toDocument(rpcPayload, schemaContext.get(), codecProvider); + return Iterables.find(childElements, new Predicate() { + @Override + public boolean apply(final XmlElement xmlElement) { + return !xmlElement.getName().equals("eventTime"); } - } else { - w3cPayload = XmlDocumentUtils.toDocument(rpcPayload, codecProvider); - } - } catch (final UnsupportedDataTypeException e) { - throw new IllegalArgumentException("Unable to create message", e); + }); + } catch (final NoSuchElementException e) { + throw new IllegalArgumentException("Unable to parse notification " + message + ", cannot strip notification metadata", e); } - w3cPayload.getDocumentElement().setAttribute("message-id", counter.getNewMessageId(MESSAGE_ID_PREFIX)); - return new NetconfMessage(w3cPayload); } @Override - public synchronized RpcResult toRpcResult(final NetconfMessage message, final QName rpc) { - if(schemaContext.isPresent()) { - return toRpcResult(message, rpc, schemaContext.get()); - } else { - final CompositeNode node = (CompositeNode) XmlDocumentUtils.toDomNode(message.getDocument()); - return RpcResultBuilder.success( node ).build(); + public NetconfMessage toRpcRequest(SchemaPath rpc, final NormalizedNode payload) { + // In case no input for rpc is defined, we can simply construct the payload here + final QName rpcQName = 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; } - } - private static RpcResult toRpcResult(final NetconfMessage message, final QName rpc, final SchemaContext context) { - final CompositeNode compositeNode; + Preconditions.checkNotNull(currentMappedRpcs.get(rpcQName), "Unknown rpc %s, available rpcs: %s", rpcQName, currentMappedRpcs.keySet()); + if(currentMappedRpcs.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); + } - if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpc)) { + 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); - final Element xmlData = NetconfMessageTransformUtil.getDataSubtree(message.getDocument()); + // 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 { + // 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 List> dataNodes = XmlDocumentUtils.toDomNodes(xmlData, - Optional.of(context.getDataDefinitions()), context); + final Document node = result.getNode().getOwnerDocument(); - final CompositeNodeBuilder it = ImmutableCompositeNode.builder(); - it.setQName(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME); - it.add(ImmutableCompositeNode.create(NetconfMessageTransformUtil.NETCONF_DATA_QNAME, dataNodes)); + node.getDocumentElement().setAttribute(NetconfMessageTransformUtil.MESSAGE_ID_ATTR, counter.getNewMessageId(MESSAGE_ID_PREFIX)); + return new NetconfMessage(node); + } - compositeNode = it.toInstance(); - } else { - // TODO map rpc with schema - compositeNode = (CompositeNode) XmlDocumentUtils.toDomNode(message.getDocument()); - } + private static boolean isBaseRpc(final QName rpc) { + return rpc.getNamespace().equals(NETCONF_URI); + } - return RpcResultBuilder.success( compositeNode ).build(); + 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()); + final Element elementNS = document.createElementNS(rpcQName.getNamespace().toString(), rpcQName.getLocalName()); + rpcNS.appendChild(elementNS); + document.appendChild(rpcNS); + return new DOMResult(elementNS); + } + + 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 = NetconfMessageTransformUtil.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); + } + } } @Override - public synchronized void onGlobalContextUpdated(final SchemaContext schemaContext) { - this.schemaContext = Optional.of(schemaContext); + public synchronized DOMRpcResult toRpcResult(final NetconfMessage message, final SchemaPath rpc) { + final NormalizedNode normalizedNode; + 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 = parserFactory.getContainerNodeParser().parse(Collections.singleton(xmlData), schemaForDataRead); + + normalizedNode = Builders.containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME)) + .withChild(dataNode).build(); + } else { + final Set documentElement = Collections.singleton(message.getDocument().getDocumentElement()); + + 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) { + Preconditions.checkArgument(XmlElement.fromDomDocument(message.getDocument()).getOnlyChildElementWithSameNamespaceOptionally("ok").isPresent(), + "Unexpected content in response of rpc: %s, %s", rpcDefinition.getQName(), message); + normalizedNode = null; + } else { + normalizedNode = parserFactory.getContainerNodeParser().parse(documentElement, rpcDefinition.getOutput()); + } + } + return new DefaultDOMRpcResult(normalizedNode); } + }