2 * Copyright © 2017 AT&T and others. All rights reserved.
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
9 package org.opendaylight.transportpce.renderer.openroadminterface;
11 import java.math.BigDecimal;
12 import java.util.ArrayList;
13 import java.util.List;
14 import java.util.Optional;
15 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
16 import org.opendaylight.transportpce.common.StringConstants;
17 import org.opendaylight.transportpce.common.Timeouts;
18 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
19 import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface;
20 import org.opendaylight.transportpce.common.fixedflex.FlexGridInterface;
21 import org.opendaylight.transportpce.common.mapping.PortMapping;
22 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
23 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.Mapping;
25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz;
27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm;
29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.R100G;
30 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection;
34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
37 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
38 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
39 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.MediaChannelTrailTerminationPoint;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint;
46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel;
48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
49 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
50 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
51 import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.mc.ttp.container.McTtpBuilder;
52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.nmc.ctp.container.NmcCtpBuilder;
53 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.och.container.OchBuilder;
54 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
55 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
56 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
57 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
64 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
65 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
66 import org.opendaylight.yangtools.yang.common.Uint32;
67 import org.slf4j.Logger;
68 import org.slf4j.LoggerFactory;
70 public class OpenRoadmInterface221 {
71 private final PortMapping portMapping;
72 private final OpenRoadmInterfaces openRoadmInterfaces;
73 private FixedFlexInterface fixedFlex;
74 private FlexGridInterface flexGrid;
75 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
78 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces,
79 FixedFlexInterface fixedFlex, FlexGridInterface flexGrid) {
80 this.portMapping = portMapping;
81 this.openRoadmInterfaces = openRoadmInterfaces;
82 this.fixedFlex = fixedFlex;
83 this.flexGrid = flexGrid;
86 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
87 throws OpenRoadmInterfaceException {
88 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
89 if (portMap == null) {
90 throw new OpenRoadmInterfaceException(
91 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
92 nodeId, logicalConnPoint));
95 // Ethernet interface specific data
96 EthernetBuilder ethIfBuilder = new EthernetBuilder()
97 .setFec(EthAttributes.Fec.Off)
98 .setSpeed(Uint32.valueOf(100000));
100 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
101 logicalConnPoint + "-ETHERNET");
102 // Create Interface1 type object required for adding as augmentation
103 Interface1Builder ethIf1Builder = new Interface1Builder();
104 ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
106 // Post interface on the device
107 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
109 // Post the equipment-state change on the device circuit-pack
110 openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
112 return ethInterfaceBldr.getName();
115 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long bitmapIndex,
116 BigDecimal centerFreq, BigDecimal slotWidth)
117 throws OpenRoadmInterfaceException {
118 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
119 if (portMap == null) {
120 throw new OpenRoadmInterfaceException(
121 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
122 nodeId, logicalConnPoint));
125 List<String> interfacesCreated = new ArrayList<>();
127 if (logicalConnPoint.contains("DEG")) {
128 String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, centerFreq, slotWidth, bitmapIndex);
129 interfacesCreated.add(mcInterfaceCreated);
131 String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, centerFreq, slotWidth, bitmapIndex);
132 interfacesCreated.add(mcInterfaceCreated);
133 return interfacesCreated;
137 * This methods creates an OCH interface on the given termination point on
140 * @param nodeId node ID
141 * @param logicalConnPoint logical connection point
142 * @param waveNumber wavelength number of the OCH interface.
144 * @return Name of the interface if successful, otherwise return null.
146 * @throws OpenRoadmInterfaceException OpenRoadm interface exception
149 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long waveNumber)
150 throws OpenRoadmInterfaceException {
151 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
152 if (portMap == null) {
153 throw new OpenRoadmInterfaceException(
154 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
155 nodeId, logicalConnPoint));
158 List<String> interfacesCreated = new ArrayList<>();
160 if (logicalConnPoint.contains("DEG")) {
161 String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber);
162 interfacesCreated.add(mcInterfaceCreated);
164 String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, waveNumber);
165 interfacesCreated.add(nmcInterfaceCreated);
166 return interfacesCreated;
170 public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
171 throws OpenRoadmInterfaceException {
173 // TODO : Check this method
175 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
177 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
178 if (portMap == null) {
179 throw new OpenRoadmInterfaceException(
180 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
181 nodeId, logicalConnPoint));
184 // TODO : Check this method
186 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
187 MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + waveNumber)
188 .setSupportingInterface(portMap.getSupportingOms());
190 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
191 .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStart())))
192 .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStop())));
194 // Create Interface1 type object required for adding as augmentation
195 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
197 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
198 .setMcTtp(mcTtpBuilder.build());
200 mcInterfaceBldr.addAugmentation(
201 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1.class,
202 interface1Builder.build());
204 // Post interface on the device
205 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
206 return mcInterfaceBldr.getName();
209 public String createMCInterface(String nodeId, String logicalConnPoint,
210 BigDecimal centerFrequency, BigDecimal slotWidth, Long bitmapIndex)
211 throws OpenRoadmInterfaceException {
213 // TODO : Check this method
215 flexGrid = flexGrid.getFlexWaveMapping(centerFrequency.floatValue(), slotWidth.floatValue());
217 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
218 if (portMap == null) {
219 throw new OpenRoadmInterfaceException(
220 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
221 nodeId, logicalConnPoint));
224 // TODO : Check this method
225 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
226 flexGrid.getStart(), flexGrid.getStop(), centerFrequency);
227 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
228 MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + bitmapIndex)
229 .setSupportingInterface(portMap.getSupportingOms());
231 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
232 .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStart())))
233 .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStop())));
235 // Create Interface1 type object required for adding as augmentation
236 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
238 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
239 .setMcTtp(mcTtpBuilder.build());
241 mcInterfaceBldr.addAugmentation(
242 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1.class,
243 interface1Builder.build());
245 // Post interface on the device
246 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
247 return mcInterfaceBldr.getName();
250 public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
251 throws OpenRoadmInterfaceException {
253 // TODO : Check this method
254 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
256 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
257 if (portMap == null) {
258 throw new OpenRoadmInterfaceException(
259 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
260 nodeId, logicalConnPoint));
262 LOG.info("Freq Start {} and Freq End {} and center-Freq {}",
263 fixedFlex.getStart(), fixedFlex.getStop(), fixedFlex.getCenterFrequency());
264 //TODO : Check this method
265 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
266 NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + waveNumber);
267 if (logicalConnPoint.contains("DEG")) {
268 nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + waveNumber);
271 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
272 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
273 .setWidth(FrequencyGHz.getDefaultInstance("40"));
275 // Create Interface1 type object required for adding as augmentation
276 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
278 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
279 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
280 nmcInterfaceBldr.addAugmentation(
281 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1.class,
282 nmcCtpI1fBuilder.build());
284 // Post interface on the device
285 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
286 return nmcInterfaceBldr.getName();
289 public String createNMCInterface(String nodeId, String logicalConnPoint,
290 BigDecimal centerFrequency, BigDecimal slotWidth, Long bitmapIndex)
291 throws OpenRoadmInterfaceException {
292 LOG.info("This is the central frequency {}", centerFrequency.floatValue());
293 LOG.info("This is the slot-width {}", slotWidth.floatValue());
294 // TODO : Check this method
295 flexGrid = flexGrid.getFlexWaveMapping(centerFrequency.floatValue(), slotWidth.floatValue());
296 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
297 if (portMap == null) {
298 throw new OpenRoadmInterfaceException(
299 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
300 nodeId, logicalConnPoint));
303 LOG.info("Freq Start {} and Freq End {} and center-Freq {}", flexGrid.getStart(),
304 flexGrid.getStop(),centerFrequency);
305 //TODO : Check this method
306 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
307 NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + bitmapIndex);
308 if (logicalConnPoint.contains("DEG")) {
309 nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + bitmapIndex);
311 NmcCtpBuilder nmcCtpIfBuilder;
313 // From the logicalConnPoint, get the substring and for that associated substring find the mc-cap
315 if (logicalConnPoint.contains("-PP")) {
316 mcLcp = logicalConnPoint.substring(0, logicalConnPoint.indexOf("-")) + "-PP";
318 else if (logicalConnPoint.contains("-TTP")) {
319 mcLcp = logicalConnPoint.substring(0, logicalConnPoint.indexOf("-")) + "-TTP";
322 double slotWidthGran = portMapping.getMcCapbilities(nodeId, mcLcp)
323 .getSlotWidthGranularity().getValue().doubleValue();
325 // Dead-band is constant (Ref: WP)
326 double deadBand = 8; // In GHz
327 double guardBand = Math.ceil(deadBand / slotWidthGran) * slotWidthGran;
329 nmcCtpIfBuilder = new NmcCtpBuilder()
330 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
331 .setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(slotWidth.doubleValue() - guardBand)));
333 // Create Interface1 type object required for adding as augmentation
334 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
336 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
337 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
338 nmcInterfaceBldr.addAugmentation(
339 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
340 .Interface1.class, nmcCtpI1fBuilder.build());
342 // Post interface on the device
343 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
346 catch (NullPointerException e) {
347 LOG.error("Port mapping could not find {}", mcLcp);
348 LOG.error("Check the port mapping to verify {}", mcLcp);
350 return nmcInterfaceBldr.getName();
353 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
354 throws OpenRoadmInterfaceException {
355 // TODO : Check this method
357 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
359 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
360 if (portMap == null) {
361 throw new OpenRoadmInterfaceException(
362 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
363 nodeId, logicalConnPoint));
366 // OCH interface specific data
367 OchBuilder ocIfBuilder = new OchBuilder()
368 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
369 .setRate(R100G.class)
370 // TODO: Check if this the correct way to set modulation format here
371 .setModulationFormat(ModulationFormat.DpQpsk)
372 .setTransmitPower(new PowerDBm(new BigDecimal("-5")));
374 // Create generic interface
375 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
376 createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
377 // Create Interface1 type object required for adding as augmentation
378 // TODO look at imports of different versions of class
379 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
380 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
381 .Interface1Builder();
382 ochInterfaceBldr.addAugmentation(
383 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1.class,
384 ochIf1Builder.setOch(ocIfBuilder.build()).build());
386 // Post interface on the device
387 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
389 // Post the equipment-state change on the device circuit-pack if xpdr node
390 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
391 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
394 return ochInterfaceBldr.getName();
397 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
398 Long waveNumber, BigDecimal centerFrequency, BigDecimal slotWidth)
399 throws OpenRoadmInterfaceException {
400 // TODO : Check this method
402 // OCH interface specific data
403 OchBuilder ocIfBuilder = new OchBuilder()
404 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
405 .setRate(R100G.class)
406 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
407 .setModulationFormat(ModulationFormat.DpQpsk);
409 // In Flex-grid, slot-width could be other than 50 GHz
410 if ((centerFrequency != null) && (slotWidth != null)) {
411 ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)));
412 ocIfBuilder.setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(slotWidth)));
415 // Use fixed grid to find the
416 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
417 ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())));
419 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
420 if (portMap == null) {
421 throw new OpenRoadmInterfaceException(
422 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
423 nodeId, logicalConnPoint));
428 // Create generic interface
429 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
430 createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
431 // Create Interface1 type object required for adding as augmentation
432 // TODO look at imports of different versions of class
433 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
434 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
435 .Interface1Builder();
436 ochInterfaceBldr.addAugmentation(
437 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1.class,
438 ochIf1Builder.setOch(ocIfBuilder.build()).build());
440 // Post interface on the device
441 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
443 // Post the equipment-state change on the device circuit-pack if xpdr node
444 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
445 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
448 return ochInterfaceBldr.getName();
451 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
452 throws OpenRoadmInterfaceException {
453 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
454 if (portMap == null) {
455 throw new OpenRoadmInterfaceException(
456 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
457 nodeId, logicalConnPoint));
459 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
460 logicalConnPoint + "-ODU");
461 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
463 // ODU interface specific data
464 // Set Opu attributes
465 OpuBuilder opuBldr = new OpuBuilder()
466 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
467 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
468 OduBuilder oduIfBuilder = new OduBuilder()
470 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
471 .setOpu(opuBldr.build());
473 // Create Interface1 type object required for adding as augmentation
474 // TODO look at imports of different versions of class
475 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
476 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
477 oduInterfaceBldr.addAugmentation(
478 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
479 oduIf1Builder.setOdu(oduIfBuilder.build()).build());
481 // Post interface on the device
482 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
483 return oduInterfaceBldr.getName();
486 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
487 String znodeId, String zlogicalConnPoint)
488 throws OpenRoadmInterfaceException {
489 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
490 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
491 if (portMapA == null) {
492 throw new OpenRoadmInterfaceException(
493 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
494 anodeId, alogicalConnPoint));
496 if (portMapZ == null) {
497 throw new OpenRoadmInterfaceException(
498 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
499 znodeId, zlogicalConnPoint));
501 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
502 alogicalConnPoint + "-ODU");
503 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
505 // ODU interface specific data
506 // Set Opu attributes
507 OpuBuilder opuBldr = new OpuBuilder()
508 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
509 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
510 OduBuilder oduIfBuilder = new OduBuilder()
512 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
513 .setOpu(opuBldr.build())
514 .setTxSapi(portMapA.getLcpHashVal())
515 .setTxDapi(portMapZ.getLcpHashVal())
516 .setExpectedDapi(portMapA.getLcpHashVal()) // Setting the expected Dapi and Sapi values
517 .setExpectedSapi(portMapZ.getLcpHashVal());
519 // Create Interface1 type object required for adding as augmentation
520 // TODO look at imports of different versions of class
521 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
522 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
523 oduInterfaceBldr.addAugmentation(
524 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
525 oduIf1Builder.setOdu(oduIfBuilder.build()).build());
527 // Post interface on the device
528 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
529 return oduInterfaceBldr.getName();
532 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
533 throws OpenRoadmInterfaceException {
534 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
535 if (portMap == null) {
536 throw new OpenRoadmInterfaceException(
537 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
538 nodeId, logicalConnPoint));
540 // Create generic interface
541 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class,
542 logicalConnPoint + "-OTU");
543 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
545 // OTU interface specific data
546 OtuBuilder otuIfBuilder = new OtuBuilder();
547 otuIfBuilder.setFec(OtuAttributes.Fec.Scfec);
548 otuIfBuilder.setRate(OTU4.class);
550 // Create Interface1 type object required for adding as augmentation
551 // TODO look at imports of different versions of class
552 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
553 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
554 otuInterfaceBldr.addAugmentation(
555 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
556 otuIf1Builder.setOtu(otuIfBuilder.build()).build());
558 // Post interface on the device
559 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
560 return otuInterfaceBldr.getName();
563 public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
564 String znodeId, String zlogicalConnPoint)
565 throws OpenRoadmInterfaceException {
566 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
567 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
568 if (portMapA == null) {
569 throw new OpenRoadmInterfaceException(
570 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
571 anodeId, alogicalConnPoint));
574 if (portMapZ == null) {
575 throw new OpenRoadmInterfaceException(
576 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
577 znodeId, zlogicalConnPoint));
580 // Create generic interface builder
581 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
582 alogicalConnPoint + "-OTU");
584 // Set the supporting interface data
585 otuInterfaceBldr.setSupportingInterface(asupportOchInterface);
587 // OTU interface specific data
588 OtuBuilder otuIfBuilder = new OtuBuilder()
589 .setFec(OtuAttributes.Fec.Scfec)
591 .setTxSapi(portMapA.getLcpHashVal())
592 .setTxDapi(portMapZ.getLcpHashVal())
593 .setExpectedDapi(portMapA.getLcpHashVal()) // setting expected SAPI and DAPI values
594 .setExpectedSapi(portMapZ.getLcpHashVal());
596 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
597 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
599 otuInterfaceBldr.addAugmentation(
600 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
601 otuIf1Builder.setOtu(otuIfBuilder.build()).build());
603 // Post interface on the device
604 openRoadmInterfaces.postInterface(anodeId, otuInterfaceBldr);
605 return otuInterfaceBldr.getName();
609 public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
610 return logicalConnectionPoint + "-" + waveNumber;
613 private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
615 InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
616 .setDescription(" TBD ")
617 .setCircuitId(" TBD ")
618 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
619 .setSupportingPort(portMap.getSupportingPort())
620 .setAdministrativeState(AdminStates.InService)
623 .withKey(new InterfaceKey(key));
624 return interfaceBuilder;
627 public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
628 if (mapping.getSupportingOms() == null) {
629 // Create generic interface
630 InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class,
631 "OMS-" + mapping.getLogicalConnectionPoint());
632 if (mapping.getSupportingOts() != null) {
633 omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts());
635 LOG.error("Unable to get ots interface from mapping {} - {}", nodeId,
636 mapping.getLogicalConnectionPoint());
639 this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
640 this.portMapping.updateMapping(nodeId, mapping);
641 return omsInterfaceBldr.build().getName();
643 return mapping.getSupportingOms();
647 public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
648 if (mapping.getSupportingOts() == null) {
649 // Create generic interface
650 InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-"
651 + mapping.getLogicalConnectionPoint());
652 // OTS interface augmentation specific data
653 OtsBuilder otsIfBuilder = new OtsBuilder();
654 otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf);
656 // Create Interface1 type object required for adding as
658 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
659 otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
660 .rev181019.Interface1Builder();
661 otsInterfaceBldr.addAugmentation(
662 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1.class,
663 otsIf1Builder.setOts(otsIfBuilder.build()).build());
664 this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
665 this.portMapping.updateMapping(nodeId, mapping);
666 return otsInterfaceBldr.build().getName();
668 return mapping.getSupportingOts();
672 public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
673 DeviceTransactionManager deviceTransactionManager) {
674 InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
675 .child(RoadmConnections.class, new RoadmConnectionsKey(xc));
676 LOG.info("reading xc {} in node {}", xc, nodeId);
677 Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
678 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
679 if (crossconnection.isPresent()) {
680 RoadmConnections rc = crossconnection.get();
681 LOG.info("xd {} found", xc);
682 String supportedinter = null;
683 if (!interfaceName.contains("nmc")) {
684 supportedinter = interfaceName.replace("mc", "nmc");
686 if (rc.getSource().getSrcIf().equals(interfaceName)
687 || rc.getDestination().getDstIf().equals(interfaceName)
688 || rc.getSource().getSrcIf().equals(supportedinter)
689 || rc.getDestination().getDstIf().equals(supportedinter)) {
693 LOG.info("xd {} not found !", xc);
698 public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
699 DeviceTransactionManager deviceTransactionManager) {
700 InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
701 .child(OduConnection.class, new OduConnectionKey(xc));
702 LOG.info("reading xc {} in node {}", xc, nodeId);
703 Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
704 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
705 if (oduConnectionOpt.isPresent()) {
706 OduConnection oduXc = oduConnectionOpt.get();
707 LOG.info("xc {} found", xc);
708 if (oduXc.getSource().getSrcIf().equals(interfaceName)
709 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
713 LOG.info("xc {} not found !", xc);
718 public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
719 throws OpenRoadmInterfaceException {
720 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
721 if (portMap == null) {
722 throw new OpenRoadmInterfaceException(
723 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
724 nodeId, logicalConnPoint));
726 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
727 logicalConnPoint + "-ODU4");
728 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
730 // ODU interface specific data
731 OduBuilder oduIfBuilder = new OduBuilder()
733 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
735 // Set Opu attributes
736 OpuBuilder opuBldr = new OpuBuilder()
737 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
738 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
739 oduIfBuilder.setOduFunction(ODUTTP.class)
740 .setOpu(opuBldr.build());
742 // Create Interface1 type object required for adding as augmentation
743 // TODO look at imports of different versions of class
744 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
745 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
746 oduInterfaceBldr.addAugmentation(
747 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
748 oduIf1Builder.setOdu(oduIfBuilder.build()).build());
750 // Post interface on the device
751 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
754 } catch (InterruptedException e) {
755 LOG.error("Error waiting post interface on device", e);
757 this.portMapping.updateMapping(nodeId, portMap);
758 return oduInterfaceBldr.getName();
761 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
762 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
763 throws OpenRoadmInterfaceException {
764 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
765 if (portMapA == null) {
766 throw new OpenRoadmInterfaceException(
767 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
768 anodeId, alogicalConnPoint));
770 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
771 if (portMapZ == null) {
772 throw new OpenRoadmInterfaceException(
773 String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
774 znodeId, zlogicalConnPoint));
776 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
777 alogicalConnPoint + "-ODU4");
778 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
780 // ODU interface specific data
781 OduBuilder oduIfBuilder = new OduBuilder()
783 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
784 .setTxSapi(portMapA.getLcpHashVal())
785 .setTxDapi(portMapZ.getLcpHashVal())
786 .setExpectedSapi(portMapZ.getLcpHashVal())
787 .setExpectedDapi(portMapA.getLcpHashVal());
790 // Set Opu attributes
791 OpuBuilder opuBldr = new OpuBuilder()
792 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
793 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
794 oduIfBuilder.setOduFunction(ODUTTP.class)
795 .setOpu(opuBldr.build());
797 // Create Interface1 type object required for adding as augmentation
798 // TODO look at imports of different versions of class
799 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
800 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
801 oduInterfaceBldr.addAugmentation(
802 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
803 oduIf1Builder.setOdu(oduIfBuilder.build()).build());
805 // Post interface on the device
806 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
809 } catch (InterruptedException e) {
810 LOG.error("Error waiting post interface on device", e);
812 this.portMapping.updateMapping(anodeId, portMapA);
813 return oduInterfaceBldr.getName();