renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java

   1 /*
   2  * Copyright © 2019 AT&T 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.renderer.openroadminterface;
   9
  10 import java.util.HashSet;
  11 import java.util.Set;
  12 import java.util.stream.IntStream;
  13 import org.opendaylight.transportpce.common.mapping.PortMapping;
  14 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  15 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  16 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.AEndApiInfo;
  17 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo;
  18 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev231221.mapping.Mapping;
  19 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
  20 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
  21 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU0;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU2;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU2e;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUCTP;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTPCTP;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.Opu;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.parent.odu.allocation.ParentOduAllocation;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.parent.odu.allocation.ParentOduAllocationBuilder;
  40 import org.opendaylight.yangtools.yang.common.Uint16;
  41 import org.opendaylight.yangtools.yang.common.Uint32;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44
  45
  46 public class OpenRoadmOtnInterface221 {
  47
  48     private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
  49         "Unable to get mapping from PortMapping for node % and logical connection port %s";
  50     private final PortMapping portMapping;
  51     private final OpenRoadmInterfaces openRoadmInterfaces;
  52     private static final Logger LOG = LoggerFactory
  53             .getLogger(OpenRoadmOtnInterface221.class);
  54
  55     public OpenRoadmOtnInterface221(PortMapping portMapping,
  56             OpenRoadmInterfaces openRoadmInterfaces) {
  57         this.portMapping = portMapping;
  58         this.openRoadmInterfaces = openRoadmInterfaces;
  59     }
  60
  61     public String createOpenRoadmEth1GInterface(String nodeId,
  62             String logicalConnPoint) throws OpenRoadmInterfaceException {
  63         Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
  64         if (portMap == null) {
  65             throwException(nodeId, logicalConnPoint);
  66         }
  67
  68         // Ethernet interface specific data
  69         EthernetBuilder ethIfBuilder = new EthernetBuilder()
  70                 .setSpeed(Uint32.valueOf(1000));
  71         InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.VALUE,
  72                 logicalConnPoint + "-ETHERNET1G");
  73         // Create Interface1 type object required for adding as augmentation
  74         Interface1Builder ethIf1Builder = new Interface1Builder();
  75         ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
  76         // Post interface on the device
  77         this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
  78         // Post the equipment-state change on the device circuit-pack
  79         this.openRoadmInterfaces.postOTNEquipmentState(nodeId,
  80                 portMap.getSupportingCircuitPackName(), true);
  81         this.portMapping.updateMapping(nodeId, portMap);
  82         String ethernetInterfaceName = ethInterfaceBldr.getName();
  83
  84         return ethernetInterfaceName;
  85     }
  86
  87     private void throwException(String nodeId, String logicalConnPoint)
  88             throws OpenRoadmInterfaceException {
  89         throw new OpenRoadmInterfaceException(String.format(
  90                 "Unable to get mapping from PortMapping for node % and logical connection port %s",
  91                 nodeId, logicalConnPoint));
  92     }
  93
  94     private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, InterfaceType type, String key) {
  95         return new InterfaceBuilder()
  96                 // .setDescription(" TBD ")
  97                 // .setCircuitId(" TBD ")
  98                 .setSupportingCircuitPackName(
  99                         portMap.getSupportingCircuitPackName())
 100                 .setSupportingPort(portMap.getSupportingPort())
 101                 .setAdministrativeState(AdminStates.InService)
 102                 // TODO get rid of unchecked cast warning
 103                 .setType(type).setName(key).withKey(new InterfaceKey(key));
 104     }
 105
 106     public String createOpenRoadmEth10GInterface(String nodeId,
 107             String logicalConnPoint) throws OpenRoadmInterfaceException {
 108         Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
 109         if (portMap == null) {
 110             throwException(nodeId, logicalConnPoint);
 111         }
 112
 113         // Ethernet interface specific data
 114         EthernetBuilder ethIfBuilder = new EthernetBuilder()
 115                 // .setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
 116                 .setSpeed(Uint32.valueOf(10000));
 117         // Create Interface1 type object required for adding as augmentation
 118         Interface1Builder ethIf1Builder = new Interface1Builder();
 119         InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.VALUE,
 120                 logicalConnPoint + "-ETHERNET10G").addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build())
 121                         .build());
 122         // Post interface on the device
 123         this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
 124         // Post the equipment-state change on the device circuit-pack
 125         this.openRoadmInterfaces.postOTNEquipmentState(nodeId,
 126                 portMap.getSupportingCircuitPackName(), true);
 127         this.portMapping.updateMapping(nodeId, portMap);
 128         String ethernetInterfaceName = ethInterfaceBldr.getName();
 129
 130         return ethernetInterfaceName;
 131     }
 132
 133     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String serviceName,
 134             boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
 135             String payloadType) throws OpenRoadmInterfaceException {
 136
 137         Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
 138         if (mapping == null) {
 139             throw new OpenRoadmInterfaceException(
 140                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
 141         }
 142         InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.VALUE,
 143             logicalConnPoint + "-ODU2e" + ":" + serviceName);
 144         if (mapping.getSupportingOdu4() != null) {
 145             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
 146         }
 147         if (mapping.getSupportingEthernet() != null) {
 148             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
 149         }
 150
 151         OduFunctionIdentity oduFunction;
 152         MonitoringMode monitoringMode;
 153         Opu opu = null;
 154         ParentOduAllocation parentOduAllocation = null;
 155         if (isCTP) {
 156             oduFunction = ODUCTP.VALUE;
 157             monitoringMode = MonitoringMode.Monitored;
 158             Set<Uint16> tribSlots = new HashSet<>();
 159             Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
 160             tribSlots.add(newIdx);
 161             IntStream.range(tribSlotIndex, tribSlotIndex + 8)
 162                     .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
 163             parentOduAllocation = new ParentOduAllocationBuilder()
 164                     .setTribPortNumber(Uint16.valueOf(tribPortNumber))
 165                     .setTribSlots(tribSlots)
 166                     .build();
 167         } else {
 168             oduFunction = ODUTTPCTP.VALUE;
 169             monitoringMode = MonitoringMode.Terminated;
 170             opu = new OpuBuilder()
 171                 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 172                 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 173                 .build();
 174         }
 175         OduBuilder oduIfBuilder = new OduBuilder()
 176             .setRate(ODU2e.VALUE)
 177             .setOduFunction(oduFunction)
 178             .setMonitoringMode(monitoringMode)
 179             .setOpu(opu)
 180             .setParentOduAllocation(parentOduAllocation);
 181         if (apiInfoA != null) {
 182             oduIfBuilder.setTxSapi(apiInfoA.getSapi())
 183                 .setTxDapi(apiInfoA.getDapi())
 184                 .setExpectedSapi(apiInfoA.getExpectedSapi())
 185                 .setExpectedDapi(apiInfoA.getExpectedDapi());
 186         }
 187         if (apiInfoZ != null) {
 188             oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
 189                 .setTxDapi(apiInfoZ.getDapi())
 190                 .setExpectedSapi(apiInfoZ.getExpectedSapi())
 191                 .setExpectedDapi(apiInfoZ.getExpectedDapi());
 192         }
 193         // Create Interface1 type object required for adding as augmentation
 194         // TODO look at imports of different versions of class
 195         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
 196             oduIf1Builder = new
 197                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
 198         oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
 199
 200         // Post interface on the device
 201         this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
 202         if (!isCTP) {
 203             LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
 204             this.portMapping.updateMapping(nodeId, mapping);
 205         }
 206         return oduInterfaceBldr.getName();
 207     }
 208
 209     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
 210         boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
 211             String payloadType) throws OpenRoadmInterfaceException {
 212
 213         Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
 214         if (mapping == null) {
 215             throw new OpenRoadmInterfaceException(
 216                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
 217         }
 218         InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.VALUE,
 219             logicalConnPoint + "-ODU0" + ":" + servicename);
 220         if (mapping.getSupportingOdu4() != null) {
 221             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
 222         }
 223         if (mapping.getSupportingEthernet() != null) {
 224             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
 225         }
 226
 227         OduFunctionIdentity oduFunction;
 228         MonitoringMode monitoringMode;
 229         Opu opu = null;
 230         ParentOduAllocation parentOduAllocation = null;
 231         if (isCTP) {
 232             oduFunction = ODUCTP.VALUE;
 233             monitoringMode = MonitoringMode.Monitored;
 234             Set<Uint16> tribSlots = new HashSet<>();
 235             Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
 236             tribSlots.add(newIdx);
 237             IntStream.range(tribSlotIndex, tribSlotIndex + 8)
 238                     .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
 239             parentOduAllocation = new ParentOduAllocationBuilder()
 240                     .setTribPortNumber(Uint16.valueOf(tribPortNumber))
 241                     .setTribSlots(tribSlots)
 242                     .build();
 243         } else {
 244             oduFunction = ODUTTPCTP.VALUE;
 245             monitoringMode = MonitoringMode.Terminated;
 246             opu = new OpuBuilder()
 247                 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 248                 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 249                 .build();
 250         }
 251         OduBuilder oduIfBuilder = new OduBuilder()
 252             .setRate(ODU0.VALUE)
 253             .setOduFunction(oduFunction)
 254             .setMonitoringMode(monitoringMode)
 255             .setOpu(opu)
 256             .setParentOduAllocation(parentOduAllocation);
 257         if (apiInfoA != null) {
 258             oduIfBuilder.setTxSapi(apiInfoA.getSapi())
 259                 .setTxDapi(apiInfoA.getDapi())
 260                 .setExpectedSapi(apiInfoA.getExpectedSapi())
 261                 .setExpectedDapi(apiInfoA.getExpectedDapi());
 262         }
 263         if (apiInfoZ != null) {
 264             oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
 265                 .setTxDapi(apiInfoZ.getDapi())
 266                 .setExpectedSapi(apiInfoZ.getExpectedSapi())
 267                 .setExpectedDapi(apiInfoZ.getExpectedDapi());
 268         }
 269         // Create Interface1 type object required for adding as augmentation
 270         // TODO look at imports of different versions of class
 271         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
 272             oduIf1Builder = new
 273                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
 274         oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
 275
 276         // Post interface on the device
 277         this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
 278         if (!isCTP) {
 279             LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
 280             this.portMapping.updateMapping(nodeId, mapping);
 281         }
 282         return oduInterfaceBldr.getName();
 283     }
 284
 285     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint,
 286             String servicename, boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA,
 287             ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
 288
 289         Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
 290         if (mapping == null) {
 291             throw new OpenRoadmInterfaceException(
 292                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
 293         }
 294         InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.VALUE,
 295             logicalConnPoint + "-ODU2" + ":" + servicename);
 296         if (mapping.getSupportingOdu4() != null) {
 297             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
 298         }
 299         if (mapping.getSupportingEthernet() != null) {
 300             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
 301         }
 302
 303         OduFunctionIdentity oduFunction;
 304         MonitoringMode monitoringMode;
 305         Opu opu = null;
 306         ParentOduAllocation parentOduAllocation = null;
 307         if (isCTP) {
 308             oduFunction = ODUCTP.VALUE;
 309             monitoringMode = MonitoringMode.Monitored;
 310             Set<Uint16> tribSlots = new HashSet<>();
 311             Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
 312             tribSlots.add(newIdx);
 313             IntStream.range(tribSlotIndex, tribSlotIndex + 8)
 314                     .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
 315             parentOduAllocation = new ParentOduAllocationBuilder()
 316                     .setTribPortNumber(Uint16.valueOf(tribPortNumber))
 317                     .setTribSlots(tribSlots)
 318                     .build();
 319         } else {
 320             oduFunction = ODUTTPCTP.VALUE;
 321             monitoringMode = MonitoringMode.Terminated;
 322             opu = new OpuBuilder()
 323                 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 324                 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 325                 .build();
 326         }
 327         OduBuilder oduIfBuilder = new OduBuilder()
 328             .setRate(ODU2.VALUE)
 329             .setOduFunction(oduFunction)
 330             .setMonitoringMode(monitoringMode)
 331             .setOpu(opu)
 332             .setParentOduAllocation(parentOduAllocation);
 333         if (apiInfoA != null) {
 334             oduIfBuilder.setTxSapi(apiInfoA.getSapi())
 335                 .setTxDapi(apiInfoA.getDapi())
 336                 .setExpectedSapi(apiInfoA.getExpectedSapi())
 337                 .setExpectedDapi(apiInfoA.getExpectedDapi());
 338         }
 339         if (apiInfoZ != null) {
 340             oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
 341                 .setTxDapi(apiInfoZ.getDapi())
 342                 .setExpectedSapi(apiInfoZ.getExpectedSapi())
 343                 .setExpectedDapi(apiInfoZ.getExpectedDapi());
 344         }
 345         // Create Interface1 type object required for adding as augmentation
 346         // TODO look at imports of different versions of class
 347         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
 348             oduIf1Builder = new
 349                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
 350         oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
 351
 352         // Post interface on the device
 353         this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
 354         if (!isCTP) {
 355             LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
 356             this.portMapping.updateMapping(nodeId, mapping);
 357         }
 358         return oduInterfaceBldr.getName();
 359     }
 360 }