common/src/main/java/org/opendaylight/transportpce/common/mapping/DeviceConfigImpl.java

   1 /*
   2  * Copyright © 2017 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.common.mapping;
   9
  10 import java.util.List;
  11 import java.util.Optional;
  12
  13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  14 import org.opendaylight.transportpce.common.Timeouts;
  15 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  16 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack;
  17 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  18 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  19 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  20 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  21 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMap;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
  28 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31
  32 public class DeviceConfigImpl implements DeviceConfig {
  33
  34     private static final Logger LOG = LoggerFactory.getLogger(DeviceConfigImpl.class);
  35
  36     private final DeviceTransactionManager deviceTransactionManager;
  37
  38     public DeviceConfigImpl(DeviceTransactionManager deviceTransactionManager) {
  39         this.deviceTransactionManager = deviceTransactionManager;
  40     }
  41
  42     @Override
  43     public Info getDeviceInfo(String nodeId) {
  44         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
  45         Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId,
  46             LogicalDatastoreType.OPERATIONAL, infoIID,
  47             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  48         if (deviceInfoOptional.isPresent()) {
  49             return deviceInfoOptional.get();
  50         } else {
  51             LOG.warn("Device info subtree is absent for {}", nodeId);
  52             return null;
  53         }
  54
  55     }
  56
  57     @Override
  58     public Ports getDevicePorts(String nodeId, String circuitPackName, String portName) {
  59         InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
  60             .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
  61             .child(Ports.class, new PortsKey(portName));
  62         LOG.info("{}: Fetching Port {} at circuit pack {}", nodeId, portName, circuitPackName);
  63         Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
  64             LogicalDatastoreType.OPERATIONAL, portIID, Timeouts.DEVICE_READ_TIMEOUT,
  65             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  66         if (portObject.isPresent()) {
  67             return portObject.get();
  68         } else {
  69             return null;
  70         }
  71     }
  72
  73     @Override
  74     public SharedRiskGroup getDeviceSrg(String nodeId, int srgNb) {
  75         InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
  76             SharedRiskGroup.class, new SharedRiskGroupKey(srgNb));
  77         Optional<SharedRiskGroup> srgObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
  78             LogicalDatastoreType.CONFIGURATION, srgIID, Timeouts.DEVICE_READ_TIMEOUT,
  79             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  80         if (srgObject.isPresent()) {
  81             return srgObject.get();
  82         } else {
  83             return null;
  84         }
  85     }
  86
  87     @Override
  88     public CircuitPack getDeviceCp(String nodeId, String cpName) {
  89         InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
  90             .child(CircuitPacks.class, new CircuitPacksKey(cpName));
  91         Optional<CircuitPacks> cpObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
  92             LogicalDatastoreType.OPERATIONAL, cpIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  93         if (cpObject.isPresent()) {
  94             return cpObject.get();
  95         } else {
  96             return null;
  97         }
  98     }
  99
 100     @Override
 101     public List<ConnectionMap> getConnectionMap(String NodeId) {
 102         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 103         Optional<OrgOpenroadmDevice> deviceObject = this.deviceTransactionManager.getDataFromDevice(NodeId,
 104             LogicalDatastoreType.OPERATIONAL, deviceIID, Timeouts.DEVICE_READ_TIMEOUT,
 105             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 106         if (deviceObject.isPresent()) {
 107             return deviceObject.get().getConnectionMap();
 108         } else {
 109             return null;
 110         }
 111     }
 112
 113     @Override
 114     public Degree getDeviceDegree(String nodeId, int degreeNb) {
 115         InstanceIdentifier<Degree> degreeIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
 116             Degree.class, new DegreeKey(degreeNb));
 117         Optional<Degree> degreeObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 118             LogicalDatastoreType.OPERATIONAL, degreeIID, Timeouts.DEVICE_READ_TIMEOUT,
 119             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 120         if (degreeObject.isPresent()) {
 121             return degreeObject.get();
 122         } else {
 123             return null;
 124         }
 125     }
 126 }