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.equipment.states.types.rev171215.AdminStates;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.MediaChannelTrailTerminationPoint;
46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint;
47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel;
49 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
50 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
51 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
52 import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.mc.ttp.container.McTtpBuilder;
53 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.nmc.ctp.container.NmcCtpBuilder;
54 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.och.container.OchBuilder;
55 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
56 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
57 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUCTP;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
64 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
65 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
66 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.Opu;
67 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
68 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
69 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
70 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
71 import org.opendaylight.yangtools.yang.common.Uint32;
72 import org.slf4j.Logger;
73 import org.slf4j.LoggerFactory;
76 public class OpenRoadmInterface221 {
77 private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
78 "Unable to get mapping from PortMapping for node % and logical connection port %s";
79 private final PortMapping portMapping;
80 private final OpenRoadmInterfaces openRoadmInterfaces;
81 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
84 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
85 this.portMapping = portMapping;
86 this.openRoadmInterfaces = openRoadmInterfaces;
89 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
90 throws OpenRoadmInterfaceException {
91 Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
92 if (mapping == null) {
93 throw new OpenRoadmInterfaceException(
94 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
97 // Ethernet interface specific data
98 EthernetBuilder ethIfBuilder = new EthernetBuilder()
99 .setFec(EthAttributes.Fec.Off)
100 .setSpeed(Uint32.valueOf(100000));
102 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(mapping, EthernetCsmacd.class,
103 logicalConnPoint + "-ETHERNET");
104 // Create Interface1 type object required for adding as augmentation
105 Interface1Builder ethIf1Builder = new Interface1Builder();
106 ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
108 // Post interface on the device
109 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
111 // Post the equipment-state change on the device circuit-pack
112 openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
113 this.portMapping.updateMapping(nodeId, mapping);
114 return ethInterfaceBldr.getName();
117 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
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<>();
126 String mcInterfaceCreated = "";
127 if (logicalConnPoint.contains("DEG")) {
128 mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
129 interfacesCreated.add(mcInterfaceCreated);
131 String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation,
133 interfacesCreated.add(nmcInterfaceCreated);
134 return interfacesCreated;
137 public String createMCInterface(String nodeId, String logicalConnPoint,
138 SpectrumInformation spectrumInformation)
139 throws OpenRoadmInterfaceException {
140 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
141 if (portMap == null) {
142 throw new OpenRoadmInterfaceException(
143 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
145 // TODO : Check this method
146 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
147 spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
148 spectrumInformation.getCenterFrequency());
149 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
150 MediaChannelTrailTerminationPoint.class,
151 spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
152 .setSupportingInterface(portMap.getSupportingOms());
154 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
155 .setMinFreq(new FrequencyTHz(spectrumInformation.getMinFrequency()))
156 .setMaxFreq(new FrequencyTHz(spectrumInformation.getMaxFrequency()));
158 // Create Interface1 type object required for adding as augmentation
159 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
161 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
162 .setMcTtp(mcTtpBuilder.build());
164 mcInterfaceBldr.addAugmentation(interface1Builder.build());
166 // Post interface on the device
167 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
168 return mcInterfaceBldr.getName();
171 public String createNMCInterface(String nodeId, String logicalConnPoint,
172 SpectrumInformation spectrumInformation, String mcName)
173 throws OpenRoadmInterfaceException {
174 LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency());
175 LOG.info("This is the nmc width {}", spectrumInformation.getWidth());
176 // TODO : Check this method
177 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
178 if (portMap == null) {
179 throw new OpenRoadmInterfaceException(
180 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
182 //TODO : Check this method
183 String nmcName = spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc");
184 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
185 NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
186 if (logicalConnPoint.contains("DEG")) {
187 nmcInterfaceBldr.setSupportingInterface(mcName);
190 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
191 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
192 .setWidth(new FrequencyGHz(spectrumInformation.getWidth()));
194 // Create Interface1 type object required for adding as augmentation
195 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
197 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
198 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
199 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
200 // Post interface on the device
201 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
202 return nmcInterfaceBldr.getName();
205 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
206 SpectrumInformation spectrumInformation)
207 throws OpenRoadmInterfaceException {
208 // TODO : Check this method
209 ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
210 Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
211 .forName(spectrumInformation.getModulationFormat());
212 if (optionalModulationFormat.isPresent()) {
213 modulationFormat = optionalModulationFormat.get();
215 // OCH interface specific data
216 OchBuilder ocIfBuilder = new OchBuilder()
217 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
218 .setRate(R100G.class)
219 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
220 .setModulationFormat(modulationFormat);
221 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
222 if (portMap == null) {
223 throw new OpenRoadmInterfaceException(
224 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
225 nodeId, logicalConnPoint));
227 // Create generic interface
228 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
229 spectrumInformation.getIdentifierFromParams(logicalConnPoint));
230 // Create Interface1 type object required for adding as augmentation
231 // TODO look at imports of different versions of class
232 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
233 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
234 .Interface1Builder();
235 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
237 // Post interface on the device
238 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
240 // Post the equipment-state change on the device circuit-pack if xpdr node
241 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
242 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
245 return ochInterfaceBldr.getName();
248 public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
249 AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
250 Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
251 if (mapping == null) {
252 throw new OpenRoadmInterfaceException(
253 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
255 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
256 logicalConnPoint + "-ODU4");
257 if (mapping.getSupportingOtu4() != null) {
258 oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOtu4());
260 if (mapping.getSupportingEthernet() != null) {
261 oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
263 // ODU interface specific data
264 Class<? extends OduFunctionIdentity> oduFunction;
265 MonitoringMode monitoringMode;
268 oduFunction = ODUCTP.class;
269 monitoringMode = MonitoringMode.Monitored;
271 oduFunction = ODUTTP.class;
272 monitoringMode = MonitoringMode.Terminated;
273 opu = new OpuBuilder()
274 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
275 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
278 OduBuilder oduIfBuilder = new OduBuilder()
280 .setOduFunction(oduFunction)
281 .setMonitoringMode(monitoringMode)
283 if (apiInfoA != null) {
284 oduIfBuilder.setTxSapi(apiInfoA.getSapi())
285 .setTxDapi(apiInfoA.getDapi())
286 .setExpectedSapi(apiInfoA.getExpectedSapi())
287 .setExpectedDapi(apiInfoA.getExpectedDapi());
289 if (apiInfoZ != null) {
290 oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
291 .setTxDapi(apiInfoZ.getDapi())
292 .setExpectedSapi(apiInfoZ.getExpectedSapi())
293 .setExpectedDapi(apiInfoZ.getExpectedDapi());
295 // Create Interface1 type object required for adding as augmentation
296 // TODO look at imports of different versions of class
297 oduInterfaceBldr.addAugmentation(
298 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
299 .setOdu(oduIfBuilder.build())
302 // Post interface on the device
303 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
305 LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
306 this.portMapping.updateMapping(nodeId, mapping);
308 return oduInterfaceBldr.getName();
311 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
312 throws OpenRoadmInterfaceException {
313 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
314 if (portMap == null) {
315 throw new OpenRoadmInterfaceException(
316 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
317 nodeId, logicalConnPoint));
319 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
320 logicalConnPoint + "-ODU");
321 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
323 // ODU interface specific data
324 // Set Opu attributes
325 OpuBuilder opuBldr = new OpuBuilder()
326 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
327 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
328 OduBuilder oduIfBuilder = new OduBuilder()
330 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
331 .setOpu(opuBldr.build());
333 // Create Interface1 type object required for adding as augmentation
334 // TODO look at imports of different versions of class
335 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
336 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
337 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
339 // Post interface on the device
340 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
341 return oduInterfaceBldr.getName();
344 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
345 String znodeId, String zlogicalConnPoint)
346 throws OpenRoadmInterfaceException {
347 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
348 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
349 if (portMapA == null) {
350 throw new OpenRoadmInterfaceException(
351 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
353 if (portMapZ == null) {
354 throw new OpenRoadmInterfaceException(
355 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
357 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
358 alogicalConnPoint + "-ODU");
359 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
361 // ODU interface specific data
362 // Set Opu attributes
363 OpuBuilder opuBldr = new OpuBuilder()
364 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
365 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
366 OduBuilder oduIfBuilder = new OduBuilder()
368 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
369 .setOpu(opuBldr.build())
370 .setTxSapi(portMapA.getLcpHashVal())
371 .setTxDapi(portMapZ.getLcpHashVal())
372 // Setting the expected Dapi and Sapi values
373 .setExpectedDapi(portMapA.getLcpHashVal())
374 .setExpectedSapi(portMapZ.getLcpHashVal());
376 // Create Interface1 type object required for adding as augmentation
377 // TODO look at imports of different versions of class
378 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
379 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
380 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
382 // Post interface on the device
383 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
384 return oduInterfaceBldr.getName();
387 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface,
388 AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException {
390 Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
391 if (mapping == null) {
392 throw new OpenRoadmInterfaceException(
393 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
395 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOtu.class,
396 logicalConnPoint + "-OTU");
397 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
399 // OTU interface specific data
400 OtuBuilder otuIfBuilder = new OtuBuilder()
401 .setFec(OtuAttributes.Fec.Scfec)
402 .setRate(OTU4.class);
403 if (apiInfoA != null) {
404 otuIfBuilder.setTxSapi(apiInfoA.getSapi())
405 .setTxDapi(apiInfoA.getDapi())
406 .setExpectedSapi(apiInfoA.getExpectedSapi())
407 .setExpectedDapi(apiInfoA.getExpectedDapi());
409 if (apiInfoZ != null) {
410 otuIfBuilder.setTxSapi(apiInfoZ.getSapi())
411 .setTxDapi(apiInfoZ.getDapi())
412 .setExpectedSapi(apiInfoZ.getExpectedSapi())
413 .setExpectedDapi(apiInfoZ.getExpectedDapi());
416 // Create Interface1 type object required for adding as augmentation
417 // TODO look at imports of different versions of class
418 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
419 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
420 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
422 // Post interface on the device
423 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
424 this.portMapping.updateMapping(nodeId, mapping);
425 return otuInterfaceBldr.getName();
428 public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
429 return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
432 private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
434 return new InterfaceBuilder()
435 .setDescription(" TBD ")
436 .setCircuitId(" TBD ")
437 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
438 .setSupportingPort(portMap.getSupportingPort())
439 .setAdministrativeState(AdminStates.InService)
442 .withKey(new InterfaceKey(key));
445 public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
446 if (mapping.getSupportingOms() == null) {
447 // Create generic interface
448 InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class,
449 "OMS-" + mapping.getLogicalConnectionPoint());
450 if (mapping.getSupportingOts() != null) {
451 omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts());
453 LOG.error("Unable to get ots interface from mapping {} - {}", nodeId,
454 mapping.getLogicalConnectionPoint());
457 this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
458 this.portMapping.updateMapping(nodeId, mapping);
459 return omsInterfaceBldr.build().getName();
461 return mapping.getSupportingOms();
465 public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
466 if (mapping.getSupportingOts() == null) {
467 // Create generic interface
468 InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-"
469 + mapping.getLogicalConnectionPoint());
470 // OTS interface augmentation specific data
471 OtsBuilder otsIfBuilder = new OtsBuilder();
472 otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf);
474 // Create Interface1 type object required for adding as
476 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
477 otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
478 .rev181019.Interface1Builder();
479 otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
480 this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
481 this.portMapping.updateMapping(nodeId, mapping);
482 return otsInterfaceBldr.build().getName();
484 return mapping.getSupportingOts();
488 public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
489 DeviceTransactionManager deviceTransactionManager) {
490 InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
491 .child(RoadmConnections.class, new RoadmConnectionsKey(xc));
492 LOG.info("reading xc {} in node {}", xc, nodeId);
493 Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
494 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
495 if (crossconnection.isPresent()) {
496 RoadmConnections rc = crossconnection.get();
497 LOG.info("xd {} found", xc);
498 String supportedinter = null;
499 if (!interfaceName.contains("nmc")) {
500 supportedinter = interfaceName.replace("mc", "nmc");
502 if (rc.getSource().getSrcIf().equals(interfaceName)
503 || rc.getDestination().getDstIf().equals(interfaceName)
504 || rc.getSource().getSrcIf().equals(supportedinter)
505 || rc.getDestination().getDstIf().equals(supportedinter)) {
509 LOG.info("xd {} not found !", xc);
514 public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
515 DeviceTransactionManager deviceTransactionManager) {
516 InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
517 .child(OduConnection.class, new OduConnectionKey(xc));
518 LOG.info("reading xc {} in node {}", xc, nodeId);
519 Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
520 LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
521 if (oduConnectionOpt.isPresent()) {
522 OduConnection oduXc = oduConnectionOpt.get();
523 LOG.info("xc {} found", xc);
524 if (oduXc.getSource().getSrcIf().equals(interfaceName)
525 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
529 LOG.info("xc {} not found !", xc);
534 public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
535 throws OpenRoadmInterfaceException {
536 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
537 if (portMap == null) {
538 throw new OpenRoadmInterfaceException(
539 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
541 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
542 logicalConnPoint + "-ODU4");
543 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
545 // ODU interface specific data
546 OduBuilder oduIfBuilder = new OduBuilder()
548 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
550 // Set Opu attributes
551 OpuBuilder opuBldr = new OpuBuilder()
552 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
553 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
554 oduIfBuilder.setOduFunction(ODUTTP.class)
555 .setOpu(opuBldr.build());
557 // Create Interface1 type object required for adding as augmentation
558 // TODO look at imports of different versions of class
559 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
560 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
561 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
563 // Post interface on the device
564 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
565 this.portMapping.updateMapping(nodeId, portMap);
566 return oduInterfaceBldr.getName();
569 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
570 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
571 throws OpenRoadmInterfaceException {
572 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
573 if (portMapA == null) {
574 throw new OpenRoadmInterfaceException(
575 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
577 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
578 if (portMapZ == null) {
579 throw new OpenRoadmInterfaceException(
580 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
582 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
583 alogicalConnPoint + "-ODU4");
584 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
586 // ODU interface specific data
587 OduBuilder oduIfBuilder = new OduBuilder()
589 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
590 .setTxSapi(portMapA.getLcpHashVal())
591 .setTxDapi(portMapZ.getLcpHashVal())
592 .setExpectedSapi(portMapZ.getLcpHashVal())
593 .setExpectedDapi(portMapA.getLcpHashVal());
596 // Set Opu attributes
597 OpuBuilder opuBldr = new OpuBuilder()
598 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
599 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
600 oduIfBuilder.setOduFunction(ODUTTP.class)
601 .setOpu(opuBldr.build());
603 // Create Interface1 type object required for adding as augmentation
604 // TODO look at imports of different versions of class
605 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
606 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
607 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
609 // Post interface on the device
610 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
611 this.portMapping.updateMapping(anodeId, portMapA);
612 return oduInterfaceBldr.getName();