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.rev210426.mapping.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.ODUCTP;
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.ODUTTPCTP;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
64 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
65 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
66 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
67 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
68 import org.opendaylight.yangtools.yang.common.Uint32;
69 import org.slf4j.Logger;
70 import org.slf4j.LoggerFactory;
73 public class OpenRoadmInterface221 {
74 private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
75 "Unable to get mapping from PortMapping for node % and logical connection port %s";
76 private final PortMapping portMapping;
77 private final OpenRoadmInterfaces openRoadmInterfaces;
78 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
81 public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
82 this.portMapping = portMapping;
83 this.openRoadmInterfaces = openRoadmInterfaces;
86 public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
87 throws OpenRoadmInterfaceException {
88 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
89 if (portMap == null) {
90 throw new OpenRoadmInterfaceException(
91 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
94 // Ethernet interface specific data
95 EthernetBuilder ethIfBuilder = new EthernetBuilder()
96 .setFec(EthAttributes.Fec.Off)
97 .setSpeed(Uint32.valueOf(100000));
99 InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
100 logicalConnPoint + "-ETHERNET");
101 // Create Interface1 type object required for adding as augmentation
102 Interface1Builder ethIf1Builder = new Interface1Builder();
103 ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
105 // Post interface on the device
106 openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
108 // Post the equipment-state change on the device circuit-pack
109 openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
111 return ethInterfaceBldr.getName();
114 public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
115 throws OpenRoadmInterfaceException {
116 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
117 if (portMap == null) {
118 throw new OpenRoadmInterfaceException(
119 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
122 List<String> interfacesCreated = new ArrayList<>();
123 String mcInterfaceCreated = "";
124 if (logicalConnPoint.contains("DEG")) {
125 mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
126 interfacesCreated.add(mcInterfaceCreated);
128 String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation,
130 interfacesCreated.add(nmcInterfaceCreated);
131 return interfacesCreated;
134 public String createMCInterface(String nodeId, String logicalConnPoint,
135 SpectrumInformation spectrumInformation)
136 throws OpenRoadmInterfaceException {
137 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
138 if (portMap == null) {
139 throw new OpenRoadmInterfaceException(
140 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
142 // TODO : Check this method
143 LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
144 spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
145 spectrumInformation.getCenterFrequency());
146 InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
147 MediaChannelTrailTerminationPoint.class,
148 spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
149 .setSupportingInterface(portMap.getSupportingOms());
151 McTtpBuilder mcTtpBuilder = new McTtpBuilder()
152 .setMinFreq(new FrequencyTHz(spectrumInformation.getMinFrequency()))
153 .setMaxFreq(new FrequencyTHz(spectrumInformation.getMaxFrequency()));
155 // Create Interface1 type object required for adding as augmentation
156 org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
158 new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
159 .setMcTtp(mcTtpBuilder.build());
161 mcInterfaceBldr.addAugmentation(interface1Builder.build());
163 // Post interface on the device
164 openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
165 return mcInterfaceBldr.getName();
168 public String createNMCInterface(String nodeId, String logicalConnPoint,
169 SpectrumInformation spectrumInformation, String mcName)
170 throws OpenRoadmInterfaceException {
171 LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency());
172 LOG.info("This is the nmc width {}", spectrumInformation.getWidth());
173 // TODO : Check this method
174 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
175 if (portMap == null) {
176 throw new OpenRoadmInterfaceException(
177 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
179 //TODO : Check this method
180 String nmcName = spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc");
181 InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
182 NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
183 if (logicalConnPoint.contains("DEG")) {
184 nmcInterfaceBldr.setSupportingInterface(mcName);
187 NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
188 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
189 .setWidth(new FrequencyGHz(spectrumInformation.getWidth()));
191 // Create Interface1 type object required for adding as augmentation
192 org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
194 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
195 .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
196 nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
197 // Post interface on the device
198 openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
199 return nmcInterfaceBldr.getName();
202 public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
203 SpectrumInformation spectrumInformation)
204 throws OpenRoadmInterfaceException {
205 // TODO : Check this method
206 ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
207 Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
208 .forName(spectrumInformation.getModulationFormat());
209 if (optionalModulationFormat.isPresent()) {
210 modulationFormat = optionalModulationFormat.get();
212 // OCH interface specific data
213 OchBuilder ocIfBuilder = new OchBuilder()
214 .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
215 .setRate(R100G.class)
216 .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
217 .setModulationFormat(modulationFormat);
218 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
219 if (portMap == null) {
220 throw new OpenRoadmInterfaceException(
221 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
222 nodeId, logicalConnPoint));
224 // Create generic interface
225 InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
226 spectrumInformation.getIdentifierFromParams(logicalConnPoint));
227 // Create Interface1 type object required for adding as augmentation
228 // TODO look at imports of different versions of class
229 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
230 ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
231 .Interface1Builder();
232 ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
234 // Post interface on the device
235 openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
237 // Post the equipment-state change on the device circuit-pack if xpdr node
238 if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
239 this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
242 return ochInterfaceBldr.getName();
245 public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isNetworkPort,
246 String supportingInterface) throws OpenRoadmInterfaceException {
247 Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
248 if (mapping == null) {
249 throw new OpenRoadmInterfaceException(
250 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
252 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
253 logicalConnPoint + "-ODU4");
254 if (supportingInterface != null) {
255 oduInterfaceBldr.setSupportingInterface(supportingInterface);
258 // ODU interface specific data
259 Class<? extends OduFunctionIdentity> oduFunction = isNetworkPort ? ODUCTP.class : ODUTTPCTP.class;
260 // TODO look at imports of different versions of class
261 oduInterfaceBldr.addAugmentation(
262 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
263 .setOdu(new OduBuilder()
265 .setOduFunction(oduFunction)
266 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
269 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
270 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07")).build()).build())
273 // Post interface on the device
274 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
275 return oduInterfaceBldr.getName();
278 public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
279 throws OpenRoadmInterfaceException {
280 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
281 if (portMap == null) {
282 throw new OpenRoadmInterfaceException(
283 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
284 nodeId, logicalConnPoint));
286 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
287 logicalConnPoint + "-ODU");
288 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
290 // ODU interface specific data
291 // Set Opu attributes
292 OpuBuilder opuBldr = new OpuBuilder()
293 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
294 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
295 OduBuilder oduIfBuilder = new OduBuilder()
297 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
298 .setOpu(opuBldr.build());
300 // Create Interface1 type object required for adding as augmentation
301 // TODO look at imports of different versions of class
302 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
303 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
304 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
306 // Post interface on the device
307 openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
308 return oduInterfaceBldr.getName();
311 public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
312 String znodeId, String zlogicalConnPoint)
313 throws OpenRoadmInterfaceException {
314 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
315 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
316 if (portMapA == null) {
317 throw new OpenRoadmInterfaceException(
318 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
320 if (portMapZ == null) {
321 throw new OpenRoadmInterfaceException(
322 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
324 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
325 alogicalConnPoint + "-ODU");
326 oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
328 // ODU interface specific data
329 // Set Opu attributes
330 OpuBuilder opuBldr = new OpuBuilder()
331 .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
332 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"));
333 OduBuilder oduIfBuilder = new OduBuilder()
335 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
336 .setOpu(opuBldr.build())
337 .setTxSapi(portMapA.getLcpHashVal())
338 .setTxDapi(portMapZ.getLcpHashVal())
339 // Setting the expected Dapi and Sapi values
340 .setExpectedDapi(portMapA.getLcpHashVal())
341 .setExpectedSapi(portMapZ.getLcpHashVal());
343 // Create Interface1 type object required for adding as augmentation
344 // TODO look at imports of different versions of class
345 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
346 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
347 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
349 // Post interface on the device
350 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
351 return oduInterfaceBldr.getName();
354 public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
355 throws OpenRoadmInterfaceException {
356 Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
357 if (portMap == null) {
358 throw new OpenRoadmInterfaceException(
359 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
360 nodeId, logicalConnPoint));
362 // Create generic interface
363 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class,
364 logicalConnPoint + "-OTU");
365 otuInterfaceBldr.setSupportingInterface(supportOchInterface);
367 // OTU interface specific data
368 OtuBuilder otuIfBuilder = new OtuBuilder();
369 otuIfBuilder.setFec(OtuAttributes.Fec.Scfec);
370 otuIfBuilder.setRate(OTU4.class);
372 // Create Interface1 type object required for adding as augmentation
373 // TODO look at imports of different versions of class
374 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
375 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
376 otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
378 // Post interface on the device
379 openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
380 return otuInterfaceBldr.getName();
383 public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
384 String znodeId, String zlogicalConnPoint)
385 throws OpenRoadmInterfaceException {
386 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
387 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
388 if (portMapA == null) {
389 throw new OpenRoadmInterfaceException(
390 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
391 anodeId, alogicalConnPoint));
394 if (portMapZ == null) {
395 throw new OpenRoadmInterfaceException(
396 String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s ",
397 znodeId, zlogicalConnPoint));
400 // Create generic interface builder
401 InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
402 alogicalConnPoint + "-OTU");
404 // Set the supporting interface data
405 otuInterfaceBldr.setSupportingInterface(asupportOchInterface);
407 // OTU interface specific data
408 OtuBuilder otuIfBuilder = new OtuBuilder()
409 .setFec(OtuAttributes.Fec.Scfec)
411 .setTxSapi(portMapA.getLcpHashVal())
412 .setTxDapi(portMapZ.getLcpHashVal())
413 // setting expected SAPI and DAPI values
414 .setExpectedDapi(portMapA.getLcpHashVal())
415 .setExpectedSapi(portMapZ.getLcpHashVal());
417 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
418 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(anodeId, otuInterfaceBldr);
424 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);
567 } catch (InterruptedException e) {
568 LOG.error("Error waiting post interface on device", e);
570 this.portMapping.updateMapping(nodeId, portMap);
571 return oduInterfaceBldr.getName();
574 public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
575 String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
576 throws OpenRoadmInterfaceException {
577 Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
578 if (portMapA == null) {
579 throw new OpenRoadmInterfaceException(
580 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, anodeId, alogicalConnPoint));
582 Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
583 if (portMapZ == null) {
584 throw new OpenRoadmInterfaceException(
585 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, znodeId, zlogicalConnPoint));
587 InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
588 alogicalConnPoint + "-ODU4");
589 oduInterfaceBldr.setSupportingInterface(asupportingOtuInterface);
591 // ODU interface specific data
592 OduBuilder oduIfBuilder = new OduBuilder()
594 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
595 .setTxSapi(portMapA.getLcpHashVal())
596 .setTxDapi(portMapZ.getLcpHashVal())
597 .setExpectedSapi(portMapZ.getLcpHashVal())
598 .setExpectedDapi(portMapA.getLcpHashVal());
601 // Set Opu attributes
602 OpuBuilder opuBldr = new OpuBuilder()
603 .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
604 .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
605 oduIfBuilder.setOduFunction(ODUTTP.class)
606 .setOpu(opuBldr.build());
608 // Create Interface1 type object required for adding as augmentation
609 // TODO look at imports of different versions of class
610 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
611 new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
612 oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
614 // Post interface on the device
615 openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
618 } catch (InterruptedException e) {
619 LOG.error("Error waiting post interface on device", e);
621 this.portMapping.updateMapping(anodeId, portMapA);
622 return oduInterfaceBldr.getName();