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.GridConstant;
20 import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
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.rev210310.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.Interface1Builder;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.MediaChannelTrailTerminationPoint;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel;
47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
49 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
50 import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.mc.ttp.container.McTtpBuilder;
51 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.nmc.ctp.container.NmcCtpBuilder;
52 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.och.container.OchBuilder;
53 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
54 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
55 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
56 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
57 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
64 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
65 import org.opendaylight.yangtools.yang.common.Uint32;
66 import org.slf4j.Logger;
67 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 static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
78 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
79 this.portMapping = portMapping;
80 this.openRoadmInterfaces = openRoadmInterfaces;
83 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
84 throws OpenRoadmInterfaceException {
85 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
86 if (portMap == null) {
87 throw new OpenRoadmInterfaceException(
88 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
91 // Ethernet interface specific data
92 EthernetBuilder ethIfBuilder = new EthernetBuilder()
93 .setFec(EthAttributes.Fec.Off)
94 .setSpeed(Uint32.valueOf(100000));
96 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
97 logicalConnPoint + "-ETHERNET");
98 // Create Interface1 type object required for adding as augmentation
99 Interface1Builder ethIf1Builder = new Interface1Builder();
100 ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
102 // Post interface on the device
103 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
105 // Post the equipment-state change on the device circuit-pack
106 openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
108 return ethInterfaceBldr.getName();
111 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
112 throws OpenRoadmInterfaceException {
113 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
114 if (portMap == null) {
115 throw new OpenRoadmInterfaceException(
116 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
119 List<String> interfacesCreated = new ArrayList<>();
121 if (logicalConnPoint.contains("DEG")) {
122 String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
123 interfacesCreated.add(mcInterfaceCreated);
125 String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation);
126 interfacesCreated.add(mcInterfaceCreated);
127 return interfacesCreated;
130 public String createMCInterface(String nodeId, String logicalConnPoint,
131 SpectrumInformation spectrumInformation)
132 throws OpenRoadmInterfaceException {
133 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
134 if (portMap == null) {
135 throw new OpenRoadmInterfaceException(
136 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
138 // TODO : Check this method
139 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
140 spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
141 spectrumInformation.getCenterFrequency());
142 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
143 MediaChannelTrailTerminationPoint.class,
144 spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
145 .setSupportingInterface(portMap.getSupportingOms());
147 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
148 .setMinFreq(new FrequencyTHz(spectrumInformation.getMinFrequency()))
149 .setMaxFreq(new FrequencyTHz(spectrumInformation.getMaxFrequency()));
151 // Create Interface1 type object required for adding as augmentation
152 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
154 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
155 .setMcTtp(mcTtpBuilder.build());
157 mcInterfaceBldr.addAugmentation(interface1Builder.build());
159 // Post interface on the device
160 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
161 return mcInterfaceBldr.getName();
164 public String createNMCInterface(String nodeId, String logicalConnPoint,
165 SpectrumInformation spectrumInformation)
166 throws OpenRoadmInterfaceException {
167 LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency());
168 LOG.info("This is the nmc width {}", spectrumInformation.getWidth());
169 // TODO : Check this method
170 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
171 if (portMap == null) {
172 throw new OpenRoadmInterfaceException(
173 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
175 //TODO : Check this method
176 String nmcName = spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc");
177 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
178 NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
179 if (logicalConnPoint.contains("DEG")) {
180 nmcInterfaceBldr.setSupportingInterface(nmcName);
183 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
184 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
185 .setWidth(new FrequencyGHz(spectrumInformation.getWidth()));
187 // Create Interface1 type object required for adding as augmentation
188 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
190 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
191 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
192 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
193 // Post interface on the device
194 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
195 return nmcInterfaceBldr.getName();
198 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
199 SpectrumInformation spectrumInformation)
200 throws OpenRoadmInterfaceException {
201 // TODO : Check this method
202 ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
203 Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
204 .forName(spectrumInformation.getModulationFormat());
205 if (optionalModulationFormat.isPresent()) {
206 modulationFormat = optionalModulationFormat.get();
208 // OCH interface specific data
209 OchBuilder ocIfBuilder = new OchBuilder()
210 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
211 .setRate(R100G.class)
212 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
213 .setModulationFormat(modulationFormat);
214 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
215 if (portMap == null) {
216 throw new OpenRoadmInterfaceException(
217 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
218 nodeId, logicalConnPoint));
220 // Create generic interface
221 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
222 spectrumInformation.getIdentifierFromParams(logicalConnPoint));
223 // Create Interface1 type object required for adding as augmentation
224 // TODO look at imports of different versions of class
225 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
226 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
227 .Interface1Builder();
228 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
230 // Post interface on the device
231 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
233 // Post the equipment-state change on the device circuit-pack if xpdr node
234 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
235 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
238 return ochInterfaceBldr.getName();
241 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
242 throws OpenRoadmInterfaceException {
243 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
244 if (portMap == null) {
245 throw new OpenRoadmInterfaceException(
246 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
247 nodeId, logicalConnPoint));
249 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
250 logicalConnPoint + "-ODU");
251 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
253 // ODU interface specific data
254 // Set Opu attributes
255 OpuBuilder opuBldr = new OpuBuilder()
256 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
257 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
258 OduBuilder oduIfBuilder = new OduBuilder()
260 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
261 .setOpu(opuBldr.build());
263 // Create Interface1 type object required for adding as augmentation
264 // TODO look at imports of different versions of class
265 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
266 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
267 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
269 // Post interface on the device
270 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
271 return oduInterfaceBldr.getName();
274 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
275 String znodeId, String zlogicalConnPoint)
276 throws OpenRoadmInterfaceException {
277 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
278 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
279 if (portMapA == null) {
280 throw new OpenRoadmInterfaceException(
281 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
283 if (portMapZ == null) {
284 throw new OpenRoadmInterfaceException(
285 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
287 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
288 alogicalConnPoint + "-ODU");
289 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
291 // ODU interface specific data
292 // Set Opu attributes
293 OpuBuilder opuBldr = new OpuBuilder()
294 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
295 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
296 OduBuilder oduIfBuilder = new OduBuilder()
298 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
299 .setOpu(opuBldr.build())
300 .setTxSapi(portMapA.getLcpHashVal())
301 .setTxDapi(portMapZ.getLcpHashVal())
302 // Setting the expected Dapi and Sapi values
303 .setExpectedDapi(portMapA.getLcpHashVal())
304 .setExpectedSapi(portMapZ.getLcpHashVal());
306 // Create Interface1 type object required for adding as augmentation
307 // TODO look at imports of different versions of class
308 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
309 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
310 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
312 // Post interface on the device
313 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
314 return oduInterfaceBldr.getName();
317 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
318 throws OpenRoadmInterfaceException {
319 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
320 if (portMap == null) {
321 throw new OpenRoadmInterfaceException(
322 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
323 nodeId, logicalConnPoint));
325 // Create generic interface
326 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class,
327 logicalConnPoint + "-OTU");
328 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
330 // OTU interface specific data
331 OtuBuilder otuIfBuilder = new OtuBuilder();
332 otuIfBuilder.setFec(OtuAttributes.Fec.Scfec);
333 otuIfBuilder.setRate(OTU4.class);
335 // Create Interface1 type object required for adding as augmentation
336 // TODO look at imports of different versions of class
337 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
338 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
339 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
341 // Post interface on the device
342 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
343 return otuInterfaceBldr.getName();
346 public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
347 String znodeId, String zlogicalConnPoint)
348 throws OpenRoadmInterfaceException {
349 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
350 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
351 if (portMapA == null) {
352 throw new OpenRoadmInterfaceException(
353 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
354 anodeId, alogicalConnPoint));
357 if (portMapZ == null) {
358 throw new OpenRoadmInterfaceException(
359 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
360 znodeId, zlogicalConnPoint));
363 // Create generic interface builder
364 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
365 alogicalConnPoint + "-OTU");
367 // Set the supporting interface data
368 otuInterfaceBldr.setSupportingInterface(asupportOchInterface);
370 // OTU interface specific data
371 OtuBuilder otuIfBuilder = new OtuBuilder()
372 .setFec(OtuAttributes.Fec.Scfec)
374 .setTxSapi(portMapA.getLcpHashVal())
375 .setTxDapi(portMapZ.getLcpHashVal())
376 // setting expected SAPI and DAPI values
377 .setExpectedDapi(portMapA.getLcpHashVal())
378 .setExpectedSapi(portMapZ.getLcpHashVal());
380 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
381 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
383 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
385 // Post interface on the device
386 openRoadmInterfaces.postInterface(anodeId, otuInterfaceBldr);
387 return otuInterfaceBldr.getName();
391 public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
392 return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
395 private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
397 return new InterfaceBuilder()
398 .setDescription(" TBD ")
399 .setCircuitId(" TBD ")
400 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
401 .setSupportingPort(portMap.getSupportingPort())
402 .setAdministrativeState(AdminStates.InService)
405 .withKey(new InterfaceKey(key));
408 public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
409 if (mapping.getSupportingOms() == null) {
410 // Create generic interface
411 InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class,
412 "OMS-" + mapping.getLogicalConnectionPoint());
413 if (mapping.getSupportingOts() != null) {
414 omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts());
416 LOG.error("Unable to get ots interface from mapping {} - {}", nodeId,
417 mapping.getLogicalConnectionPoint());
420 this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
421 this.portMapping.updateMapping(nodeId, mapping);
422 return omsInterfaceBldr.build().getName();
424 return mapping.getSupportingOms();
428 public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
429 if (mapping.getSupportingOts() == null) {
430 // Create generic interface
431 InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-"
432 + mapping.getLogicalConnectionPoint());
433 // OTS interface augmentation specific data
434 OtsBuilder otsIfBuilder = new OtsBuilder();
435 otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf);
437 // Create Interface1 type object required for adding as
439 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
440 otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
441 .rev181019.Interface1Builder();
442 otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
443 this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
444 this.portMapping.updateMapping(nodeId, mapping);
445 return otsInterfaceBldr.build().getName();
447 return mapping.getSupportingOts();
451 public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
452 DeviceTransactionManager deviceTransactionManager) {
453 InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
454 .child(RoadmConnections.class, new RoadmConnectionsKey(xc));
455 LOG.info("reading xc {} in node {}", xc, nodeId);
456 Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
457 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
458 if (crossconnection.isPresent()) {
459 RoadmConnections rc = crossconnection.get();
460 LOG.info("xd {} found", xc);
461 String supportedinter = null;
462 if (!interfaceName.contains("nmc")) {
463 supportedinter = interfaceName.replace("mc", "nmc");
465 if (rc.getSource().getSrcIf().equals(interfaceName)
466 || rc.getDestination().getDstIf().equals(interfaceName)
467 || rc.getSource().getSrcIf().equals(supportedinter)
468 || rc.getDestination().getDstIf().equals(supportedinter)) {
472 LOG.info("xd {} not found !", xc);
477 public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
478 DeviceTransactionManager deviceTransactionManager) {
479 InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
480 .child(OduConnection.class, new OduConnectionKey(xc));
481 LOG.info("reading xc {} in node {}", xc, nodeId);
482 Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
483 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
484 if (oduConnectionOpt.isPresent()) {
485 OduConnection oduXc = oduConnectionOpt.get();
486 LOG.info("xc {} found", xc);
487 if (oduXc.getSource().getSrcIf().equals(interfaceName)
488 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
492 LOG.info("xc {} not found !", xc);
497 public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
498 throws OpenRoadmInterfaceException {
499 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
500 if (portMap == null) {
501 throw new OpenRoadmInterfaceException(
502 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
504 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
505 logicalConnPoint + "-ODU4");
506 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
508 // ODU interface specific data
509 OduBuilder oduIfBuilder = new OduBuilder()
511 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
513 // Set Opu attributes
514 OpuBuilder opuBldr = new OpuBuilder()
515 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
516 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
517 oduIfBuilder.setOduFunction(ODUTTP.class)
518 .setOpu(opuBldr.build());
520 // Create Interface1 type object required for adding as augmentation
521 // TODO look at imports of different versions of class
522 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
523 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
524 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
526 // Post interface on the device
527 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
530 } catch (InterruptedException e) {
531 LOG.error("Error waiting post interface on device", e);
533 this.portMapping.updateMapping(nodeId, portMap);
534 return oduInterfaceBldr.getName();
537 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
538 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
539 throws OpenRoadmInterfaceException {
540 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
541 if (portMapA == null) {
542 throw new OpenRoadmInterfaceException(
543 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
545 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
546 if (portMapZ == null) {
547 throw new OpenRoadmInterfaceException(
548 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
550 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
551 alogicalConnPoint + "-ODU4");
552 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
554 // ODU interface specific data
555 OduBuilder oduIfBuilder = new OduBuilder()
557 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
558 .setTxSapi(portMapA.getLcpHashVal())
559 .setTxDapi(portMapZ.getLcpHashVal())
560 .setExpectedSapi(portMapZ.getLcpHashVal())
561 .setExpectedDapi(portMapA.getLcpHashVal());
564 // Set Opu attributes
565 OpuBuilder opuBldr = new OpuBuilder()
566 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
567 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
568 oduIfBuilder.setOduFunction(ODUTTP.class)
569 .setOpu(opuBldr.build());
571 // Create Interface1 type object required for adding as augmentation
572 // TODO look at imports of different versions of class
573 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
574 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
575 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
577 // Post interface on the device
578 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
581 } catch (InterruptedException e) {
582 LOG.error("Error waiting post interface on device", e);
584 this.portMapping.updateMapping(anodeId, portMapA);
585 return oduInterfaceBldr.getName();