package org.opendaylight.yangtools.yang.data.codec.gson;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.base.Splitter;
-import com.google.common.collect.Iterators;
import com.google.gson.JsonIOException;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonToken;
import com.google.gson.stream.MalformedJsonException;
-
import java.io.Closeable;
import java.io.EOFException;
import java.io.Flushable;
import java.io.IOException;
import java.net.URI;
-import java.security.InvalidParameterException;
import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
import java.util.Set;
-
-import org.opendaylight.yangtools.concepts.Codec;
-import org.opendaylight.yangtools.yang.common.QName;
+import javax.xml.transform.dom.DOMSource;
+import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestCodecFactory;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestUtil;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestUtil.PrefixMapingFromJson;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.SchemaContextUtils;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.data.util.AbstractNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.AnyXmlNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.CompositeNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.LeafListEntryNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.LeafListNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.LeafNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.ListEntryNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.ListNodeDataWithSchema;
+import org.opendaylight.yangtools.yang.data.util.ParserStreamUtils;
+import org.opendaylight.yangtools.yang.data.util.RpcAsContainer;
+import org.opendaylight.yangtools.yang.data.util.SimpleNodeDataWithSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypedSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Text;
/**
* This class parses JSON elements from a GSON JsonReader. It disallows multiple elements of the same name unlike the
*/
@Beta
public final class JsonParserStream implements Closeable, Flushable {
- private static final Splitter COLON_SPLITTER = Splitter.on(':');
+ static final String ANYXML_ARRAY_ELEMENT_ID = "array-element";
private final Deque<URI> namespaces = new ArrayDeque<>();
private final NormalizedNodeStreamWriter writer;
- private final SchemaContextUtils utils;
- private final RestCodecFactory codecs;
+ private final JSONCodecFactory codecs;
private final SchemaContext schema;
+ private final DataSchemaNode parentNode;
- private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext) {
+ private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
+ final DataSchemaNode parentNode) {
this.schema = Preconditions.checkNotNull(schemaContext);
- this.utils = SchemaContextUtils.create(schemaContext);
this.writer = Preconditions.checkNotNull(writer);
- this.codecs = RestCodecFactory.create(utils);
+ this.codecs = JSONCodecFactory.create(schemaContext);
+ this.parentNode = parentNode;
+ }
+
+ public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
+ final SchemaNode parentNode ) {
+ if (parentNode instanceof RpcDefinition) {
+ return new JsonParserStream(writer, schemaContext, new RpcAsContainer((RpcDefinition) parentNode));
+ }
+ Preconditions.checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
+ return new JsonParserStream(writer, schemaContext, (DataSchemaNode) parentNode);
}
public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext) {
- return new JsonParserStream(writer, schemaContext);
+ return new JsonParserStream(writer, schemaContext, schemaContext);
}
- public JsonParserStream parse(final JsonReader reader) throws JsonIOException, JsonSyntaxException {
+ public JsonParserStream parse(final JsonReader reader) {
// code copied from gson's JsonParser and Stream classes
- boolean lenient = reader.isLenient();
+ final boolean lenient = reader.isLenient();
reader.setLenient(true);
boolean isEmpty = true;
try {
reader.peek();
isEmpty = false;
- CompositeNodeDataWithSchema compositeNodeDataWithSchema = new CompositeNodeDataWithSchema(schema);
+ final CompositeNodeDataWithSchema compositeNodeDataWithSchema = new CompositeNodeDataWithSchema(parentNode);
read(reader, compositeNodeDataWithSchema);
- compositeNodeDataWithSchema.writeToStream(writer);
+ compositeNodeDataWithSchema.write(writer);
return this;
- // return read(reader);
- } catch (EOFException e) {
+ } catch (final EOFException e) {
if (isEmpty) {
return this;
- // return JsonNull.INSTANCE;
}
// The stream ended prematurely so it is likely a syntax error.
throw new JsonSyntaxException(e);
- } catch (MalformedJsonException e) {
+ } catch (final MalformedJsonException | NumberFormatException e) {
throw new JsonSyntaxException(e);
- } catch (IOException e) {
+ } catch (final IOException e) {
throw new JsonIOException(e);
- } catch (NumberFormatException e) {
- throw new JsonSyntaxException(e);
} catch (StackOverflowError | OutOfMemoryError e) {
throw new JsonParseException("Failed parsing JSON source: " + reader + " to Json", e);
} finally {
}
}
- public void read(final JsonReader in, final AbstractNodeDataWithSchema parent) throws IOException {
+ private void traverseAnyXmlValue(final JsonReader in, final Document doc, final Element parentElement)
+ throws IOException {
+ switch (in.peek()) {
+ case STRING:
+ case NUMBER:
+ Text textNode = doc.createTextNode(in.nextString());
+ parentElement.appendChild(textNode);
+ break;
+ case BOOLEAN:
+ textNode = doc.createTextNode(Boolean.toString(in.nextBoolean()));
+ parentElement.appendChild(textNode);
+ break;
+ case NULL:
+ in.nextNull();
+ textNode = doc.createTextNode("null");
+ parentElement.appendChild(textNode);
+ break;
+ case BEGIN_ARRAY:
+ in.beginArray();
+ while (in.hasNext()) {
+ final Element childElement = doc.createElement(ANYXML_ARRAY_ELEMENT_ID);
+ parentElement.appendChild(childElement);
+ traverseAnyXmlValue(in, doc, childElement);
+ }
+ in.endArray();
+ break;
+ case BEGIN_OBJECT:
+ in.beginObject();
+ while (in.hasNext()) {
+ final Element childElement = doc.createElement(in.nextName());
+ parentElement.appendChild(childElement);
+ traverseAnyXmlValue(in, doc, childElement);
+ }
+ in.endObject();
+ case END_DOCUMENT:
+ case NAME:
+ case END_OBJECT:
+ case END_ARRAY:
+ break;
+ }
+ }
+
+ private void readAnyXmlValue(final JsonReader in, final AnyXmlNodeDataWithSchema parent,
+ final String anyXmlObjectName) throws IOException {
+ final String anyXmlObjectNS = getCurrentNamespace().toString();
+ final Document doc = UntrustedXML.newDocumentBuilder().newDocument();
+ final Element rootElement = doc.createElementNS(anyXmlObjectNS, anyXmlObjectName);
+ doc.appendChild(rootElement);
+ traverseAnyXmlValue(in, doc, rootElement);
+
+ final DOMSource domSource = new DOMSource(doc.getDocumentElement());
+ parent.setValue(domSource);
+ }
- final JsonToken peek = in.peek();
- Optional<String> value = Optional.absent();
- switch (peek) {
+ public void read(final JsonReader in, AbstractNodeDataWithSchema parent) throws IOException {
+ switch (in.peek()) {
case STRING:
case NUMBER:
- value = Optional.of(in.nextString());
+ setValue(parent, in.nextString());
break;
case BOOLEAN:
- value = Optional.of(Boolean.toString(in.nextBoolean()));
+ setValue(parent, Boolean.toString(in.nextBoolean()));
break;
case NULL:
in.nextNull();
- value = Optional.of((String) null);
- break;
- default:
+ setValue(parent, null);
break;
- }
- if (value.isPresent()) {
- final Object translatedValue = translateValueByType(value.get(), parent.getSchema());
- ((SimpleNodeDataWithSchema) parent).setValue(translatedValue);
- }
-
- switch (peek) {
case BEGIN_ARRAY:
in.beginArray();
while (in.hasNext()) {
- AbstractNodeDataWithSchema newChild = null;
- if (parent instanceof ListNodeDataWithSchema) {
- newChild = new ListEntryNodeDataWithSchema(parent.getSchema());
- ((CompositeNodeDataWithSchema) parent).addChild(newChild);
- } else if (parent instanceof LeafListNodeDataWithSchema) {
- newChild = new LeafListEntryNodeDataWithSchema(parent.getSchema());
- ((CompositeNodeDataWithSchema) parent).addChild(newChild);
+ if (parent instanceof LeafNodeDataWithSchema) {
+ read(in, parent);
+ } else {
+ final AbstractNodeDataWithSchema newChild = newArrayEntry(parent);
+ read(in, newChild);
}
- read(in, newChild);
}
in.endArray();
return;
case BEGIN_OBJECT:
- Set<String> namesakes = new HashSet<>();
+ final Set<String> namesakes = new HashSet<>();
in.beginObject();
+ /*
+ * This allows parsing of incorrectly /as showcased/
+ * in testconf nesting of list items - eg.
+ * lists with one value are sometimes serialized
+ * without wrapping array.
+ *
+ */
+ if (isArray(parent)) {
+ parent = newArrayEntry(parent);
+ }
while (in.hasNext()) {
final String jsonElementName = in.nextName();
- final NamespaceAndName namespaceAndName = resolveNamespace(jsonElementName);
+ DataSchemaNode parentSchema = parent.getSchema();
+ if (parentSchema instanceof YangModeledAnyXmlSchemaNode) {
+ parentSchema = ((YangModeledAnyXmlSchemaNode) parentSchema).getSchemaOfAnyXmlData();
+ }
+ final NamespaceAndName namespaceAndName = resolveNamespace(jsonElementName, parentSchema);
final String localName = namespaceAndName.getName();
addNamespace(namespaceAndName.getUri());
if (namesakes.contains(jsonElementName)) {
throw new JsonSyntaxException("Duplicate name " + jsonElementName + " in JSON input.");
}
namesakes.add(jsonElementName);
- final Deque<DataSchemaNode> childDataSchemaNodes = findSchemaNodeByNameAndNamespace(parent.getSchema(),
- localName, getCurrentNamespace());
+
+ final Deque<DataSchemaNode> childDataSchemaNodes =
+ ParserStreamUtils.findSchemaNodeByNameAndNamespace(parentSchema, localName, getCurrentNamespace());
if (childDataSchemaNodes.isEmpty()) {
throw new IllegalStateException("Schema for node with name " + localName + " and namespace "
+ getCurrentNamespace() + " doesn't exist.");
}
- AbstractNodeDataWithSchema newChild;
- newChild = ((CompositeNodeDataWithSchema) parent).addChild(childDataSchemaNodes);
-// FIXME:anyxml data shouldn't be skipped but should be loaded somehow. will be specified after 17AUG2014
+ final AbstractNodeDataWithSchema newChild = ((CompositeNodeDataWithSchema) parent).addChild(childDataSchemaNodes);
if (newChild instanceof AnyXmlNodeDataWithSchema) {
- in.skipValue();
+ readAnyXmlValue(in, (AnyXmlNodeDataWithSchema) newChild, jsonElementName);
} else {
read(in, newChild);
}
case NAME:
case END_OBJECT:
case END_ARRAY:
+ break;
}
}
- private Object translateValueByType(final String value, final DataSchemaNode node) {
- final TypeDefinition<? extends Object> typeDefinition = typeDefinition(node);
- if (typeDefinition == null) {
- return value;
- }
-
- final Object inputValue;
- if (typeDefinition instanceof IdentityrefTypeDefinition) {
- inputValue = valueAsIdentityRef(value);
- } else if (typeDefinition instanceof InstanceIdentifierTypeDefinition) {
- inputValue = valueAsInstanceIdentifier(value);
- } else {
- inputValue = value;
- }
-
- // FIXME: extract this as a cacheable context?
- final Codec<Object, Object> codec = codecs.codecFor(typeDefinition);
- if (codec == null) {
- return null;
- }
- return codec.deserialize(inputValue);
+ private static boolean isArray(final AbstractNodeDataWithSchema parent) {
+ return parent instanceof ListNodeDataWithSchema || parent instanceof LeafListNodeDataWithSchema;
}
- private static TypeDefinition<? extends Object> typeDefinition(final DataSchemaNode node) {
- TypeDefinition<?> baseType = null;
- if (node instanceof LeafListSchemaNode) {
- baseType = ((LeafListSchemaNode) node).getType();
- } else if (node instanceof LeafSchemaNode) {
- baseType = ((LeafSchemaNode) node).getType();
- } else if (node instanceof AnyXmlSchemaNode) {
- return null;
+ private static AbstractNodeDataWithSchema newArrayEntry(final AbstractNodeDataWithSchema parent) {
+ AbstractNodeDataWithSchema newChild;
+ if (parent instanceof ListNodeDataWithSchema) {
+ newChild = new ListEntryNodeDataWithSchema(parent.getSchema());
+ } else if (parent instanceof LeafListNodeDataWithSchema) {
+ newChild = new LeafListEntryNodeDataWithSchema(parent.getSchema());
} else {
- throw new IllegalArgumentException("Unhandled parameter types: " + Arrays.<Object> asList(node).toString());
- }
-
- if (baseType != null) {
- while (baseType.getBaseType() != null) {
- baseType = baseType.getBaseType();
- }
- }
- return baseType;
- }
-
- private static Object valueAsInstanceIdentifier(final String value) {
- // it could be instance-identifier Built-In Type
- if (!value.isEmpty() && value.charAt(0) == '/') {
- IdentityValuesDTO resolvedValue = RestUtil.asInstanceIdentifier(value, new PrefixMapingFromJson());
- if (resolvedValue != null) {
- return resolvedValue;
- }
- }
- throw new InvalidParameterException("Value for instance-identifier doesn't have correct format");
- }
-
- private static IdentityValuesDTO valueAsIdentityRef(final String value) {
- // it could be identityref Built-In Type
- URI namespace = getNamespaceFor(value);
- if (namespace != null) {
- return new IdentityValuesDTO(namespace.toString(), getLocalNameFor(value), null, value);
+ throw new IllegalStateException("Found an unexpected array nested under "+ parent.getSchema().getQName());
}
- throw new InvalidParameterException("Value for identityref has to be in format moduleName:localName.");
+ ((CompositeNodeDataWithSchema) parent).addChild(newChild);
+ return newChild;
}
- private static URI getNamespaceFor(final String jsonElementName) {
- final Iterator<String> it = COLON_SPLITTER.split(jsonElementName).iterator();
+ private void setValue(final AbstractNodeDataWithSchema parent, final String value) {
+ Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
+ parent.getSchema().getQName());
+ final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
+ Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
+ parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
- // The string needs to me in form "moduleName:localName"
- if (it.hasNext()) {
- final String maybeURI = it.next();
- if (Iterators.size(it) == 1) {
- return URI.create(maybeURI);
- }
- }
-
- return null;
+ final Object translatedValue = translateValueByType(value, parentSimpleNode.getSchema());
+ parentSimpleNode.setValue(translatedValue);
}
- private static String getLocalNameFor(final String jsonElementName) {
- final Iterator<String> it = COLON_SPLITTER.split(jsonElementName).iterator();
-
- // The string needs to me in form "moduleName:localName"
- final String ret = Iterators.get(it, 1, null);
- return ret != null && !it.hasNext() ? ret : jsonElementName;
+ private Object translateValueByType(final String value, final DataSchemaNode node) {
+ Preconditions.checkArgument(node instanceof TypedSchemaNode);
+ return codecs.codecFor((TypedSchemaNode) node).parseValue(null, value);
}
private void removeNamespace() {
namespaces.pop();
}
- private void addNamespace(final Optional<URI> namespace) {
- if (!namespace.isPresent()) {
- if (namespaces.isEmpty()) {
- throw new IllegalStateException("Namespace has to be specified at top level.");
- } else {
- namespaces.push(namespaces.peek());
- }
- } else {
- namespaces.push(namespace.get());
- }
+ private void addNamespace(final URI namespace) {
+ namespaces.push(namespace);
}
- private NamespaceAndName resolveNamespace(final String childName) {
- int lastIndexOfColon = childName.lastIndexOf(":");
+ private NamespaceAndName resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
+ final int lastIndexOfColon = childName.lastIndexOf(':');
String moduleNamePart = null;
String nodeNamePart = null;
URI namespace = null;
if (lastIndexOfColon != -1) {
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
- namespace = utils.findNamespaceByModuleName(moduleNamePart);
+
+ final Module m = schema.findModuleByName(moduleNamePart, null);
+ namespace = m == null ? null : m.getNamespace();
} else {
nodeNamePart = childName;
}
- Optional<URI> namespaceOpt = namespace == null ? Optional.<URI> absent() : Optional.of(namespace);
- return new NamespaceAndName(nodeNamePart, namespaceOpt);
+ if (namespace == null) {
+ Set<URI> potentialUris = Collections.emptySet();
+ potentialUris = resolveAllPotentialNamespaces(nodeNamePart, dataSchemaNode);
+ if (potentialUris.contains(getCurrentNamespace())) {
+ namespace = getCurrentNamespace();
+ } else if (potentialUris.size() == 1) {
+ namespace = potentialUris.iterator().next();
+ } else if (potentialUris.size() > 1) {
+ throw new IllegalStateException("Choose suitable module name for element "+nodeNamePart+":"+toModuleNames(potentialUris));
+ } else if (potentialUris.isEmpty()) {
+ throw new IllegalStateException("Schema node with name "+nodeNamePart+" wasn't found under "+dataSchemaNode.getQName()+".");
+ }
+ }
+
+ return new NamespaceAndName(nodeNamePart, namespace);
}
- private URI getCurrentNamespace() {
- return namespaces.peek();
+ private String toModuleNames(final Set<URI> potentialUris) {
+ final StringBuilder builder = new StringBuilder();
+ for (final URI potentialUri : potentialUris) {
+ builder.append("\n");
+ //FIXME how to get information about revision from JSON input? currently first available is used.
+ builder.append(schema.findModuleByNamespace(potentialUri).iterator().next().getName());
+ }
+ return builder.toString();
}
- /**
- * Returns stack of schema nodes via which it was necessary to prass to get schema node with specified
- * {@code childName} and {@code namespace}
- *
- * @param dataSchemaNode
- * @param childName
- * @param namespace
- * @return stack of schema nodes via which it was passed through. If found schema node is dirrect child then stack
- * contains only one node. If it is found under choice and case then stack should conains 2*n+1 element
- * (where n is number of choices through it was passed)
- */
- private Deque<DataSchemaNode> findSchemaNodeByNameAndNamespace(final DataSchemaNode dataSchemaNode,
- final String childName, final URI namespace) {
- final Deque<DataSchemaNode> result = new ArrayDeque<>();
- List<ChoiceNode> childChoices = new ArrayList<>();
+ private Set<URI> resolveAllPotentialNamespaces(final String elementName, final DataSchemaNode dataSchemaNode) {
+ final Set<URI> potentialUris = new HashSet<>();
+ final Set<ChoiceSchemaNode> choices = new HashSet<>();
if (dataSchemaNode instanceof DataNodeContainer) {
- for (DataSchemaNode childNode : ((DataNodeContainer) dataSchemaNode).getChildNodes()) {
- if (childNode instanceof ChoiceNode) {
- childChoices.add((ChoiceNode) childNode);
- } else {
- final QName childQName = childNode.getQName();
- if (childQName.getLocalName().equals(childName) && childQName.getNamespace().equals(namespace)) {
- result.push(childNode);
- return result;
- }
+ for (final DataSchemaNode childSchemaNode : ((DataNodeContainer) dataSchemaNode).getChildNodes()) {
+ if (childSchemaNode instanceof ChoiceSchemaNode) {
+ choices.add((ChoiceSchemaNode)childSchemaNode);
+ } else if (childSchemaNode.getQName().getLocalName().equals(elementName)) {
+ potentialUris.add(childSchemaNode.getQName().getNamespace());
}
}
- }
- // try to find data schema node in choice (looking for first match)
- for (ChoiceNode choiceNode : childChoices) {
- for (ChoiceCaseNode concreteCase : choiceNode.getCases()) {
- Deque<DataSchemaNode> resultFromRecursion = findSchemaNodeByNameAndNamespace(concreteCase, childName,
- namespace);
- if (!resultFromRecursion.isEmpty()) {
- resultFromRecursion.push(concreteCase);
- resultFromRecursion.push(choiceNode);
- return resultFromRecursion;
+
+ for (final ChoiceSchemaNode choiceNode : choices) {
+ for (final ChoiceCaseNode concreteCase : choiceNode.getCases()) {
+ potentialUris.addAll(resolveAllPotentialNamespaces(elementName, concreteCase));
}
}
}
- return result;
+ return potentialUris;
+ }
+
+ private URI getCurrentNamespace() {
+ return namespaces.peek();
}
+
+
private static class NamespaceAndName {
- private final Optional<URI> uri;
+ private final URI uri;
private final String name;
- public NamespaceAndName(final String name, final Optional<URI> uri) {
+ public NamespaceAndName(final String name, final URI uri) {
this.name = name;
this.uri = uri;
}
return name;
}
- public Optional<URI> getUri() {
+ public URI getUri() {
return uri;
}
}