+ * Due to this we perform a quick test for behavior and decide the appropriate strategy.
+ */
+ @FunctionalInterface
+ private interface NamespaceSetter {
+ void initializeNamespace(XMLStreamWriter writer) throws XMLStreamException;
+
+ static NamespaceSetter forFactory(final XMLOutputFactory xmlFactory) {
+ final String netconfNamespace = NETCONF_QNAME.getNamespace().toString();
+ final AnyXmlNamespaceContext namespaceContext = new AnyXmlNamespaceContext(ImmutableMap.of(
+ "op", netconfNamespace));
+
+ try {
+ final XMLStreamWriter testWriter = xmlFactory.createXMLStreamWriter(new DOMResult(
+ XmlUtil.newDocument()));
+ testWriter.setNamespaceContext(namespaceContext);
+ } catch (final UnsupportedOperationException e) {
+ // This happens with JDK's DOM writer, which we may be using
+ LOG.warn("Unable to set namespace context, falling back to setPrefix()", e);
+ return writer -> writer.setPrefix("op", netconfNamespace);
+ } catch (XMLStreamException e) {
+ throw new ExceptionInInitializerError(e);
+ }
+
+ // Success, we can use setNamespaceContext()
+ return writer -> writer.setNamespaceContext(namespaceContext);
+ }
+ }
private static final Logger LOG = LoggerFactory.getLogger(NetconfUtil.class);
+
+ // FIXME: document what exactly this QName means, as it is not referring to a tangible node nor the ietf-module.
+ // FIXME: what is this contract saying?
+ // - is it saying all data is going to be interpreted with this root?
+ // - is this saying we are following a specific interface contract (i.e. do we have schema mounts?)
+ // - is it also inferring some abilities w.r.t. RFC8342?
+ public static final QName NETCONF_QNAME = QName.create(QNameModule.create(SchemaContext.NAME.getNamespace(),
+ Revision.of("2011-06-01")), "netconf").intern();
+ // FIXME: is this the device-bound revision?
+ public static final QName NETCONF_DATA_QNAME = QName.create(NETCONF_QNAME, "data").intern();
+
public static final XMLOutputFactory XML_FACTORY;
static {
- XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ final XMLOutputFactory f = XMLOutputFactory.newFactory();
+ // FIXME: not repairing namespaces is probably common, this should be availabe as common XML constant.
+ f.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY = f;
}
- private NetconfUtil() {}
+ private static final NamespaceSetter XML_NAMESPACE_SETTER = NamespaceSetter.forFactory(XML_FACTORY);
+
+ private NetconfUtil() {
+ // No-op
+ }
- public static Document checkIsMessageOk(Document response) throws DocumentedException {
- XmlElement element = XmlElement.fromDomDocument(response);
- Preconditions.checkState(element.getName().equals(XmlMappingConstants.RPC_REPLY_KEY));
- element = element.getOnlyChildElement();
- if (element.getName().equals(XmlNetconfConstants.OK)) {
+ public static Document checkIsMessageOk(final Document response) throws DocumentedException {
+ final XmlElement docElement = XmlElement.fromDomDocument(response);
+ // FIXME: we should throw DocumentedException here
+ checkState(XmlNetconfConstants.RPC_REPLY_KEY.equals(docElement.getName()));
+ final XmlElement element = docElement.getOnlyChildElement();
+ if (XmlNetconfConstants.OK.equals(element.getName())) {
return response;
}
+
LOG.warn("Can not load last configuration. Operation failed.");
+ // FIXME: we should be throwing a DocumentedException here
throw new IllegalStateException("Can not load last configuration. Operation failed: "
+ XmlUtil.toString(response));
}
- public static void writeNormalizedNode(final NormalizedNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext context)
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public static void writeNormalizedNode(final NormalizedNode normalized, final DOMResult result,
+ final SchemaPath schemaPath, final SchemaContext context)
throws IOException, XMLStreamException {
final XMLStreamWriter writer = XML_FACTORY.createXMLStreamWriter(result);
try (
- final NormalizedNodeStreamWriter normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath);
- final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter)
+ NormalizedNodeStreamWriter normalizedNodeStreamWriter =
+ XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath);
+ NormalizedNodeWriter normalizedNodeWriter =
+ NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter)
) {
normalizedNodeWriter.write(normalized);
normalizedNodeWriter.flush();
} finally {
try {
- if(writer != null) {
+ if (writer != null) {
writer.close();
}
} catch (final Exception e) {
@@ -71,4 +154,78 @@ public final class NetconfUtil {
}
}
}
+
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public static void writeNormalizedNode(final NormalizedNode normalized,
+ final @Nullable NormalizedMetadata metadata,
+ final DOMResult result, final SchemaPath schemaPath,
+ final SchemaContext context) throws IOException, XMLStreamException {
+ if (metadata == null) {
+ writeNormalizedNode(normalized, result, schemaPath, context);
+ return;
+ }
+
+ final XMLStreamWriter writer = XML_FACTORY.createXMLStreamWriter(result);
+ XML_NAMESPACE_SETTER.initializeNamespace(writer);
+ try (
+ NormalizedNodeStreamWriter normalizedNodeStreamWriter =
+ XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath);
+ NormalizedMetadataWriter normalizedNodeWriter =
+ NormalizedMetadataWriter.forStreamWriter(normalizedNodeStreamWriter)
+ ) {
+ normalizedNodeWriter.write(normalized, metadata);
+ normalizedNodeWriter.flush();
+ } finally {
+ try {
+ if (writer != null) {
+ writer.close();
+ }
+ } catch (final Exception e) {
+ LOG.warn("Unable to close resource properly", e);
+ }
+ }
+ }
+
+ public static void writeFilter(final YangInstanceIdentifier query, final DOMResult result,
+ final SchemaPath schemaPath, final SchemaContext context) throws IOException, XMLStreamException {
+ if (query.isEmpty()) {
+ // No query at all
+ return;
+ }
+
+ final XMLStreamWriter xmlWriter = XML_FACTORY.createXMLStreamWriter(result);
+ try {
+ try (NormalizedNodeStreamWriter writer =
+ XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, context, schemaPath)) {
+ final Iterator