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.device.renderer.rev211004.az.api.info.AEndApiInfo;
25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo;
26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220114.mapping.Mapping;
27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz;
29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm;
31 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.R100G;
32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection;
36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.MediaChannelTrailTerminationPoint;
47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint;
48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
49 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel;
50 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
51 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
52 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
53 import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.mc.ttp.container.McTtpBuilder;
54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.nmc.ctp.container.NmcCtpBuilder;
55 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.och.container.OchBuilder;
56 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
57 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUCTP;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTPCTP;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
64 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
65 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
66 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
67 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
68 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.Opu;
69 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
70 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
71 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
72 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
73 import org.opendaylight.yangtools.yang.common.Uint32;
74 import org.slf4j.Logger;
75 import org.slf4j.LoggerFactory;
78 public class OpenRoadmInterface221 {
79 private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
80 "Unable to get mapping from PortMapping for node % and logical connection port %s";
81 private final PortMapping portMapping;
82 private final OpenRoadmInterfaces openRoadmInterfaces;
83 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
86 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
87 this.portMapping = portMapping;
88 this.openRoadmInterfaces = openRoadmInterfaces;
91 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
92 throws OpenRoadmInterfaceException {
93 Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
94 if (mapping == null) {
95 throw new OpenRoadmInterfaceException(
96 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
99 // Ethernet interface specific data
100 EthernetBuilder ethIfBuilder = new EthernetBuilder()
101 .setFec(EthAttributes.Fec.Off)
102 .setSpeed(Uint32.valueOf(100000));
104 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(mapping, EthernetCsmacd.class,
105 logicalConnPoint + "-ETHERNET");
106 // Create Interface1 type object required for adding as augmentation
107 Interface1Builder ethIf1Builder = new Interface1Builder();
108 ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
110 // Post interface on the device
111 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
113 // Post the equipment-state change on the device circuit-pack
114 openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
115 this.portMapping.updateMapping(nodeId, mapping);
116 return ethInterfaceBldr.getName();
119 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
120 throws OpenRoadmInterfaceException {
121 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
122 if (portMap == null) {
123 throw new OpenRoadmInterfaceException(
124 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
127 List<String> interfacesCreated = new ArrayList<>();
128 String mcInterfaceCreated = "";
129 if (logicalConnPoint.contains("DEG")) {
130 mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
131 interfacesCreated.add(mcInterfaceCreated);
133 String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation,
135 interfacesCreated.add(nmcInterfaceCreated);
136 return interfacesCreated;
139 public String createMCInterface(String nodeId, String logicalConnPoint,
140 SpectrumInformation spectrumInformation)
141 throws OpenRoadmInterfaceException {
142 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
143 if (portMap == null) {
144 throw new OpenRoadmInterfaceException(
145 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
147 // TODO : Check this method
148 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
149 spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
150 spectrumInformation.getCenterFrequency());
151 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
152 MediaChannelTrailTerminationPoint.class,
153 spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
154 .setSupportingInterface(portMap.getSupportingOms());
156 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
157 .setMinFreq(new FrequencyTHz(spectrumInformation.getMinFrequency()))
158 .setMaxFreq(new FrequencyTHz(spectrumInformation.getMaxFrequency()));
160 // Create Interface1 type object required for adding as augmentation
161 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
163 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
164 .setMcTtp(mcTtpBuilder.build());
166 mcInterfaceBldr.addAugmentation(interface1Builder.build());
168 // Post interface on the device
169 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
170 return mcInterfaceBldr.getName();
173 public String createNMCInterface(String nodeId, String logicalConnPoint,
174 SpectrumInformation spectrumInformation, String mcName)
175 throws OpenRoadmInterfaceException {
176 LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency());
177 LOG.info("This is the nmc width {}", spectrumInformation.getWidth());
178 // TODO : Check this method
179 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
180 if (portMap == null) {
181 throw new OpenRoadmInterfaceException(
182 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
184 //TODO : Check this method
185 String nmcName = spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc");
186 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
187 NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
188 if (logicalConnPoint.contains("DEG")) {
189 nmcInterfaceBldr.setSupportingInterface(mcName);
192 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
193 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
194 .setWidth(new FrequencyGHz(spectrumInformation.getWidth()));
196 // Create Interface1 type object required for adding as augmentation
197 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
199 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
200 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
201 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
202 // Post interface on the device
203 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
204 return nmcInterfaceBldr.getName();
207 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
208 SpectrumInformation spectrumInformation)
209 throws OpenRoadmInterfaceException {
210 // TODO : Check this method
211 ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
212 Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
213 .forName(spectrumInformation.getModulationFormat());
214 if (optionalModulationFormat.isPresent()) {
215 modulationFormat = optionalModulationFormat.get();
217 // OCH interface specific data
218 OchBuilder ocIfBuilder = new OchBuilder()
219 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
220 .setRate(R100G.class)
221 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
222 .setModulationFormat(modulationFormat);
223 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
224 if (portMap == null) {
225 throw new OpenRoadmInterfaceException(
226 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
227 nodeId, logicalConnPoint));
229 // Create generic interface
230 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
231 spectrumInformation.getIdentifierFromParams(logicalConnPoint));
232 // Create Interface1 type object required for adding as augmentation
233 // TODO look at imports of different versions of class
234 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
235 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
236 .Interface1Builder();
237 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
239 // Post interface on the device
240 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
242 // Post the equipment-state change on the device circuit-pack if xpdr node
243 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
244 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
247 return ochInterfaceBldr.getName();
250 public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
251 AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
252 Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
253 if (mapping == null) {
254 throw new OpenRoadmInterfaceException(
255 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
258 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
259 logicalConnPoint + "-ODU4");
260 if (mapping.getSupportingOtu4() != null) {
261 oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOtu4());
263 if (mapping.getSupportingEthernet() != null) {
264 oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
266 // ODU interface specific data
267 Class<? extends OduFunctionIdentity> oduFunction;
268 MonitoringMode monitoringMode;
271 oduFunction = ODUCTP.class;
272 monitoringMode = MonitoringMode.Monitored;
274 // For TPDR it can be both CTP and TTP
275 if (mapping.getXponderType() == XpdrNodeTypes.Tpdr) {
276 oduFunction = ODUTTPCTP.class;
277 // For switch-ponder we still use TTP
279 oduFunction = ODUTTP.class;
281 monitoringMode = MonitoringMode.Terminated;
282 opu = new OpuBuilder()
283 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
284 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
287 OduBuilder oduIfBuilder = new OduBuilder()
289 .setOduFunction(oduFunction)
290 .setMonitoringMode(monitoringMode)
292 if (apiInfoA != null) {
293 oduIfBuilder.setTxSapi(apiInfoA.getSapi())
294 .setTxDapi(apiInfoA.getDapi())
295 .setExpectedSapi(apiInfoA.getExpectedSapi())
296 .setExpectedDapi(apiInfoA.getExpectedDapi());
298 if (apiInfoZ != null) {
299 oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
300 .setTxDapi(apiInfoZ.getDapi())
301 .setExpectedSapi(apiInfoZ.getExpectedSapi())
302 .setExpectedDapi(apiInfoZ.getExpectedDapi());
304 // Create Interface1 type object required for adding as augmentation
305 // TODO look at imports of different versions of class
306 oduInterfaceBldr.addAugmentation(
307 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
308 .setOdu(oduIfBuilder.build())
311 // Post interface on the device
312 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
314 LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
315 this.portMapping.updateMapping(nodeId, mapping);
317 return oduInterfaceBldr.getName();
320 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
321 throws OpenRoadmInterfaceException {
322 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
323 if (portMap == null) {
324 throw new OpenRoadmInterfaceException(
325 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
326 nodeId, logicalConnPoint));
328 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
329 logicalConnPoint + "-ODU");
330 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
332 // ODU interface specific data
333 // Set Opu attributes
334 OpuBuilder opuBldr = new OpuBuilder()
335 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
336 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
337 OduBuilder oduIfBuilder = new OduBuilder()
339 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
340 .setOpu(opuBldr.build());
342 // Create Interface1 type object required for adding as augmentation
343 // TODO look at imports of different versions of class
344 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
345 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
346 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
348 // Post interface on the device
349 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
350 return oduInterfaceBldr.getName();
353 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
354 String znodeId, String zlogicalConnPoint)
355 throws OpenRoadmInterfaceException {
356 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
357 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
358 if (portMapA == null) {
359 throw new OpenRoadmInterfaceException(
360 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
362 if (portMapZ == null) {
363 throw new OpenRoadmInterfaceException(
364 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
366 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
367 alogicalConnPoint + "-ODU");
368 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
370 // ODU interface specific data
371 // Set Opu attributes
372 OpuBuilder opuBldr = new OpuBuilder()
373 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
374 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
375 OduBuilder oduIfBuilder = new OduBuilder()
377 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
378 .setOpu(opuBldr.build())
379 .setTxSapi(portMapA.getLcpHashVal())
380 .setTxDapi(portMapZ.getLcpHashVal())
381 // Setting the expected Dapi and Sapi values
382 .setExpectedDapi(portMapA.getLcpHashVal())
383 .setExpectedSapi(portMapZ.getLcpHashVal());
385 // Create Interface1 type object required for adding as augmentation
386 // TODO look at imports of different versions of class
387 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
388 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
389 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
391 // Post interface on the device
392 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
393 return oduInterfaceBldr.getName();
396 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface,
397 AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException {
399 Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
400 if (mapping == null) {
401 throw new OpenRoadmInterfaceException(
402 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
404 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOtu.class,
405 logicalConnPoint + "-OTU");
406 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
408 // OTU interface specific data
409 OtuBuilder otuIfBuilder = new OtuBuilder()
410 .setFec(OtuAttributes.Fec.Scfec)
411 .setRate(OTU4.class);
412 if (apiInfoA != null) {
413 otuIfBuilder.setTxSapi(apiInfoA.getSapi())
414 .setTxDapi(apiInfoA.getDapi())
415 .setExpectedSapi(apiInfoA.getExpectedSapi())
416 .setExpectedDapi(apiInfoA.getExpectedDapi());
418 if (apiInfoZ != null) {
419 otuIfBuilder.setTxSapi(apiInfoZ.getSapi())
420 .setTxDapi(apiInfoZ.getDapi())
421 .setExpectedSapi(apiInfoZ.getExpectedSapi())
422 .setExpectedDapi(apiInfoZ.getExpectedDapi());
425 // Create Interface1 type object required for adding as augmentation
426 // TODO look at imports of different versions of class
427 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
428 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
429 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
431 // Post interface on the device
432 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
433 this.portMapping.updateMapping(nodeId, mapping);
434 return otuInterfaceBldr.getName();
437 public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
438 return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
441 private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
443 return new InterfaceBuilder()
444 .setDescription(" TBD ")
445 .setCircuitId(" TBD ")
446 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
447 .setSupportingPort(portMap.getSupportingPort())
448 .setAdministrativeState(AdminStates.InService)
451 .withKey(new InterfaceKey(key));
454 public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
455 if (mapping.getSupportingOms() == null) {
456 // Create generic interface
457 InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class,
458 "OMS-" + mapping.getLogicalConnectionPoint());
459 if (mapping.getSupportingOts() != null) {
460 omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts());
462 LOG.error("Unable to get ots interface from mapping {} - {}", nodeId,
463 mapping.getLogicalConnectionPoint());
466 this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
467 this.portMapping.updateMapping(nodeId, mapping);
468 return omsInterfaceBldr.build().getName();
470 return mapping.getSupportingOms();
474 public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
475 if (mapping.getSupportingOts() == null) {
476 // Create generic interface
477 InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-"
478 + mapping.getLogicalConnectionPoint());
479 // OTS interface augmentation specific data
480 OtsBuilder otsIfBuilder = new OtsBuilder();
481 otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf);
483 // Create Interface1 type object required for adding as
485 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
486 otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
487 .rev181019.Interface1Builder();
488 otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
489 this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
490 this.portMapping.updateMapping(nodeId, mapping);
491 return otsInterfaceBldr.build().getName();
493 return mapping.getSupportingOts();
497 public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
498 DeviceTransactionManager deviceTransactionManager) {
499 InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
500 .child(RoadmConnections.class, new RoadmConnectionsKey(xc));
501 LOG.info("reading xc {} in node {}", xc, nodeId);
502 Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
503 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
504 if (crossconnection.isPresent()) {
505 RoadmConnections rc = crossconnection.get();
506 LOG.info("xd {} found", xc);
507 String supportedinter = null;
508 if (!interfaceName.contains("nmc")) {
509 supportedinter = interfaceName.replace("mc", "nmc");
511 if (rc.getSource().getSrcIf().equals(interfaceName)
512 || rc.getDestination().getDstIf().equals(interfaceName)
513 || rc.getSource().getSrcIf().equals(supportedinter)
514 || rc.getDestination().getDstIf().equals(supportedinter)) {
518 LOG.info("xd {} not found !", xc);
523 public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
524 DeviceTransactionManager deviceTransactionManager) {
525 InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
526 .child(OduConnection.class, new OduConnectionKey(xc));
527 LOG.info("reading xc {} in node {}", xc, nodeId);
528 Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
529 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
530 if (oduConnectionOpt.isPresent()) {
531 OduConnection oduXc = oduConnectionOpt.get();
532 LOG.info("xc {} found", xc);
533 if (oduXc.getSource().getSrcIf().equals(interfaceName)
534 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
538 LOG.info("xc {} not found !", xc);
543 public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
544 throws OpenRoadmInterfaceException {
545 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
546 if (portMap == null) {
547 throw new OpenRoadmInterfaceException(
548 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
550 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
551 logicalConnPoint + "-ODU4");
552 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
554 // ODU interface specific data
555 OduBuilder oduIfBuilder = new OduBuilder()
557 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
559 // Set Opu attributes
560 OpuBuilder opuBldr = new OpuBuilder()
561 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
562 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
563 oduIfBuilder.setOduFunction(ODUTTP.class)
564 .setOpu(opuBldr.build());
566 // Create Interface1 type object required for adding as augmentation
567 // TODO look at imports of different versions of class
568 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
569 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
570 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
572 // Post interface on the device
573 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
574 this.portMapping.updateMapping(nodeId, portMap);
575 return oduInterfaceBldr.getName();
578 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
579 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
580 throws OpenRoadmInterfaceException {
581 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
582 if (portMapA == null) {
583 throw new OpenRoadmInterfaceException(
584 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
586 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
587 if (portMapZ == null) {
588 throw new OpenRoadmInterfaceException(
589 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
591 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
592 alogicalConnPoint + "-ODU4");
593 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
595 // ODU interface specific data
596 OduBuilder oduIfBuilder = new OduBuilder()
598 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
599 .setTxSapi(portMapA.getLcpHashVal())
600 .setTxDapi(portMapZ.getLcpHashVal())
601 .setExpectedSapi(portMapZ.getLcpHashVal())
602 .setExpectedDapi(portMapA.getLcpHashVal());
605 // Set Opu attributes
606 OpuBuilder opuBldr = new OpuBuilder()
607 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
608 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
609 oduIfBuilder.setOduFunction(ODUTTP.class)
610 .setOpu(opuBldr.build());
612 // Create Interface1 type object required for adding as augmentation
613 // TODO look at imports of different versions of class
614 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
615 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
616 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
618 // Post interface on the device
619 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
620 this.portMapping.updateMapping(anodeId, portMapA);
621 return oduInterfaceBldr.getName();