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.fixedflex.GridConstant;
22 import org.opendaylight.transportpce.common.mapping.PortMapping;
23 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
24 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping;
26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz;
28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm;
30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.R100G;
31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection;
35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
38 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
39 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
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 static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
72 "Unable to get mapping from PortMapping for node % and logical connection port %s";
73 private final PortMapping portMapping;
74 private final OpenRoadmInterfaces openRoadmInterfaces;
75 private FixedFlexInterface fixedFlex;
76 private FlexGridInterface flexGrid;
77 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
80 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces,
81 FixedFlexInterface fixedFlex, FlexGridInterface flexGrid) {
82 this.portMapping = portMapping;
83 this.openRoadmInterfaces = openRoadmInterfaces;
84 this.fixedFlex = fixedFlex;
85 this.flexGrid = flexGrid;
88 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
89 throws OpenRoadmInterfaceException {
90 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
91 if (portMap == null) {
92 throw new OpenRoadmInterfaceException(
93 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
96 // Ethernet interface specific data
97 EthernetBuilder ethIfBuilder = new EthernetBuilder()
98 .setFec(EthAttributes.Fec.Off)
99 .setSpeed(Uint32.valueOf(100000));
101 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
102 logicalConnPoint + "-ETHERNET");
103 // Create Interface1 type object required for adding as augmentation
104 Interface1Builder ethIf1Builder = new Interface1Builder();
105 ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
107 // Post interface on the device
108 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
110 // Post the equipment-state change on the device circuit-pack
111 openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
113 return ethInterfaceBldr.getName();
116 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long bitmapIndex,
117 BigDecimal centerFreq, BigDecimal width)
118 throws OpenRoadmInterfaceException {
119 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
120 if (portMap == null) {
121 throw new OpenRoadmInterfaceException(
122 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
125 List<String> interfacesCreated = new ArrayList<>();
127 if (logicalConnPoint.contains("DEG")) {
128 String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, centerFreq, width, bitmapIndex);
129 interfacesCreated.add(mcInterfaceCreated);
131 String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, centerFreq, width, 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(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
157 List<String> interfacesCreated = new ArrayList<>();
159 if (logicalConnPoint.contains("DEG")) {
160 String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber);
161 interfacesCreated.add(mcInterfaceCreated);
163 String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, waveNumber);
164 interfacesCreated.add(nmcInterfaceCreated);
165 return interfacesCreated;
169 public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
170 throws OpenRoadmInterfaceException {
172 // TODO : Check this method
174 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
176 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
177 if (portMap == null) {
178 throw new OpenRoadmInterfaceException(
179 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
182 // TODO : Check this method
184 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
185 MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + waveNumber)
186 .setSupportingInterface(portMap.getSupportingOms());
188 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
189 .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStart())))
190 .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStop())));
192 // Create Interface1 type object required for adding as augmentation
193 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
195 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
196 .setMcTtp(mcTtpBuilder.build());
198 mcInterfaceBldr.addAugmentation(interface1Builder.build());
200 // Post interface on the device
201 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
202 return mcInterfaceBldr.getName();
205 public String createMCInterface(String nodeId, String logicalConnPoint,
206 BigDecimal centerFrequency, BigDecimal width, Long bitmapIndex)
207 throws OpenRoadmInterfaceException {
209 // TODO : Check this method
210 flexGrid = flexGrid.getFlexWaveMapping(centerFrequency.floatValue(),
211 GridConstant.WIDTH_SLOT_WIDTH_MAP.get(width).floatValue());
213 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
214 if (portMap == null) {
215 throw new OpenRoadmInterfaceException(
216 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
219 // TODO : Check this method
220 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
221 flexGrid.getStart(), flexGrid.getStop(), centerFrequency);
222 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
223 MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + bitmapIndex)
224 .setSupportingInterface(portMap.getSupportingOms());
226 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
227 .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStart())))
228 .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStop())));
230 // Create Interface1 type object required for adding as augmentation
231 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
233 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
234 .setMcTtp(mcTtpBuilder.build());
236 mcInterfaceBldr.addAugmentation(interface1Builder.build());
238 // Post interface on the device
239 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
240 return mcInterfaceBldr.getName();
243 public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
244 throws OpenRoadmInterfaceException {
246 // TODO : Check this method
247 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
249 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
250 if (portMap == null) {
251 throw new OpenRoadmInterfaceException(
252 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
254 LOG.info("Freq Start {} and Freq End {} and center-Freq {}",
255 fixedFlex.getStart(), fixedFlex.getStop(), fixedFlex.getCenterFrequency());
256 //TODO : Check this method
257 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
258 NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + waveNumber);
259 if (logicalConnPoint.contains("DEG")) {
260 nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + waveNumber);
263 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
264 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
265 .setWidth(FrequencyGHz.getDefaultInstance("40"));
267 // Create Interface1 type object required for adding as augmentation
268 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
270 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
271 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
272 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
274 // Post interface on the device
275 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
276 return nmcInterfaceBldr.getName();
279 public String createNMCInterface(String nodeId, String logicalConnPoint,
280 BigDecimal centerFrequency, BigDecimal width, Long bitmapIndex)
281 throws OpenRoadmInterfaceException {
282 LOG.info("This is the central frequency {}", centerFrequency.floatValue());
283 LOG.info("This is the nmc width {}", width.floatValue());
284 // TODO : Check this method
285 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
286 if (portMap == null) {
287 throw new OpenRoadmInterfaceException(
288 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
291 //TODO : Check this method
292 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
293 NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + bitmapIndex);
294 if (logicalConnPoint.contains("DEG")) {
295 nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + bitmapIndex);
298 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
299 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
300 .setWidth(new FrequencyGHz(width));
302 // Create Interface1 type object required for adding as augmentation
303 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
305 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
306 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
307 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
308 // Post interface on the device
309 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
310 return nmcInterfaceBldr.getName();
313 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
314 throws OpenRoadmInterfaceException {
315 // TODO : Check this method
317 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
319 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
320 if (portMap == null) {
321 throw new OpenRoadmInterfaceException(
322 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
325 // OCH interface specific data
326 OchBuilder ocIfBuilder = new OchBuilder()
327 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
328 .setRate(R100G.class)
329 // TODO: Check if this the correct way to set modulation format here
330 .setModulationFormat(ModulationFormat.DpQpsk)
331 .setTransmitPower(new PowerDBm(new BigDecimal("-5")));
333 // Create generic interface
334 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
335 createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
336 // Create Interface1 type object required for adding as augmentation
337 // TODO look at imports of different versions of class
338 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
339 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
340 .Interface1Builder();
341 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
343 // Post interface on the device
344 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
346 // Post the equipment-state change on the device circuit-pack if xpdr node
347 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
348 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
351 return ochInterfaceBldr.getName();
354 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
355 Long waveNumber, BigDecimal centerFrequency, BigDecimal slotWidth)
356 throws OpenRoadmInterfaceException {
357 // TODO : Check this method
359 // OCH interface specific data
360 OchBuilder ocIfBuilder = new OchBuilder()
361 .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
362 .setRate(R100G.class)
363 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
364 .setModulationFormat(ModulationFormat.DpQpsk);
366 // In Flex-grid, slot-width could be other than 50 GHz
367 if ((centerFrequency != null) && (slotWidth != null)) {
368 ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)));
369 ocIfBuilder.setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(slotWidth)));
372 // Use fixed grid to find the
373 fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
374 ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())));
376 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
377 if (portMap == null) {
378 throw new OpenRoadmInterfaceException(
379 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
380 nodeId, logicalConnPoint));
385 // Create generic interface
386 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
387 createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
388 // Create Interface1 type object required for adding as augmentation
389 // TODO look at imports of different versions of class
390 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
391 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
392 .Interface1Builder();
393 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
395 // Post interface on the device
396 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
398 // Post the equipment-state change on the device circuit-pack if xpdr node
399 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
400 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
403 return ochInterfaceBldr.getName();
406 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
407 throws OpenRoadmInterfaceException {
408 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
409 if (portMap == null) {
410 throw new OpenRoadmInterfaceException(
411 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
412 nodeId, logicalConnPoint));
414 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
415 logicalConnPoint + "-ODU");
416 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
418 // ODU interface specific data
419 // Set Opu attributes
420 OpuBuilder opuBldr = new OpuBuilder()
421 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
422 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
423 OduBuilder oduIfBuilder = new OduBuilder()
425 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
426 .setOpu(opuBldr.build());
428 // Create Interface1 type object required for adding as augmentation
429 // TODO look at imports of different versions of class
430 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
431 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
432 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
434 // Post interface on the device
435 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
436 return oduInterfaceBldr.getName();
439 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
440 String znodeId, String zlogicalConnPoint)
441 throws OpenRoadmInterfaceException {
442 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
443 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
444 if (portMapA == null) {
445 throw new OpenRoadmInterfaceException(
446 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
448 if (portMapZ == null) {
449 throw new OpenRoadmInterfaceException(
450 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
452 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
453 alogicalConnPoint + "-ODU");
454 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
456 // ODU interface specific data
457 // Set Opu attributes
458 OpuBuilder opuBldr = new OpuBuilder()
459 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
460 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
461 OduBuilder oduIfBuilder = new OduBuilder()
463 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
464 .setOpu(opuBldr.build())
465 .setTxSapi(portMapA.getLcpHashVal())
466 .setTxDapi(portMapZ.getLcpHashVal())
467 // Setting the expected Dapi and Sapi values
468 .setExpectedDapi(portMapA.getLcpHashVal())
469 .setExpectedSapi(portMapZ.getLcpHashVal());
471 // Create Interface1 type object required for adding as augmentation
472 // TODO look at imports of different versions of class
473 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
474 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
475 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
477 // Post interface on the device
478 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
479 return oduInterfaceBldr.getName();
482 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
483 throws OpenRoadmInterfaceException {
484 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
485 if (portMap == null) {
486 throw new OpenRoadmInterfaceException(
487 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
488 nodeId, logicalConnPoint));
490 // Create generic interface
491 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class,
492 logicalConnPoint + "-OTU");
493 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
495 // OTU interface specific data
496 OtuBuilder otuIfBuilder = new OtuBuilder();
497 otuIfBuilder.setFec(OtuAttributes.Fec.Scfec);
498 otuIfBuilder.setRate(OTU4.class);
500 // Create Interface1 type object required for adding as augmentation
501 // TODO look at imports of different versions of class
502 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
503 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
504 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
506 // Post interface on the device
507 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
508 return otuInterfaceBldr.getName();
511 public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
512 String znodeId, String zlogicalConnPoint)
513 throws OpenRoadmInterfaceException {
514 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
515 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
516 if (portMapA == null) {
517 throw new OpenRoadmInterfaceException(
518 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
519 anodeId, alogicalConnPoint));
522 if (portMapZ == null) {
523 throw new OpenRoadmInterfaceException(
524 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
525 znodeId, zlogicalConnPoint));
528 // Create generic interface builder
529 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
530 alogicalConnPoint + "-OTU");
532 // Set the supporting interface data
533 otuInterfaceBldr.setSupportingInterface(asupportOchInterface);
535 // OTU interface specific data
536 OtuBuilder otuIfBuilder = new OtuBuilder()
537 .setFec(OtuAttributes.Fec.Scfec)
539 .setTxSapi(portMapA.getLcpHashVal())
540 .setTxDapi(portMapZ.getLcpHashVal())
541 // setting expected SAPI and DAPI values
542 .setExpectedDapi(portMapA.getLcpHashVal())
543 .setExpectedSapi(portMapZ.getLcpHashVal());
545 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
546 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
548 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
550 // Post interface on the device
551 openRoadmInterfaces.postInterface(anodeId, otuInterfaceBldr);
552 return otuInterfaceBldr.getName();
556 public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
557 return logicalConnectionPoint + "-" + waveNumber;
560 private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
562 return new InterfaceBuilder()
563 .setDescription(" TBD ")
564 .setCircuitId(" TBD ")
565 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
566 .setSupportingPort(portMap.getSupportingPort())
567 .setAdministrativeState(AdminStates.InService)
570 .withKey(new InterfaceKey(key));
573 public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
574 if (mapping.getSupportingOms() == null) {
575 // Create generic interface
576 InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class,
577 "OMS-" + mapping.getLogicalConnectionPoint());
578 if (mapping.getSupportingOts() != null) {
579 omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts());
581 LOG.error("Unable to get ots interface from mapping {} - {}", nodeId,
582 mapping.getLogicalConnectionPoint());
585 this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
586 this.portMapping.updateMapping(nodeId, mapping);
587 return omsInterfaceBldr.build().getName();
589 return mapping.getSupportingOms();
593 public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
594 if (mapping.getSupportingOts() == null) {
595 // Create generic interface
596 InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-"
597 + mapping.getLogicalConnectionPoint());
598 // OTS interface augmentation specific data
599 OtsBuilder otsIfBuilder = new OtsBuilder();
600 otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf);
602 // Create Interface1 type object required for adding as
604 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
605 otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
606 .rev181019.Interface1Builder();
607 otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
608 this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
609 this.portMapping.updateMapping(nodeId, mapping);
610 return otsInterfaceBldr.build().getName();
612 return mapping.getSupportingOts();
616 public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
617 DeviceTransactionManager deviceTransactionManager) {
618 InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
619 .child(RoadmConnections.class, new RoadmConnectionsKey(xc));
620 LOG.info("reading xc {} in node {}", xc, nodeId);
621 Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
622 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
623 if (crossconnection.isPresent()) {
624 RoadmConnections rc = crossconnection.get();
625 LOG.info("xd {} found", xc);
626 String supportedinter = null;
627 if (!interfaceName.contains("nmc")) {
628 supportedinter = interfaceName.replace("mc", "nmc");
630 if (rc.getSource().getSrcIf().equals(interfaceName)
631 || rc.getDestination().getDstIf().equals(interfaceName)
632 || rc.getSource().getSrcIf().equals(supportedinter)
633 || rc.getDestination().getDstIf().equals(supportedinter)) {
637 LOG.info("xd {} not found !", xc);
642 public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
643 DeviceTransactionManager deviceTransactionManager) {
644 InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
645 .child(OduConnection.class, new OduConnectionKey(xc));
646 LOG.info("reading xc {} in node {}", xc, nodeId);
647 Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
648 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
649 if (oduConnectionOpt.isPresent()) {
650 OduConnection oduXc = oduConnectionOpt.get();
651 LOG.info("xc {} found", xc);
652 if (oduXc.getSource().getSrcIf().equals(interfaceName)
653 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
657 LOG.info("xc {} not found !", xc);
662 public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
663 throws OpenRoadmInterfaceException {
664 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
665 if (portMap == null) {
666 throw new OpenRoadmInterfaceException(
667 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
669 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
670 logicalConnPoint + "-ODU4");
671 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
673 // ODU interface specific data
674 OduBuilder oduIfBuilder = new OduBuilder()
676 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
678 // Set Opu attributes
679 OpuBuilder opuBldr = new OpuBuilder()
680 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
681 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
682 oduIfBuilder.setOduFunction(ODUTTP.class)
683 .setOpu(opuBldr.build());
685 // Create Interface1 type object required for adding as augmentation
686 // TODO look at imports of different versions of class
687 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
688 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
689 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
691 // Post interface on the device
692 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
695 } catch (InterruptedException e) {
696 LOG.error("Error waiting post interface on device", e);
698 this.portMapping.updateMapping(nodeId, portMap);
699 return oduInterfaceBldr.getName();
702 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
703 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
704 throws OpenRoadmInterfaceException {
705 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
706 if (portMapA == null) {
707 throw new OpenRoadmInterfaceException(
708 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
710 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
711 if (portMapZ == null) {
712 throw new OpenRoadmInterfaceException(
713 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
715 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
716 alogicalConnPoint + "-ODU4");
717 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
719 // ODU interface specific data
720 OduBuilder oduIfBuilder = new OduBuilder()
722 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
723 .setTxSapi(portMapA.getLcpHashVal())
724 .setTxDapi(portMapZ.getLcpHashVal())
725 .setExpectedSapi(portMapZ.getLcpHashVal())
726 .setExpectedDapi(portMapA.getLcpHashVal());
729 // Set Opu attributes
730 OpuBuilder opuBldr = new OpuBuilder()
731 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
732 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
733 oduIfBuilder.setOduFunction(ODUTTP.class)
734 .setOpu(opuBldr.build());
736 // Create Interface1 type object required for adding as augmentation
737 // TODO look at imports of different versions of class
738 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
739 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
740 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
742 // Post interface on the device
743 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
746 } catch (InterruptedException e) {
747 LOG.error("Error waiting post interface on device", e);
749 this.portMapping.updateMapping(anodeId, portMapA);
750 return oduInterfaceBldr.getName();