import org.opendaylight.yangtools.rfc7952.data.api.NormalizedMetadata;
import org.opendaylight.yangtools.rfc7952.data.util.ImmutableNormalizedMetadata;
import org.opendaylight.yangtools.rfc7952.data.util.ImmutableNormalizedMetadata.Builder;
+import org.opendaylight.yangtools.yang.common.ErrorSeverity;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
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.api.schema.stream.YangInstanceIdentifierWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
final String outputMsgId = output.getDocument().getDocumentElement().getAttribute(MESSAGE_ID_ATTR);
if (!inputMsgId.equals(outputMsgId)) {
- final Map<String, String> errorInfo = ImmutableMap.<String, String>builder()
- .put("actual-message-id", outputMsgId)
- .put("expected-message-id", inputMsgId)
- .build();
-
- throw new NetconfDocumentedException("Response message contained unknown \"message-id\"",
- null, NetconfDocumentedException.ErrorType.PROTOCOL,
- NetconfDocumentedException.ErrorTag.BAD_ATTRIBUTE,
- NetconfDocumentedException.ErrorSeverity.ERROR, errorInfo);
+ throw new NetconfDocumentedException("Response message contained unknown \"message-id\"", null,
+ ErrorType.PROTOCOL, ErrorTag.BAD_ATTRIBUTE, ErrorSeverity.ERROR,
+ ImmutableMap.of("actual-message-id", outputMsgId, "expected-message-id", inputMsgId));
}
}
}
}
- final ErrorSeverity severity = toRpcErrorSeverity(ex.getErrorSeverity());
- return severity == ErrorSeverity.ERROR
- ? RpcResultBuilder.newError(toRpcErrorType(ex.getErrorType()), ex.getErrorTag().getTagValue(),
+ return ex.getErrorSeverity() == ErrorSeverity.ERROR
+ ? RpcResultBuilder.newError(ex.getErrorType(), ex.getErrorTag(),
ex.getLocalizedMessage(), null, infoBuilder.toString(), ex.getCause())
- : RpcResultBuilder.newWarning(
- toRpcErrorType(ex.getErrorType()), ex.getErrorTag().getTagValue(),
+ : RpcResultBuilder.newWarning(ex.getErrorType(), ex.getErrorTag(),
ex.getLocalizedMessage(), null, infoBuilder.toString(), ex.getCause());
}
- private static ErrorSeverity toRpcErrorSeverity(final NetconfDocumentedException.ErrorSeverity severity) {
- switch (severity) {
- case WARNING:
- return RpcError.ErrorSeverity.WARNING;
- default:
- return RpcError.ErrorSeverity.ERROR;
- }
- }
-
- private static RpcError.ErrorType toRpcErrorType(final NetconfDocumentedException.ErrorType type) {
- switch (type) {
- case PROTOCOL:
- return RpcError.ErrorType.PROTOCOL;
- case RPC:
- return RpcError.ErrorType.RPC;
- case TRANSPORT:
- return RpcError.ErrorType.TRANSPORT;
- default:
- return RpcError.ErrorType.APPLICATION;
- }
- }
-
public static NodeIdentifier toId(final PathArgument qname) {
return qname instanceof NodeIdentifier ? (NodeIdentifier) qname : toId(qname.getNodeType());
}
return Builders.containerBuilder().withNodeIdentifier(name).withValue(ImmutableList.copyOf(node)).build();
}
+ /**
+ * Create edit-config structure to invoke {@code operation} with {@code lastChildOverride} data on {@code dataPath}.
+ *
+ * @param ctx {@link EffectiveModelContext} device's model context
+ * @param dataPath {@link YangInstanceIdentifier} path to data in device's data-store
+ * @param operation Optional of {@link ModifyAction} action to be invoked
+ * @param lastChildOverride Optional of {@code NormalizedNode} data on which action will be invoked
+ * @return {@link DOMSourceAnyxmlNode} containing edit-config structure
+ */
public static DOMSourceAnyxmlNode createEditConfigAnyxml(
final EffectiveModelContext ctx, final YangInstanceIdentifier dataPath,
final Optional<ModifyAction> operation, final Optional<NormalizedNode> lastChildOverride) {
- final NormalizedNode configContent;
- final NormalizedMetadata metadata;
if (dataPath.isEmpty()) {
Preconditions.checkArgument(lastChildOverride.isPresent(),
"Data has to be present when creating structure for top level element");
Preconditions.checkArgument(lastChildOverride.get() instanceof DataContainerChild,
"Data has to be either container or a list node when creating structure for top level element, "
+ "but was: %s", lastChildOverride.get());
- configContent = lastChildOverride.get();
- metadata = null;
- } else {
- configContent = ImmutableNodes.fromInstanceId(ctx, dataPath, lastChildOverride);
- metadata = operation.map(oper -> leafMetadata(dataPath, oper)).orElse(null);
}
- final Element element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_CONFIG_QNAME.getLocalName(),
+ final var element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_CONFIG_QNAME.getLocalName(),
Optional.of(NETCONF_CONFIG_QNAME.getNamespace().toString()));
-
+ final var metadata = operation.map(o -> leafMetadata(dataPath, o)).orElse(null);
try {
- NetconfUtil.writeNormalizedNode(configContent, metadata, new DOMResult(element), SchemaPath.ROOT, ctx);
- } catch (IOException | XMLStreamException e) {
+ if (lastChildOverride.isPresent()) {
+ // TODO do not transform this into result and then to xml, rework the whole pipeline to directly write
+ // into xml
+
+ final var parentPath = dataPath.isEmpty() ? dataPath : dataPath.coerceParent();
+ var result = new NormalizedNodeResult();
+ try (var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result)) {
+ try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, ctx, parentPath);
+ var nnWriter = NormalizedNodeWriter.forStreamWriter(streamWriter)) {
+ nnWriter.write(lastChildOverride.get());
+ }
+ }
+ NetconfUtil.writeNormalizedNode(result.getResult(), metadata, new DOMResult(element),
+ SchemaPath.ROOT, ctx);
+ } else {
+ NetconfUtil.writeNormalizedNode(dataPath, metadata, new DOMResult(element), SchemaPath.ROOT, ctx);
+ }
+ } catch (final IOException | XMLStreamException e) {
throw new IllegalStateException("Unable to serialize edit config content element for path " + dataPath, e);
}
throws IOException, XMLStreamException {
final QName inputQName = YangConstants.operationInputQName(operationPath.lastNodeIdentifier().getModule());
// FIXME: eliminate this conversion
- final SchemaPath inputPath = operationPath.asSchemaPath().createChild(inputQName);
+ final SchemaPath inputPath = SchemaPath.of(operationPath).createChild(inputQName);
final XMLStreamWriter writer = NetconfUtil.XML_FACTORY.createXMLStreamWriter(result);
try {
public static RpcResult<NetconfMessage> toRpcResult(final FailedNetconfMessage message) {
return RpcResultBuilder.<NetconfMessage>failed()
- .withRpcError(
- toRpcError(
- new NetconfDocumentedException(
- message.getException().getMessage(),
- DocumentedException.ErrorType.APPLICATION,
- DocumentedException.ErrorTag.MALFORMED_MESSAGE,
- DocumentedException.ErrorSeverity.ERROR)))
+ .withRpcError(toRpcError(new NetconfDocumentedException(message.getException().getMessage(),
+ ErrorType.APPLICATION, ErrorTag.MALFORMED_MESSAGE, ErrorSeverity.ERROR)))
.build();
}
}
Code Review / netconf.git / blobdiff