* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.Nonnull;
+import java.util.Locale;
+import java.util.Optional;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
+import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
-import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
-import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
import org.opendaylight.restconf.common.patch.PatchContext;
import org.opendaylight.restconf.common.patch.PatchEditOperation;
import org.opendaylight.restconf.common.patch.PatchEntity;
+import org.opendaylight.restconf.common.util.RestUtil;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
+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.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
private static final Logger LOG = LoggerFactory.getLogger(XmlToPatchBodyReader.class);
+ public XmlToPatchBodyReader(final ControllerContext controllerContext) {
+ super(controllerContext);
+ }
+
@Override
public boolean isReadable(final Class<?> type, final Type genericType,
final Annotation[] annotations, final MediaType mediaType) {
public PatchContext readFrom(final Class<PatchContext> type, final Type genericType,
final Annotation[] annotations, final MediaType mediaType,
final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream)
- throws IOException, WebApplicationException {
+ throws WebApplicationException {
try {
final InstanceIdentifierContext<?> path = getInstanceIdentifierContext();
-
- if (entityStream.available() < 1) {
+ final Optional<InputStream> nonEmptyInputStreamOptional = RestUtil.isInputStreamEmpty(entityStream);
+ if (nonEmptyInputStreamOptional.isEmpty()) {
// represent empty nopayload input
return new PatchContext(path, null, null);
}
- final Document doc = UntrustedXML.newDocumentBuilder().parse(entityStream);
+ final Document doc = UntrustedXML.newDocumentBuilder().parse(nonEmptyInputStreamOptional.get());
return parse(path, doc);
} catch (final RestconfDocumentedException e) {
throw e;
} catch (final Exception e) {
LOG.debug("Error parsing xml input", e);
-
+ RestconfDocumentedException.throwIfYangError(e);
throw new RestconfDocumentedException("Error parsing input: " + e.getMessage(), ErrorType.PROTOCOL,
- ErrorTag.MALFORMED_MESSAGE);
+ ErrorTag.MALFORMED_MESSAGE, e);
}
}
DataSchemaNode schemaNode = (DataSchemaNode) pathContext.getSchemaNode();
final Element element = (Element) editNodes.item(i);
final String operation = element.getElementsByTagName("operation").item(0).getFirstChild().getNodeValue();
- final PatchEditOperation oper = PatchEditOperation.valueOf(operation.toUpperCase());
+ final PatchEditOperation oper = PatchEditOperation.valueOf(operation.toUpperCase(Locale.ROOT));
final String editId = element.getElementsByTagName("edit-id").item(0).getFirstChild().getNodeValue();
final String target = element.getElementsByTagName("target").item(0).getFirstChild().getNodeValue();
? schemaNode.getQName().getNamespace().toString() : firstValueElement.getNamespaceURI();
// find module according to namespace
- final Module module = pathContext.getSchemaContext().findModuleByNamespace(
- URI.create(namespace)).iterator().next();
+ final Module module = pathContext.getSchemaContext().findModules(XMLNamespace.of(namespace)).iterator()
+ .next();
// initialize codec + set default prefix derived from module name
final StringModuleInstanceIdentifierCodec codec = new StringModuleInstanceIdentifierCodec(
// target can be also empty (only slash)
YangInstanceIdentifier targetII;
final SchemaNode targetNode;
+ final Inference inference;
if (target.equals("/")) {
targetII = pathContext.getInstanceIdentifier();
targetNode = pathContext.getSchemaContext();
+ inference = Inference.ofDataTreePath(pathContext.getSchemaContext(), schemaNode.getQName());
} else {
targetII = codec.deserialize(codec.serialize(pathContext.getInstanceIdentifier())
.concat(prepareNonCondXpath(schemaNode, target.replaceFirst("/", ""), firstValueElement,
- namespace, module.getQNameModule().getFormattedRevision())));
-
- targetNode = SchemaContextUtil.findDataSchemaNode(pathContext.getSchemaContext(),
- codec.getDataContextTree().getChild(targetII).getDataSchemaNode().getPath().getParent());
-
+ namespace,
+ module.getQNameModule().getRevision().map(Revision::toString).orElse(null))));
// move schema node
- schemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(pathContext.getSchemaContext(),
- codec.getDataContextTree().getChild(targetII).getDataSchemaNode().getPath());
+ schemaNode = verifyNotNull(codec.getDataContextTree().findChild(targetII).orElseThrow()
+ .getDataSchemaNode());
+
+ final SchemaInferenceStack stack = SchemaInferenceStack.of(pathContext.getSchemaContext());
+ targetII.getPathArguments().stream()
+ .filter(arg -> !(arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates))
+ .filter(arg -> !(arg instanceof YangInstanceIdentifier.AugmentationIdentifier))
+ .forEach(p -> stack.enterSchemaTree(p.getNodeType()));
+ final EffectiveStatement<?, ?> parentStmt = stack.exit();
+ verify(parentStmt instanceof SchemaNode, "Unexpected parent %s", parentStmt);
+ targetNode = (SchemaNode) parentStmt;
+ inference = stack.toInference();
}
if (targetNode == null) {
}
if (oper.isWithValue()) {
- final NormalizedNode<?, ?> parsed;
+ final NormalizedNode parsed;
if (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, pathContext.getSchemaContext(),
- schemaNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, inference);
xmlParser.traverse(new DOMSource(firstValueElement));
parsed = resultHolder.getResult();
} else {
* @param operation Name of current operation
* @return List of value elements
*/
- private static List<Element> readValueNodes(@Nonnull final Element element,
- @Nonnull final PatchEditOperation operation) {
+ private static List<Element> readValueNodes(final @NonNull Element element,
+ final @NonNull PatchEditOperation operation) {
final Node valueNode = element.getElementsByTagName("value").item(0);
if (operation.isWithValue() && valueNode == null) {
* @param revision Module revision
* @return Non-conditional XPath
*/
- private static String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
- @Nonnull final Element value, @Nonnull final String namespace, @Nonnull final String revision) {
+ private static String prepareNonCondXpath(final @NonNull DataSchemaNode schemaNode, final @NonNull String target,
+ final @NonNull Element value, final @NonNull String namespace, final @NonNull String revision) {
final Iterator<String> args = Splitter.on("/").split(target.substring(target.indexOf(':') + 1)).iterator();
final StringBuilder nonCondXpath = new StringBuilder();
while (args.hasNext()) {
final String s = args.next();
- nonCondXpath.append("/");
- nonCondXpath.append(s);
+ nonCondXpath.append('/').append(s);
childNode = ((DataNodeContainer) childNode).getDataChildByName(QName.create(namespace, revision, s));
if (childNode instanceof ListSchemaNode && args.hasNext()) {
* @param keys Iterator of list keys names
* @return Iterator of list keys values
*/
- private static Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
+ private static Iterator<String> readKeyValues(final @NonNull Element value, final @NonNull Iterator<QName> keys) {
final List<String> result = new ArrayList<>();
while (keys.hasNext()) {
* @param keyNames Iterator of list keys names
* @param keyValues Iterator of list keys values
*/
- private static void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
- @Nonnull final Iterator<String> keyValues) {
+ private static void appendKeys(final @NonNull StringBuilder nonCondXpath, final @NonNull Iterator<QName> keyNames,
+ final @NonNull Iterator<String> keyValues) {
while (keyNames.hasNext()) {
- nonCondXpath.append("[");
- nonCondXpath.append(keyNames.next().getLocalName());
- nonCondXpath.append("=");
- nonCondXpath.append("'");
- nonCondXpath.append(keyValues.next());
- nonCondXpath.append("'");
- nonCondXpath.append("]");
+ nonCondXpath.append("[").append(keyNames.next().getLocalName()).append("='").append(keyValues.next())
+ .append("']");
}
}
}
Code Review / netconf.git / blobdiff