tests/honeynode/honeynode-plugin-impl/src/main/java/io/fd/honeycomb/transportpce/device/read/DeviceReaderFactory.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.read;
  17
  18 import com.google.common.collect.Sets;
  19 import com.google.common.util.concurrent.Futures;
  20 import com.google.inject.Inject;
  21 import com.google.inject.name.Named;
  22 import io.fd.honeycomb.translate.read.ReaderFactory;
  23 import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
  24 import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
  25 import io.fd.honeycomb.transportpce.device.DeviceConfiguration;
  26 import java.io.File;
  27 import java.io.IOException;
  28 import java.text.DateFormat;
  29 import java.text.SimpleDateFormat;
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import java.util.Set;
  33 import java.util.concurrent.ExecutionException;
  34 import java.util.concurrent.Future;
  35 import org.opendaylight.controller.config.util.capability.Capability;
  36 import org.opendaylight.controller.config.util.capability.YangModuleCapability;
  37 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  38 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  39 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDeviceBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfStateBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.SchemasBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location.Enumeration;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.SchemaBuilder;
  51 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  52 import org.opendaylight.yangtools.yang.model.api.Module;
  53 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  54 import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
  55 import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
  56 import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
  57 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  58 import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
  59 import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
  60 import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
  61 import org.opendaylight.yangtools.yang.model.repo.util.FilesystemSchemaSourceCache;
  62 import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
  63 import org.opendaylight.yangtools.yang.parser.util.TextToASTTransformer;
  64 import org.slf4j.Logger;
  65 import org.slf4j.LoggerFactory;
  66
  67 /**
  68  * @author Martial COULIBALY ( martial.coulibaly@gfi.com ) on behalf of Orange
  69  */
  70 public final class DeviceReaderFactory implements ReaderFactory {
  71
  72     private static final Logger LOG = LoggerFactory.getLogger(DeviceReaderFactory.class);
  73     public static final InstanceIdentifier<OrgOpenroadmDevice> DEVICE_CONTAINER_ID =
  74             InstanceIdentifier.create(OrgOpenroadmDevice.class);
  75     private static final String YANG_MODELS = "yang";
  76
  77     @Inject
  78     @Named("device-databroker")
  79     private DataBroker dataBroker;
  80
  81     @Inject
  82     private DeviceConfiguration deviceConfiguration;
  83
  84
  85     @Override
  86     public void init(final ModifiableReaderRegistryBuilder registry) {
  87         registry.add(new BindingBrokerReader<>(DEVICE_CONTAINER_ID, dataBroker,LogicalDatastoreType.OPERATIONAL,
  88                 OrgOpenroadmDeviceBuilder.class));
  89         if(writeXMLDataToOper()) {
  90             writeNetconfState();
  91             loadConfigData();
  92         }
  93     }
  94
  95     /**
  96      * Write xml data from {@link DeviceConfiguration}
  97      * to operational data.
  98      *
  99      */
 100     public boolean writeXMLDataToOper() {
 101         Boolean res = false;
 102         LOG.info("writting xml file data to oper datastore");
 103         OrgOpenroadmDevice device = this.deviceConfiguration.getDataDevice();
 104         if (device !=null) {
 105             String deviceId = device.getInfo().getNodeId();
 106             LOG.info("Getting device info from xml file for device '{}'", deviceId);
 107             OrgOpenroadmDeviceBuilder result  = new OrgOpenroadmDeviceBuilder(device);
 108             InstanceIdentifier<OrgOpenroadmDevice> iid = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 109             WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
 110             if (writeTx != null ) {
 111                 LOG.info("WriteTransaction is ok, copy device info to oper datastore");
 112                 writeTx.put(LogicalDatastoreType.OPERATIONAL, iid, result.build());
 113                 Future<Void> future = writeTx.submit();
 114                 try {
 115                     Futures.getChecked(future, ExecutionException.class);
 116                     LOG.info("device '{}' writed to oper datastore", deviceId);
 117                     res = true;
 118                 } catch (ExecutionException e) {
 119                     LOG.error("Failed to write Element '{}' to oper datastore", deviceId);
 120                 }
 121             } else {
 122                 LOG.error("WriteTransaction object is null");
 123             }
 124         } else {
 125             LOG.error("device data operation gets from xml file is null !");
 126         }
 127         return res;
 128     }
 129
 130     /**
 131      * Load data to config
 132      * device datastore.
 133      *
 134      */
 135     public boolean loadConfigData() {
 136         Boolean res = false;
 137         LOG.info("loading device configuration info from xml file...");
 138         String xml = this.deviceConfiguration.getConfigDevice();
 139         LOG.info("device info gets from xml file !");
 140         if (xml != null) {
 141             OrgOpenroadmDevice result  = this.deviceConfiguration.getDeviceFromXML(xml);
 142             if (result != null) {
 143                 LOG.info("OrgOpenroadmDevice info gets : {}", result.getInfo().getNodeId());
 144                 WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
 145                 if (writeTx != null ) {
 146                     LOG.info("WriteTransaction is ok, copy device info to config datastore");
 147                     writeTx.put(LogicalDatastoreType.CONFIGURATION, DEVICE_CONTAINER_ID, result);
 148                     Future<Void> future = writeTx.submit();
 149                     try {
 150                         Futures.getChecked(future, ExecutionException.class);
 151                         LOG.info("device writed to config datastore");
 152                       } catch (ExecutionException e) {
 153                           LOG.error("Failed to write device to config datastore");
 154                       }
 155                 } else {
 156                     LOG.error("WriteTransaction object is null");
 157                 }
 158             } else {
 159                 LOG.error("device gets from xml is null !!");
 160             }
 161         } else {
 162             LOG.error("device ID from input is not the same from xml file");
 163         }
 164         return res;
 165     }
 166
 167     /**
 168      * Write xml data from {@link DeviceConfiguration}
 169      * to operational data.
 170      *
 171      */
 172     public boolean writeNetconfState() {
 173         Boolean res = false;
 174         LOG.info("writting netconf state to oper datastore");
 175         final SharedSchemaRepository schemaRepo = new SharedSchemaRepository("honeynode-simulator");
 176         final Set<Capability> capabilities = parseSchemasToModuleCapabilities(schemaRepo);
 177         final Set<Capability> transformedCapabilities = Sets.newHashSet(capabilities);
 178         DummyMonitoringService monitor = new DummyMonitoringService(transformedCapabilities);
 179         List<Schema> schemaList = new ArrayList<Schema>();
 180         List<Location> locationList = new ArrayList<Location>();
 181         Location location = new Location(Enumeration.NETCONF);
 182         locationList.add(location );
 183         Schema schematobuild = null;
 184         for (final Schema schema : monitor.getSchemas().getSchema()) {
 185             schematobuild = new SchemaBuilder()
 186                     .setIdentifier(schema.getIdentifier())
 187                     .setNamespace(schema.getNamespace())
 188                     .setVersion(schema.getVersion())
 189                     .setFormat(Yang.class)
 190                     .setLocation(locationList)
 191                     .build();
 192             schemaList.add(schematobuild);
 193         }
 194         Schemas schemas = new SchemasBuilder()
 195                 .setSchema(schemaList)
 196                 .build();
 197         NetconfState netconfState = new NetconfStateBuilder()
 198                 .setSchemas(schemas)
 199                 .build();
 200         if (netconfState !=null) {
 201             InstanceIdentifier<NetconfState> iid = InstanceIdentifier.create(NetconfState.class);
 202             WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
 203             if (writeTx != null ) {
 204                 LOG.info("WriteTransaction is ok, copy device info to oper datastore");
 205                 writeTx.put(LogicalDatastoreType.OPERATIONAL, iid, netconfState);
 206                 Future<Void> future = writeTx.submit();
 207                 try {
 208                     Futures.getChecked(future, ExecutionException.class);
 209                     LOG.info("netconf state writed to oper datastore");
 210                     res = true;
 211                 } catch (ExecutionException e) {
 212                     LOG.error("Failed to write netconf state to oper datastore");
 213                 }
 214             } else {
 215                 LOG.error("WriteTransaction object is null");
 216             }
 217         } else {
 218             LOG.error("device data operation gets from xml file is null !");
 219         }
 220         return res;
 221     }
 222
 223     private Set<Capability> parseSchemasToModuleCapabilities(final SharedSchemaRepository consumer) {
 224         final Set<SourceIdentifier> loadedSources = Sets.newHashSet();
 225         consumer.registerSchemaSourceListener(TextToASTTransformer.create(consumer, consumer));
 226         consumer.registerSchemaSourceListener(new SchemaSourceListener() {
 227             @Override
 228             public void schemaSourceEncountered(final SchemaSourceRepresentation schemaSourceRepresentation) {}
 229
 230             @Override
 231             public void schemaSourceRegistered(final Iterable<PotentialSchemaSource<?>> potentialSchemaSources) {
 232                 for (final PotentialSchemaSource<?> potentialSchemaSource : potentialSchemaSources) {
 233                     loadedSources.add(potentialSchemaSource.getSourceIdentifier());
 234                 }
 235             }
 236
 237             @Override
 238             public void schemaSourceUnregistered(final PotentialSchemaSource<?> potentialSchemaSource) {}
 239         });
 240         LOG.info("Loading models from directory.");
 241         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 242         File models = new File(classLoader.getResource(YANG_MODELS).getFile());
 243         if (models.exists() && models.isDirectory()) {
 244             LOG.info("folder '{}' exists !", models.getAbsolutePath());
 245             final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(
 246                     consumer, YangTextSchemaSource.class, models);
 247                 consumer.registerSchemaSourceListener(cache);
 248         } else {
 249             LOG.warn("folder '{}' not exists !", models.getAbsolutePath());
 250             LOG.info("Custom module loading skipped.");
 251         }
 252         SchemaContext schemaContext;
 253         try {
 254             //necessary for creating mdsal data stores and operations
 255             schemaContext = consumer.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT)
 256                 .createSchemaContext(loadedSources).get();
 257         } catch (final InterruptedException | ExecutionException e) {
 258             throw new RuntimeException("Cannot parse schema context", e);
 259         }
 260
 261         final Set<Capability> capabilities = Sets.newHashSet();
 262
 263         for (final Module module : schemaContext.getModules()) {
 264             for (final Module subModule : module.getSubmodules()) {
 265                 addModuleCapability(consumer, capabilities, subModule);
 266             }
 267             addModuleCapability(consumer, capabilities, module);
 268         }
 269         return capabilities;
 270     }
 271
 272     private static void addModuleCapability(final SharedSchemaRepository consumer, final Set<Capability> capabilities,
 273                                      final Module module) {
 274         DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
 275
 276         //to convert Date to String, use format method of SimpleDateFormat class.
 277         String revision = dateFormat.format(module.getRevision());
 278         final SourceIdentifier moduleSourceIdentifier = RevisionSourceIdentifier.create(module.getName(),
 279             revision);
 280         try {
 281             final String moduleContent = new String(
 282                 consumer.getSchemaSource(moduleSourceIdentifier, YangTextSchemaSource.class).get().read());
 283             capabilities.add(new YangModuleCapability(module, moduleContent));
 284             //IOException would be thrown in creating SchemaContext already
 285         } catch (ExecutionException | InterruptedException | IOException e) {
 286             LOG.warn("Cannot retrieve schema source for module {} from schema repository",
 287                     moduleSourceIdentifier.toString(), e);
 288         }
 289 }
 290 }