import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.CheckedFuture;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.sql.Date;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
import org.opendaylight.controller.sal.restconf.impl.CompositeNodeWrapper;
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
+import org.opendaylight.controller.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.controller.sal.restconf.impl.NodeWrapper;
+import org.opendaylight.controller.sal.restconf.impl.NormalizedNodeContext;
+import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorTag;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorType;
import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
import org.opendaylight.controller.sal.restconf.impl.StructuredData;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
+import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
+import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(TestUtils.class);
- private final static YangModelParser parser = new YangParserImpl();
+ private final static YangContextParser parser = new YangParserImpl();
- private static Set<Module> loadModules(String resourceDirectory) throws FileNotFoundException {
+ private static Set<Module> loadModules(final String resourceDirectory) throws FileNotFoundException {
final File testDir = new File(resourceDirectory);
final String[] fileList = testDir.list();
final List<File> testFiles = new ArrayList<File>();
throw new FileNotFoundException(resourceDirectory);
}
for (int i = 0; i < fileList.length; i++) {
- String fileName = fileList[i];
+ final String fileName = fileList[i];
if (new File(testDir, fileName).isDirectory() == false) {
testFiles.add(new File(testDir, fileName));
}
return parser.parseYangModels(testFiles);
}
- public static Set<Module> loadModulesFrom(String yangPath) {
+ public static Set<Module> loadModulesFrom(final String yangPath) {
try {
return TestUtils.loadModules(TestUtils.class.getResource(yangPath).getPath());
- } catch (FileNotFoundException e) {
+ } catch (final FileNotFoundException e) {
LOG.error("Yang files at path: " + yangPath + " weren't loaded.");
}
return null;
}
- public static SchemaContext loadSchemaContext(Set<Module> modules) {
+ public static SchemaContext loadSchemaContext(final Set<Module> modules) {
return parser.resolveSchemaContext(modules);
}
- public static SchemaContext loadSchemaContext(String resourceDirectory) throws FileNotFoundException {
+ public static SchemaContext loadSchemaContext(final String resourceDirectory) throws FileNotFoundException {
return parser.resolveSchemaContext(loadModulesFrom(resourceDirectory));
}
- public static Module findModule(Set<Module> modules, String moduleName) {
- for (Module module : modules) {
+ public static Module findModule(final Set<Module> modules, final String moduleName) {
+ for (final Module module : modules) {
if (module.getName().equals(moduleName)) {
return module;
}
return null;
}
- public static Document loadDocumentFrom(InputStream inputStream) {
+ public static Document loadDocumentFrom(final InputStream inputStream) {
try {
- DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
- DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
+ final DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
+ final DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
return docBuilder.parse(inputStream);
} catch (SAXException | IOException | ParserConfigurationException e) {
LOG.error("Error during loading Document from XML", e);
}
}
- public static String getDocumentInPrintableForm(Document doc) {
+ public static String getDocumentInPrintableForm(final Document doc) {
Preconditions.checkNotNull(doc);
try {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- TransformerFactory tf = TransformerFactory.newInstance();
- Transformer transformer = tf.newTransformer();
+ final ByteArrayOutputStream out = new ByteArrayOutputStream();
+ final TransformerFactory tf = TransformerFactory.newInstance();
+ final Transformer transformer = tf.newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
transformer.transform(new DOMSource(doc), new StreamResult(new OutputStreamWriter(out, "UTF-8")));
- byte[] charData = out.toByteArray();
+ final byte[] charData = out.toByteArray();
return new String(charData, "UTF-8");
} catch (IOException | TransformerException e) {
- String msg = "Error during transformation of Document into String";
+ final String msg = "Error during transformation of Document into String";
LOG.error(msg, e);
return msg;
}
}
/**
+ * @deprecated method will be removed in Lithium release
+ * we don't wish to use Node and CompositeNode anywhere -
*
* Fill missing data (namespaces) and build correct data type in {@code compositeNode} according to
* {@code dataSchemaNode}. The method {@link RestconfImpl#createConfigurationData createConfigurationData} is used
* because it contains calling of method {code normalizeNode}
*/
- public static void normalizeCompositeNode(CompositeNode compositeNode, Set<Module> modules, String schemaNodePath) {
- RestconfImpl restconf = RestconfImpl.getInstance();
+ @Deprecated
+ public static void normalizeCompositeNode(final Node<?> node, final Set<Module> modules, final String schemaNodePath) {
+ final RestconfImpl restconf = RestconfImpl.getInstance();
ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext(modules));
-
prepareMocksForRestconf(modules, restconf);
- restconf.updateConfigurationData(schemaNodePath, compositeNode);
+
+ final InstanceIdentifierContext iiContext = ControllerContext.getInstance().toInstanceIdentifier(schemaNodePath);
+ final DOMMountPoint mountPoint = iiContext.getMountPoint();
+ final CompositeNode value = RestconfImpl.getInstance().normalizeNode(node, (DataSchemaNode) iiContext.getSchemaNode(), mountPoint);
+ final NormalizedNode<?, ?> normNodePayload = compositeNodeToDatastoreNormalizedNode(value, (DataSchemaNode) iiContext.getSchemaNode());
+ final NormalizedNodeContext normlNodeContext = new NormalizedNodeContext(iiContext, normNodePayload);
+
+ restconf.updateConfigurationData(schemaNodePath, normlNodeContext);
}
/**
* module set has only one element then this element is returned.
*
*/
- public static Module resolveModule(String searchedModuleName, Set<Module> modules) {
+ public static Module resolveModule(final String searchedModuleName, final Set<Module> modules) {
assertNotNull("Modules can't be null.", modules);
if (searchedModuleName != null) {
- for (Module m : modules) {
+ for (final Module m : modules) {
if (m.getName().equals(searchedModuleName)) {
return m;
}
return null;
}
- public static DataSchemaNode resolveDataSchemaNode(String searchedDataSchemaName, Module module) {
+ public static DataSchemaNode resolveDataSchemaNode(final String searchedDataSchemaName, final Module module) {
assertNotNull("Module can't be null", module);
if (searchedDataSchemaName != null) {
- for (DataSchemaNode dsn : module.getChildNodes()) {
+ for (final DataSchemaNode dsn : module.getChildNodes()) {
if (dsn.getQName().getLocalName().equals(searchedDataSchemaName)) {
return dsn;
}
return null;
}
- public static QName buildQName(String name, String uri, String date, String prefix) {
+ public static QName buildQName(final String name, final String uri, final String date, final String prefix) {
try {
- URI u = new URI(uri);
+ final URI u = new URI(uri);
Date dt = null;
if (date != null) {
dt = Date.valueOf(date);
}
- return new QName(u, dt, prefix, name);
- } catch (URISyntaxException e) {
+ return QName.create(u, dt, name);
+ } catch (final URISyntaxException e) {
return null;
}
}
- public static QName buildQName(String name, String uri, String date) {
+ public static QName buildQName(final String name, final String uri, final String date) {
return buildQName(name, uri, date, null);
}
- public static QName buildQName(String name) {
+ public static QName buildQName(final String name) {
return buildQName(name, "", null);
}
- private static void addDummyNamespaceToAllNodes(NodeWrapper<?> wrappedNode) throws URISyntaxException {
+ private static void addDummyNamespaceToAllNodes(final NodeWrapper<?> wrappedNode) throws URISyntaxException {
wrappedNode.setNamespace(new URI(""));
if (wrappedNode instanceof CompositeNodeWrapper) {
- for (NodeWrapper<?> childNodeWrapper : ((CompositeNodeWrapper) wrappedNode).getValues()) {
+ for (final NodeWrapper<?> childNodeWrapper : ((CompositeNodeWrapper) wrappedNode).getValues()) {
addDummyNamespaceToAllNodes(childNodeWrapper);
}
}
}
- private static void prepareMocksForRestconf(Set<Module> modules, RestconfImpl restconf) {
- ControllerContext controllerContext = ControllerContext.getInstance();
- BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
+ private static void prepareMocksForRestconf(final Set<Module> modules, final RestconfImpl restconf) {
+ final ControllerContext controllerContext = ControllerContext.getInstance();
+ final BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
controllerContext.setSchemas(TestUtils.loadSchemaContext(modules));
- when(mockedBrokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
- .thenReturn(
- new DummyFuture.Builder().rpcResult(
- new DummyRpcResult.Builder<TransactionStatus>().result(TransactionStatus.COMMITED)
- .build()).build());
+ when(mockedBrokerFacade.commitConfigurationDataPut(any(YangInstanceIdentifier.class), any(NormalizedNode.class)))
+ .thenReturn(mock(CheckedFuture.class));
restconf.setControllerContext(controllerContext);
restconf.setBroker(mockedBrokerFacade);
}
- public static CompositeNode readInputToCnSn(String path, boolean dummyNamespaces,
- MessageBodyReader<CompositeNode> reader) throws WebApplicationException {
+ public static Node<?> readInputToCnSn(final String path, final boolean dummyNamespaces,
+ final MessageBodyReader<Node<?>> reader) throws WebApplicationException {
- InputStream inputStream = TestUtils.class.getResourceAsStream(path);
+ final InputStream inputStream = TestUtils.class.getResourceAsStream(path);
try {
- CompositeNode compositeNode = reader.readFrom(null, null, null, null, null, inputStream);
- assertTrue(compositeNode instanceof CompositeNodeWrapper);
+ final Node<?> node = reader.readFrom(null, null, null, null, null, inputStream);
+ assertTrue(node instanceof CompositeNodeWrapper);
if (dummyNamespaces) {
try {
- TestUtils.addDummyNamespaceToAllNodes((CompositeNodeWrapper) compositeNode);
- return ((CompositeNodeWrapper) compositeNode).unwrap();
- } catch (URISyntaxException e) {
+ TestUtils.addDummyNamespaceToAllNodes((CompositeNodeWrapper) node);
+ return ((CompositeNodeWrapper) node).unwrap();
+ } catch (final URISyntaxException e) {
LOG.error(e.getMessage());
assertTrue(e.getMessage(), false);
}
}
- return compositeNode;
- } catch (IOException e) {
+ return node;
+ } catch (final IOException e) {
LOG.error(e.getMessage());
assertTrue(e.getMessage(), false);
}
return null;
}
- public static CompositeNode readInputToCnSn(String path, MessageBodyReader<CompositeNode> reader) {
+// public static Node<?> readInputToCnSnNew(String path, MessageBodyReader<Node<?>> reader) throws WebApplicationException {
+// InputStream inputStream = TestUtils.class.getResourceAsStream(path);
+// try {
+// return reader.readFrom(null, null, null, null, null, inputStream);
+// } catch (IOException e) {
+// LOG.error(e.getMessage());
+// assertTrue(e.getMessage(), false);
+// }
+// return null;
+// }
+
+ public static Node<?> readInputToCnSn(final String path, final MessageBodyReader<Node<?>> reader) {
return readInputToCnSn(path, false, reader);
}
- public static String writeCompNodeWithSchemaContextToOutput(CompositeNode compositeNode, Set<Module> modules,
- DataSchemaNode dataSchemaNode, MessageBodyWriter<StructuredData> messageBodyWriter) throws IOException,
+ public static String writeCompNodeWithSchemaContextToOutput(final Node<?> node, final Set<Module> modules,
+ final DataSchemaNode dataSchemaNode, final MessageBodyWriter<StructuredData> messageBodyWriter) throws IOException,
WebApplicationException {
assertNotNull(dataSchemaNode);
- assertNotNull("Composite node can't be null", compositeNode);
- ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
+ assertNotNull("Composite node can't be null", node);
+ final ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
ControllerContext.getInstance().setSchemas(loadSchemaContext(modules));
- messageBodyWriter.writeTo(new StructuredData(compositeNode, dataSchemaNode, null), null, null, null, null,
+ assertTrue(node instanceof CompositeNode);
+ messageBodyWriter.writeTo(new StructuredData((CompositeNode)node, dataSchemaNode, null), null, null, null, null,
null, byteArrayOS);
return byteArrayOS.toString();
}
- public static String loadTextFile(String filePath) throws IOException {
- FileReader fileReader = new FileReader(filePath);
- BufferedReader bufReader = new BufferedReader(fileReader);
+ public static String loadTextFile(final String filePath) throws IOException {
+ final FileReader fileReader = new FileReader(filePath);
+ final BufferedReader bufReader = new BufferedReader(fileReader);
String line = null;
- StringBuilder result = new StringBuilder();
+ final StringBuilder result = new StringBuilder();
while ((line = bufReader.readLine()) != null) {
result.append(line);
}
return result.toString();
}
- private static Pattern patternForStringsSeparatedByWhiteChars(String... substrings) {
- StringBuilder pattern = new StringBuilder();
+ private static Pattern patternForStringsSeparatedByWhiteChars(final String... substrings) {
+ final StringBuilder pattern = new StringBuilder();
pattern.append(".*");
- for (String substring : substrings) {
+ for (final String substring : substrings) {
pattern.append(substring);
pattern.append("\\s*");
}
return Pattern.compile(pattern.toString(), Pattern.DOTALL);
}
- public static boolean containsStringData(String jsonOutput, String... substrings) {
- Pattern pattern = patternForStringsSeparatedByWhiteChars(substrings);
- Matcher matcher = pattern.matcher(jsonOutput);
+ public static boolean containsStringData(final String jsonOutput, final String... substrings) {
+ final Pattern pattern = patternForStringsSeparatedByWhiteChars(substrings);
+ final Matcher matcher = pattern.matcher(jsonOutput);
return matcher.matches();
}
+
+ public static NormalizedNode compositeNodeToDatastoreNormalizedNode(final CompositeNode compositeNode,
+ final DataSchemaNode schema) {
+ final List<Node<?>> lst = new ArrayList<Node<?>>();
+ lst.add(compositeNode);
+ if (schema instanceof ContainerSchemaNode) {
+ return CnSnToNormalizedNodeParserFactory.getInstance().getContainerNodeParser()
+ .parse(lst, (ContainerSchemaNode) schema);
+ } else if (schema instanceof ListSchemaNode) {
+ return CnSnToNormalizedNodeParserFactory.getInstance().getMapNodeParser()
+ .parse(lst, (ListSchemaNode) schema);
+ }
+
+ LOG.error("Top level isn't of type container, list, leaf schema node but " + schema.getClass().getSimpleName());
+
+ throw new RestconfDocumentedException(new RestconfError(ErrorType.APPLICATION, ErrorTag.INVALID_VALUE,
+ "It wasn't possible to translate specified data to datastore readable form."));
+ }
+
+ public static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName, final String namespace,
+ final String revision) throws ParseException {
+ return new YangInstanceIdentifier.NodeIdentifier(QName.create(namespace, revision, localName));
+ }
+
+ public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
+ final String namespace, final String revision, final Map<String, Object> keys) throws ParseException {
+ final Map<QName, Object> predicate = new HashMap<>();
+ for (final String key : keys.keySet()) {
+ predicate.put(QName.create(namespace, revision, key), keys.get(key));
+ }
+
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+
+ QName.create(namespace, revision, localName), predicate);
+ }
+
+ public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
+ final String namespace, final String revision, final String... keysAndValues) throws ParseException {
+ final java.util.Date date = new SimpleDateFormat("yyyy-MM-dd").parse(revision);
+ if (keysAndValues.length % 2 != 0) {
+ new IllegalArgumentException("number of keys argument have to be divisible by 2 (map)");
+ }
+ final Map<QName, Object> predicate = new HashMap<>();
+
+ int i = 0;
+ while (i < keysAndValues.length) {
+ predicate.put(QName.create(namespace, revision, keysAndValues[i++]), keysAndValues[i++]);
+ }
+
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(namespace, revision, localName),
+ predicate);
+ }
+
+ /**
+ * @deprecated method has to be removed for Lithium release
+ * so please use prepareNormalizedNodeWithIetfInterfacesInterfacesData method
+ */
+ @Deprecated
+ public static CompositeNode prepareCompositeNodeWithIetfInterfacesInterfacesData() {
+ final CompositeNodeBuilder<ImmutableCompositeNode> interfaceBuilder = ImmutableCompositeNode.builder();
+ interfaceBuilder.addLeaf(buildQName("name", "dummy", "2014-07-29"), "eth0");
+ interfaceBuilder.addLeaf(buildQName("type", "dummy", "2014-07-29"), "ethernetCsmacd");
+ interfaceBuilder.addLeaf(buildQName("enabled", "dummy", "2014-07-29"), "false");
+ interfaceBuilder.addLeaf(buildQName("description", "dummy", "2014-07-29"), "some interface");
+ return interfaceBuilder.toInstance();
+ }
+
+ static NormalizedNode<?,?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
+ final String ietfInterfacesDate = "2013-07-04";
+ final String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode = ImmutableMapEntryNodeBuilder.create();
+
+ final Map<String, Object> predicates = new HashMap<>();
+ predicates.put("name", "eth0");
+
+ mapEntryNode.withNodeIdentifier(getNodeIdentifierPredicate("interface", namespace, ietfInterfacesDate,
+ predicates));
+ mapEntryNode
+ .withChild(new ImmutableLeafNodeBuilder<String>()
+ .withNodeIdentifier(getNodeIdentifier("name", namespace, ietfInterfacesDate)).withValue("eth0")
+ .build());
+ mapEntryNode.withChild(new ImmutableLeafNodeBuilder<String>()
+ .withNodeIdentifier(getNodeIdentifier("type", namespace, ietfInterfacesDate))
+ .withValue("ethernetCsmacd").build());
+ mapEntryNode.withChild(new ImmutableLeafNodeBuilder<Boolean>()
+ .withNodeIdentifier(getNodeIdentifier("enabled", namespace, ietfInterfacesDate))
+ .withValue(Boolean.FALSE).build());
+ mapEntryNode.withChild(new ImmutableLeafNodeBuilder<String>()
+ .withNodeIdentifier(getNodeIdentifier("description", namespace, ietfInterfacesDate))
+ .withValue("some interface").build());
+
+ return mapEntryNode.build();
+ }
}
Code Review / controller.git / blobdiff