+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.controller.sal.rest.impl;
import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.base.Preconditions;
+import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.util.*;
-
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
import javax.activation.UnsupportedDataTypeException;
-
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
-import org.opendaylight.yangtools.yang.data.api.*;
-import org.opendaylight.yangtools.yang.model.api.*;
-import org.opendaylight.yangtools.yang.model.api.type.*;
-
-import com.google.common.base.Preconditions;
-import com.google.gson.stream.JsonWriter;
+import org.opendaylight.controller.sal.restconf.impl.IdentityValuesDTO;
+import org.opendaylight.controller.sal.restconf.impl.IdentityValuesDTO.IdentityValue;
+import org.opendaylight.controller.sal.restconf.impl.IdentityValuesDTO.Predicate;
+import org.opendaylight.controller.sal.restconf.impl.RestCodec;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+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.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
+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.type.IntegerTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
class JsonMapper {
+ private static final Logger LOG = LoggerFactory.getLogger(JsonMapper.class);
+ private final DOMMountPoint mountPoint;
- private final Set<LeafListSchemaNode> foundLeafLists = new HashSet<>();
- private final Set<ListSchemaNode> foundLists = new HashSet<>();
+ public JsonMapper(final DOMMountPoint mountPoint) {
+ this.mountPoint = mountPoint;
+ }
- public void write(JsonWriter writer, CompositeNode data, DataNodeContainer schema) throws IOException {
+ public void write(final JsonWriter writer, final CompositeNode data, final DataNodeContainer schema)
+ throws IOException {
Preconditions.checkNotNull(writer);
Preconditions.checkNotNull(data);
Preconditions.checkNotNull(schema);
}
writer.endObject();
-
- foundLeafLists.clear();
- foundLists.clear();
}
- private void writeChildrenOfParent(JsonWriter writer, CompositeNode parent, DataNodeContainer parentSchema)
- throws IOException {
+ private void writeChildrenOfParent(final JsonWriter writer, final CompositeNode parent,
+ final DataNodeContainer parentSchema) throws IOException {
checkNotNull(parent);
- checkNotNull(parentSchema);
-
- List<String> longestPathToElementViaChoiceCase = new ArrayList<>();
- for (Node<?> child : parent.getChildren()) {
- Deque<String> choiceCasePathStack = new ArrayDeque<>(longestPathToElementViaChoiceCase);
- SchemaLocation schemaLocation = findFirstSchemaForNode(child, parentSchema.getChildNodes(),
- choiceCasePathStack);
-
- if (schemaLocation == null) {
- if (!choiceCasePathStack.isEmpty()) {
- throw new UnsupportedDataTypeException("On choice-case path " + choiceCasePathStack
- + " wasn't found data schema for " + child.getNodeType().getLocalName());
- } else {
- throw new UnsupportedDataTypeException("Probably the data node \""
- + child.getNodeType().getLocalName() + "\" is not conform to schema");
- }
- }
- longestPathToElementViaChoiceCase = resolveLongerPath(longestPathToElementViaChoiceCase,
- schemaLocation.getLocation());
+ final Set<QName> foundLists = new HashSet<>();
+
+ Collection<DataSchemaNode> parentSchemaChildNodes = parentSchema == null ? Collections.<DataSchemaNode> emptySet()
+ : parentSchema.getChildNodes();
+
+ for (Node<?> child : parent.getValue()) {
+ DataSchemaNode childSchema = findFirstSchemaForNode(child, parentSchemaChildNodes);
- DataSchemaNode childSchema = schemaLocation.getSchema();
+ if (childSchema == null) {
+ // Node may not conform to schema or allows "anyxml" - we'll process it.
- if (childSchema instanceof ContainerSchemaNode) {
+ LOG.debug("No schema found for data node \"{}\"", child.getNodeType());
+
+ if (!foundLists.contains(child.getNodeType())) {
+ handleNoSchemaFound(writer, child, parent);
+
+ // Since we don't have a schema, we don't know which nodes are supposed to be
+ // lists so treat every one as a potential list to avoid outputting duplicates.
+
+ foundLists.add(child.getNodeType());
+ }
+ } else if (childSchema instanceof ContainerSchemaNode) {
Preconditions.checkState(child instanceof CompositeNode,
- "Data representation of Container should be CompositeNode - " + child.getNodeType());
+ "Data representation of Container should be CompositeNode - %s", child.getNodeType());
writeContainer(writer, (CompositeNode) child, (ContainerSchemaNode) childSchema);
} else if (childSchema instanceof ListSchemaNode) {
- if (!foundLists.contains(childSchema)) {
+ if (!foundLists.contains(child.getNodeType())) {
Preconditions.checkState(child instanceof CompositeNode,
- "Data representation of List should be CompositeNode - " + child.getNodeType());
- foundLists.add((ListSchemaNode) childSchema);
+ "Data representation of List should be CompositeNode - %s", child.getNodeType());
+ foundLists.add(child.getNodeType());
writeList(writer, parent, (CompositeNode) child, (ListSchemaNode) childSchema);
}
} else if (childSchema instanceof LeafListSchemaNode) {
- if (!foundLeafLists.contains(childSchema)) {
+ if (!foundLists.contains(child.getNodeType())) {
Preconditions.checkState(child instanceof SimpleNode<?>,
- "Data representation of LeafList should be SimpleNode - " + child.getNodeType());
- foundLeafLists.add((LeafListSchemaNode) childSchema);
+ "Data representation of LeafList should be SimpleNode - %s", child.getNodeType());
+ foundLists.add(child.getNodeType());
writeLeafList(writer, parent, (SimpleNode<?>) child, (LeafListSchemaNode) childSchema);
}
} else if (childSchema instanceof LeafSchemaNode) {
Preconditions.checkState(child instanceof SimpleNode<?>,
- "Data representation of LeafList should be SimpleNode - " + child.getNodeType());
+ "Data representation of LeafList should be SimpleNode - %s", child.getNodeType());
writeLeaf(writer, (SimpleNode<?>) child, (LeafSchemaNode) childSchema);
+ } else if (childSchema instanceof AnyXmlSchemaNode) {
+ if (child instanceof CompositeNode) {
+ writeContainer(writer, (CompositeNode) child, null);
+ } else {
+ handleNoSchemaFound(writer, child, parent);
+ }
} else {
throw new UnsupportedDataTypeException("Schema can be ContainerSchemaNode, ListSchemaNode, "
+ "LeafListSchemaNode, or LeafSchemaNode. Other types are not supported yet.");
}
}
+ }
- for (Node<?> child : parent.getChildren()) {
- SchemaLocation schemaLocation = findFirstSchemaForNode(child, parentSchema.getChildNodes(),
- new ArrayDeque<>(longestPathToElementViaChoiceCase));
+ private static void writeValue(final JsonWriter writer, final Object value) throws IOException {
+ writer.value(value == null ? "" : String.valueOf(value));
+ }
- DataSchemaNode childSchema = schemaLocation.getSchema();
- if (childSchema instanceof LeafListSchemaNode) {
- foundLeafLists.remove((LeafListSchemaNode) childSchema);
- } else if (childSchema instanceof ListSchemaNode) {
- foundLists.remove((ListSchemaNode) childSchema);
+ private void handleNoSchemaFound(final JsonWriter writer, final Node<?> node, final CompositeNode parent)
+ throws IOException {
+ if (node instanceof SimpleNode<?>) {
+ List<SimpleNode<?>> nodeLeafList = parent.getSimpleNodesByName(node.getNodeType());
+ if (nodeLeafList.size() == 1) {
+ writeName(node, null, writer);
+ writeValue(writer, node.getValue());
+ } else { // more than 1, write as a json array
+ writeName(node, null, writer);
+ writer.beginArray();
+ for (SimpleNode<?> leafNode : nodeLeafList) {
+ writeValue(writer, leafNode.getValue());
+ }
+
+ writer.endArray();
+ }
+ } else { // CompositeNode
+ Preconditions.checkState(node instanceof CompositeNode,
+ "Data representation of Container should be CompositeNode - %s", node.getNodeType());
+
+ List<CompositeNode> nodeList = parent.getCompositesByName(node.getNodeType());
+ if (nodeList.size() == 1) {
+ writeContainer(writer, (CompositeNode) node, null);
+ } else { // more than 1, write as a json array
+ writeList(writer, parent, (CompositeNode) node, null);
}
}
}
- private List<String> resolveLongerPath(List<String> l1, List<String> l2) {
- return l1.size() > l2.size() ? l1 : l2;
- }
-
- private SchemaLocation findFirstSchemaForNode(Node<?> node, Set<DataSchemaNode> dataSchemaNode,
- Deque<String> pathIterator) {
- Map<String, ChoiceNode> choiceSubnodes = new HashMap<>();
+ private static DataSchemaNode findFirstSchemaForNode(final Node<?> node, final Iterable<DataSchemaNode> dataSchemaNode) {
for (DataSchemaNode dsn : dataSchemaNode) {
- if (dsn instanceof ChoiceNode) {
- choiceSubnodes.put(dsn.getQName().getLocalName(), (ChoiceNode) dsn);
- } else if (node.getNodeType().getLocalName().equals(dsn.getQName().getLocalName())) {
- return new SchemaLocation(dsn);
+ if (node.getNodeType().equals(dsn.getQName())) {
+ return dsn;
}
- }
-
- for (ChoiceNode choiceSubnode : choiceSubnodes.values()) {
- if ((!pathIterator.isEmpty() && pathIterator.peekLast().equals(choiceSubnode.getQName().getLocalName()))
- || pathIterator.isEmpty()) {
- String pathPartChoice = pathIterator.pollLast();
- for (ChoiceCaseNode concreteCase : choiceSubnode.getCases()) {
- if ((!pathIterator.isEmpty() && pathIterator.peekLast().equals(
- concreteCase.getQName().getLocalName()))
- || pathIterator.isEmpty()) {
- String pathPartCase = pathIterator.pollLast();
- SchemaLocation schemaLocation = findFirstSchemaForNode(node, concreteCase.getChildNodes(),
- pathIterator);
- if (schemaLocation != null) {
- schemaLocation.addPathPart(concreteCase.getQName().getLocalName());
- schemaLocation.addPathPart(choiceSubnode.getQName().getLocalName());
- return schemaLocation;
- }
- if (pathPartCase != null) {
- pathIterator.addLast(pathPartCase);
- }
+ if (dsn instanceof ChoiceNode) {
+ for (ChoiceCaseNode choiceCase : ((ChoiceNode) dsn).getCases()) {
+ DataSchemaNode foundDsn = findFirstSchemaForNode(node, choiceCase.getChildNodes());
+ if (foundDsn != null) {
+ return foundDsn;
}
}
- if (pathPartChoice != null) {
- pathIterator.addLast(pathPartChoice);
- }
}
}
return null;
}
- private void writeContainer(JsonWriter writer, CompositeNode node, ContainerSchemaNode schema) throws IOException {
+ private void writeContainer(final JsonWriter writer, final CompositeNode node, final ContainerSchemaNode schema)
+ throws IOException {
writeName(node, schema, writer);
writer.beginObject();
writeChildrenOfParent(writer, node, schema);
writer.endObject();
}
- private void writeList(JsonWriter writer, CompositeNode nodeParent, CompositeNode node, ListSchemaNode schema)
- throws IOException {
+ private void writeList(final JsonWriter writer, final CompositeNode nodeParent, final CompositeNode node,
+ final ListSchemaNode schema) throws IOException {
writeName(node, schema, writer);
writer.beginArray();
writer.endArray();
}
- private void writeLeafList(JsonWriter writer, CompositeNode nodeParent, SimpleNode<?> node,
- LeafListSchemaNode schema) throws IOException {
+ private void writeLeafList(final JsonWriter writer, final CompositeNode nodeParent, final SimpleNode<?> node,
+ final LeafListSchemaNode schema) throws IOException {
writeName(node, schema, writer);
writer.beginArray();
List<SimpleNode<?>> nodeLeafLists = nodeParent.getSimpleNodesByName(node.getNodeType());
for (SimpleNode<?> nodeLeafList : nodeLeafLists) {
- writeValueOfNodeByType(writer, nodeLeafList, schema.getType());
+ writeValueOfNodeByType(writer, nodeLeafList, schema.getType(), schema);
}
-
writer.endArray();
}
- private void writeLeaf(JsonWriter writer, SimpleNode<?> node, LeafSchemaNode schema) throws IOException {
+ private void writeLeaf(final JsonWriter writer, final SimpleNode<?> node, final LeafSchemaNode schema)
+ throws IOException {
writeName(node, schema, writer);
- writeValueOfNodeByType(writer, node, schema.getType());
+ writeValueOfNodeByType(writer, node, schema.getType(), schema);
}
- private void writeValueOfNodeByType(JsonWriter writer, SimpleNode<?> node, TypeDefinition<?> type)
- throws IOException {
+ private void writeValueOfNodeByType(final JsonWriter writer, final SimpleNode<?> node,
+ final TypeDefinition<?> type, final DataSchemaNode schema) throws IOException {
+
+ TypeDefinition<?> baseType = RestUtil.resolveBaseTypeFrom(type);
- String value = String.valueOf(node.getValue());
- // TODO check Leafref, InstanceIdentifierTypeDefinition,
- // IdentityrefTypeDefinition, UnionTypeDefinition
- TypeDefinition<?> baseType = resolveBaseTypeFrom(type);
- if (baseType instanceof InstanceIdentifierTypeDefinition) {
- writer.value(((InstanceIdentifierTypeDefinition) baseType).getPathStatement().toString());
- } else if (baseType instanceof UnionTypeDefinition) {
- processTypeIsUnionType(writer, (UnionTypeDefinition) baseType, value);
+ if (node.getValue() == null && !(baseType instanceof EmptyTypeDefinition)) {
+ LOG.debug("While generationg JSON output null value was found for type {}.", baseType.getClass()
+ .getSimpleName());
+ }
+
+ if (baseType instanceof IdentityrefTypeDefinition) {
+ if (node.getValue() instanceof QName) {
+ IdentityValuesDTO valueDTO = (IdentityValuesDTO) RestCodec.from(baseType, mountPoint).serialize(
+ node.getValue());
+ IdentityValue valueFromDTO = valueDTO.getValuesWithNamespaces().get(0);
+ String moduleName;
+ if (mountPoint != null) {
+ moduleName = ControllerContext.getInstance().findModuleNameByNamespace(mountPoint,
+ URI.create(valueFromDTO.getNamespace()));
+ } else {
+ moduleName = ControllerContext.getInstance().findModuleNameByNamespace(
+ URI.create(valueFromDTO.getNamespace()));
+ }
+ writer.value(moduleName + ":" + valueFromDTO.getValue());
+ } else {
+ writeStringRepresentation(writer, node, baseType, QName.class);
+ }
+ } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
+ if (node.getValue() instanceof YangInstanceIdentifier) {
+ IdentityValuesDTO valueDTO = (IdentityValuesDTO) RestCodec.from(baseType, mountPoint).serialize(
+ node.getValue());
+ writeIdentityValuesDTOToJson(writer, valueDTO);
+ } else {
+ writeStringRepresentation(writer, node, baseType, YangInstanceIdentifier.class);
+ }
} else if (baseType instanceof DecimalTypeDefinition || baseType instanceof IntegerTypeDefinition
|| baseType instanceof UnsignedIntegerTypeDefinition) {
- writer.value(new NumberForJsonWriter(value));
+ writer.value(new NumberForJsonWriter((String) RestCodec.from(baseType, mountPoint).serialize(
+ node.getValue())));
} else if (baseType instanceof BooleanTypeDefinition) {
- writer.value(Boolean.parseBoolean(value));
+ writer.value(Boolean.parseBoolean((String) RestCodec.from(baseType, mountPoint).serialize(node.getValue())));
} else if (baseType instanceof EmptyTypeDefinition) {
writeEmptyDataTypeToJson(writer);
} else {
+ String value = String.valueOf(RestCodec.from(baseType, mountPoint).serialize(node.getValue()));
+ if (value == null) {
+ value = String.valueOf(node.getValue());
+ }
writer.value(value.equals("null") ? "" : value);
}
}
- private void processTypeIsUnionType(JsonWriter writer, UnionTypeDefinition unionType, String value)
+ private static void writeIdentityValuesDTOToJson(final JsonWriter writer, final IdentityValuesDTO valueDTO)
throws IOException {
- if (value == null) {
- writeEmptyDataTypeToJson(writer);
- } else if ((isNumber(value))
- && containsType(unionType, UnsignedIntegerTypeDefinition.class, IntegerTypeDefinition.class,
- DecimalTypeDefinition.class)) {
- writer.value(new NumberForJsonWriter(value));
- } else if (isBoolean(value) && containsType(unionType, BooleanTypeDefinition.class)) {
- writer.value(Boolean.parseBoolean(value));
- } else {
- writer.value(value);
+ StringBuilder result = new StringBuilder();
+ for (IdentityValue identityValue : valueDTO.getValuesWithNamespaces()) {
+ result.append('/');
+
+ writeModuleNameAndIdentifier(result, identityValue);
+ if (identityValue.getPredicates() != null && !identityValue.getPredicates().isEmpty()) {
+ for (Predicate predicate : identityValue.getPredicates()) {
+ IdentityValue identityValuePredicate = predicate.getName();
+ result.append('[');
+ if (identityValuePredicate == null) {
+ result.append('.');
+ } else {
+ writeModuleNameAndIdentifier(result, identityValuePredicate);
+ }
+ result.append("='");
+ result.append(predicate.getValue());
+ result.append("']");
+ }
+ }
}
- }
- private boolean isBoolean(String value) {
- if (value.equals("true") || value.equals("false")) {
- return true;
- }
- return false;
+ writer.value(result.toString());
}
- private void writeEmptyDataTypeToJson(JsonWriter writer) throws IOException {
- writer.beginArray();
- writer.nullValue();
- writer.endArray();
- }
-
- private boolean isNumber(String value) {
- try {
- Double.valueOf(value);
- } catch (NumberFormatException e) {
- return false;
- }
- return true;
- }
-
- private boolean containsType(UnionTypeDefinition unionType, Class<?>... searchedTypes) {
- List<TypeDefinition<?>> allUnionSubtypes = resolveAllUnionSubtypesFrom(unionType);
-
- for (TypeDefinition<?> unionSubtype : allUnionSubtypes) {
- for (Class<?> searchedType : searchedTypes) {
- if (searchedType.isInstance(unionSubtype)) {
- return true;
- }
- }
+ private static void writeModuleNameAndIdentifier(final StringBuilder result, final IdentityValue identityValue) {
+ String moduleName = ControllerContext.getInstance().findModuleNameByNamespace(
+ URI.create(identityValue.getNamespace()));
+ if (moduleName != null && !moduleName.isEmpty()) {
+ result.append(moduleName);
+ result.append(':');
}
- return false;
+ result.append(identityValue.getValue());
}
- private List<TypeDefinition<?>> resolveAllUnionSubtypesFrom(UnionTypeDefinition inputType) {
- List<TypeDefinition<?>> result = new ArrayList<>();
- for (TypeDefinition<?> subtype : inputType.getTypes()) {
- TypeDefinition<?> resolvedSubtype = subtype;
-
- resolvedSubtype = resolveBaseTypeFrom(subtype);
-
- if (resolvedSubtype instanceof UnionTypeDefinition) {
- List<TypeDefinition<?>> subtypesFromRecursion = resolveAllUnionSubtypesFrom((UnionTypeDefinition) resolvedSubtype);
- result.addAll(subtypesFromRecursion);
- } else {
- result.add(resolvedSubtype);
- }
+ private static void writeStringRepresentation(final JsonWriter writer, final SimpleNode<?> node,
+ final TypeDefinition<?> baseType, final Class<?> requiredType) throws IOException {
+ Object value = node.getValue();
+ LOG.debug("Value of {}:{} is not instance of {} but is {}", baseType.getQName().getNamespace(), baseType
+ .getQName().getLocalName(), requiredType.getClass(), node.getValue().getClass());
+ if (value == null) {
+ writer.value("");
+ } else {
+ writer.value(String.valueOf(value));
}
-
- return result;
}
- private TypeDefinition<?> resolveBaseTypeFrom(TypeDefinition<?> type) {
- return type.getBaseType() != null ? resolveBaseTypeFrom(type.getBaseType()) : type;
+ private void writeEmptyDataTypeToJson(final JsonWriter writer) throws IOException {
+ writer.beginArray();
+ writer.nullValue();
+ writer.endArray();
}
- private void writeName(Node<?> node, DataSchemaNode schema, JsonWriter writer) throws IOException {
+ private void writeName(final Node<?> node, final DataSchemaNode schema, final JsonWriter writer) throws IOException {
String nameForOutput = node.getNodeType().getLocalName();
- if (schema.isAugmenting()) {
+ if (schema != null && schema.isAugmenting()) {
ControllerContext contContext = ControllerContext.getInstance();
- CharSequence moduleName;
- moduleName = contContext.toRestconfIdentifier(schema.getQName());
+ CharSequence moduleName = null;
+ if (mountPoint == null) {
+ moduleName = contContext.toRestconfIdentifier(schema.getQName());
+ } else {
+ moduleName = contContext.toRestconfIdentifier(mountPoint, schema.getQName());
+ }
if (moduleName != null) {
nameForOutput = moduleName.toString();
+ } else {
+ LOG.info("Module '{}' was not found in schema from mount point", schema.getQName());
}
}
writer.name(nameForOutput);
private static final long serialVersionUID = -3147729419814417666L;
private final String value;
- public NumberForJsonWriter(String value) {
+ public NumberForJsonWriter(final String value) {
this.value = value;
}
Code Review / controller.git / blobdiff