tests/honeynode/honeynode-plugin-impl/src/main/java/io/fd/honeycomb/transportpce/device/tools/DefaultDeviceFactory.java

   1 /*
   2  * Copyright (c) 2018 Orange and/or its affiliates.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package io.fd.honeycomb.transportpce.device.tools;
  17
  18 import io.fd.honeycomb.transportpce.binding.converter.XMLDataObjectConverter;
  19 import io.fd.honeycomb.transportpce.test.common.DataStoreContext;
  20
  21 import java.io.BufferedWriter;
  22 import java.io.ByteArrayInputStream;
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.FileNotFoundException;
  26 import java.io.FileWriter;
  27 import java.io.IOException;
  28 import java.io.InputStream;
  29 import java.io.Writer;
  30 import java.util.Optional;
  31
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  33 import org.opendaylight.yangtools.yang.binding.DataObject;
  34 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 /**
  39  * Factory for creating the default device from the XML stored in
  40  * classpath.
  41  *
  42  * @author Martial COULIBALY ( martial.coulibaly@gfi.com ) on behalf of Orange
  43  */
  44 public class DefaultDeviceFactory {
  45
  46     private static final Logger LOG = LoggerFactory.getLogger(DefaultDeviceFactory.class);
  47
  48     /**
  49      * Returns a new instance of {@link OrgOpenroadmDevice} from the loaded XML stored
  50      * in File.
  51      *
  52      * @return {@link OrgOpenroadmDevice}
  53      */
  54     public OrgOpenroadmDevice createDefaultDevice(DataStoreContext dataStoreContextUtil, File device_data_config) {
  55         OrgOpenroadmDevice result = null;
  56         if (device_data_config.exists()) {
  57             String config = device_data_config.getName();
  58             LOG.info("file '{}' exists at location : {}", config, device_data_config.getAbsolutePath());
  59             InputStream targetStream;
  60             try {
  61                 targetStream = new FileInputStream(device_data_config);
  62                 Optional<NormalizedNode<?, ?>> transformIntoNormalizedNode = null;
  63                 transformIntoNormalizedNode =
  64                         XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil)
  65                         .transformIntoNormalizedNode(targetStream);
  66                 if (!transformIntoNormalizedNode.isPresent()) {
  67                     throw new IllegalStateException(String.format("Could not transform the input %s into normalized nodes",
  68                             config));
  69                 }
  70                 Optional<DataObject> dataObject = XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil)
  71                         .getDataObject(transformIntoNormalizedNode.get(), OrgOpenroadmDevice.QNAME);
  72                 if (!dataObject.isPresent()) {
  73                     throw new IllegalStateException("Could not transform normalized nodes into data object");
  74                 }
  75                 result =  (OrgOpenroadmDevice) dataObject.get();
  76             } catch (FileNotFoundException e) {
  77                 LOG.error("File not found : {} at {}", e.getMessage(), e.getLocalizedMessage());
  78             }
  79         } else {
  80             LOG.info("xml file not existed at : '{}'", device_data_config.getAbsolutePath());
  81         }
  82         return result;
  83     }
  84     /**
  85      * Returns a new instance of {@link OrgOpenroadmDevice} from the loaded XML stored
  86      * in String.
  87      *
  88      * @return {@link OrgOpenroadmDevice}
  89      */
  90     public OrgOpenroadmDevice createDefaultDevice(DataStoreContext dataStoreContextUtil, String device_data_config) {
  91         OrgOpenroadmDevice result = null;
  92         if (device_data_config != null) {
  93             LOG.info("device data config string is ok ");
  94             InputStream targetStream;
  95             targetStream = new ByteArrayInputStream(device_data_config.getBytes());
  96             Optional<NormalizedNode<?, ?>> transformIntoNormalizedNode = null;
  97             transformIntoNormalizedNode =
  98                     XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil)
  99                     .transformIntoNormalizedNode(targetStream);
 100             if (!transformIntoNormalizedNode.isPresent()) {
 101                 throw new IllegalStateException(String.format("Could not transform the input %s into normalized nodes"));
 102             }
 103             Optional<DataObject> dataObject = XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil)
 104                     .getDataObject(transformIntoNormalizedNode.get(), OrgOpenroadmDevice.QNAME);
 105             if (!dataObject.isPresent()) {
 106                 throw new IllegalStateException("Could not transform normalized nodes into data object");
 107             }
 108             result =  (OrgOpenroadmDevice) dataObject.get();
 109         } else {
 110             LOG.info("device data config string is null!");
 111         }
 112         return result;
 113     }
 114
 115
 116     public void createXMLFromDevice(DataStoreContext dataStoreContextUtil, OrgOpenroadmDevice device, String output) {
 117         if (device != null) {
 118             Optional<NormalizedNode<?, ?>> transformIntoNormalizedNode = null;
 119             transformIntoNormalizedNode =
 120                     XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil)
 121                     .toNormalizedNodes(device, OrgOpenroadmDevice.class);
 122             if (!transformIntoNormalizedNode.isPresent()) {
 123                 throw new IllegalStateException(String.format("Could not transform the input %s into normalized nodes",
 124                         device));
 125             }
 126             XMLDataObjectConverter createWithDataStoreUtil = XMLDataObjectConverter.createWithDataStoreUtil(dataStoreContextUtil);
 127             Writer writerFromDataObject =
 128                     createWithDataStoreUtil.writerFromDataObject(device, OrgOpenroadmDevice.class, createWithDataStoreUtil.dataContainer());
 129             try {
 130                 BufferedWriter writer = new BufferedWriter(new FileWriter(output));
 131                 writer.write(writerFromDataObject.toString());
 132                 writer.close();
 133             } catch (IOException e) {
 134                 LOG.error("Bufferwriter error ");
 135             }
 136             LOG.info("device xml : {}", writerFromDataObject.toString());
 137         }
 138     }
 139 }