package org.opendaylight.transportpce.common.openroadminterfaces;
-import com.google.common.util.concurrent.ListenableFuture;
+import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
+import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1;
+import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1;
import java.util.Optional;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.transportpce.common.Timeouts;
-import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
+import org.opendaylight.transportpce.common.mapping.MappingUtils;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOdu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOtu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev161014.maint.loopback.MaintLoopbackBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev161014.maint.testsignal.MaintTestsignalBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Component
public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces {
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfacesImpl.class);
- // TODO move somewhere to constants
- public static final String NETWORK_TOKEN = "XPDR-LINE";
- public static final String TTP_TOKEN = "TTP";
- public static final String CLIENT_TOKEN = "XPDR-CLNT";
- public static final String PP_TOKEN = "PP";
+ OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
+ OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221;
+ OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710;
+ MappingUtils mappingUtils;
+
+ @Activate
+ public OpenRoadmInterfacesImpl(@Reference DeviceTransactionManager deviceTransactionManager,
+ @Reference MappingUtils mappingUtils, @Reference PortMapping portMapping) {
+ this(deviceTransactionManager, mappingUtils,
+ new OpenRoadmInterfacesImpl121(deviceTransactionManager),
+ new OpenRoadmInterfacesImpl221(deviceTransactionManager, portMapping),
+ new OpenRoadmInterfacesImpl710(deviceTransactionManager, portMapping));
+ }
- private final DeviceTransactionManager deviceTransactionManager;
+ public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager, MappingUtils mappingUtils,
+ OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121,
+ OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221,
+ OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710) {
+ this.mappingUtils = mappingUtils;
+ this.openRoadmInterfacesImpl121 = openRoadmInterfacesImpl121;
+ this.openRoadmInterfacesImpl221 = openRoadmInterfacesImpl221;
+ this.openRoadmInterfacesImpl710 = openRoadmInterfacesImpl710;
+ }
- public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager) {
- this.deviceTransactionManager = deviceTransactionManager;
+ @Override
+ public <T> void postInterface(String nodeId, T ifBuilder) throws OpenRoadmInterfaceException {
+
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ LOG.info("postInterface for 1.2.1 device {}", nodeId);
+ InterfaceBuilder ifBuilder121 = convertInstanceOfInterface(ifBuilder, InterfaceBuilder.class);
+ openRoadmInterfacesImpl121.postInterface(nodeId,ifBuilder121);
+ return;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ LOG.info("postInterface for 2.2.1 device {}", nodeId);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder
+ ifBuilder22 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1
+ .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder.class);
+ openRoadmInterfacesImpl221.postInterface(nodeId,ifBuilder22);
+ return;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ LOG.info("postInterface for 7.1.0 device {}", nodeId);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder
+ ifBuilder71 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1
+ .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder.class);
+ openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71);
+ return;
+ default:
+ LOG.error("postInterface unknown ordm version error device {}", nodeId);
+ return;
+ }
}
@Override
- public void postInterface(String nodeId, InterfaceBuilder ifBuilder) throws OpenRoadmInterfaceException {
- Future<Optional<DeviceTransaction>> deviceTxFuture = this.deviceTransactionManager.getDeviceTransaction(nodeId);
- DeviceTransaction deviceTx;
- try {
- Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
- if (deviceTxOpt.isPresent()) {
- deviceTx = deviceTxOpt.get();
- } else {
- throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
- nodeId));
- }
- } catch (InterruptedException | ExecutionException e) {
- throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
- nodeId), e);
+ @SuppressWarnings("unchecked")
+ public <T> Optional<T> getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException {
+
+ String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
+ LOG.info("Interface get request received for node {} with version {}", nodeId, openRoadmVersion);
+ switch (openRoadmVersion) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ return (Optional<T>) openRoadmInterfacesImpl121.getInterface(nodeId,interfaceName);
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ return (Optional<T>) openRoadmInterfacesImpl221.getInterface(nodeId,interfaceName);
+ case OPENROADM_DEVICE_VERSION_7_1:
+ return (Optional<T>) openRoadmInterfacesImpl710.getInterface(nodeId,interfaceName);
+ default:
+ LOG.error("getInterface unknown ordm version error device {}", nodeId);
+ return Optional.empty();
}
+ }
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(ifBuilder.getName()));
- deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build());
- ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
- try {
- txSubmitFuture.get();
- LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
- } catch (InterruptedException | ExecutionException e) {
- throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!",
- ifBuilder.getName(), nodeId), e);
+ @Override
+ public void deleteInterface(String nodeId, String interfaceName)
+ throws OpenRoadmInterfaceException {
+
+ String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
+ LOG.info("Interface delete request received for node {} with version {}", nodeId, openRoadmVersion);
+ switch (openRoadmVersion) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ openRoadmInterfacesImpl121.deleteInterface(nodeId,interfaceName);
+ return;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ openRoadmInterfacesImpl221.deleteInterface(nodeId,interfaceName);
+ return;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ openRoadmInterfacesImpl710.deleteInterface(nodeId,interfaceName);
+ return;
+ default:
+ LOG.error("deleteInterface unknown ordm version error device {}", nodeId);
+ return;
}
}
@Override
- public Optional<Interface> getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException {
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(interfaceName));
- return this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.CONFIGURATION, interfacesIID,
- Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ public void postEquipmentState(String nodeId, String circuitPackName, boolean activate)
+ throws OpenRoadmInterfaceException {
+
+ String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
+ LOG.info("Request received for node {} with version {} to change equipment-state of cp {}.",
+ nodeId,openRoadmVersion, circuitPackName);
+ switch (openRoadmVersion) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ openRoadmInterfacesImpl121.postEquipmentState(nodeId, circuitPackName, activate);
+ return;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate);
+ return;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate);
+ return;
+ default:
+ LOG.error("postEquipmentState unknown ordm version error device {}", nodeId);
+ return;
+ }
}
@Override
- public void deleteInterface(String nodeId, String interfaceName)
- throws OpenRoadmInterfaceException {
- Optional<Interface> intf2DeleteOpt;
- try {
- intf2DeleteOpt = getInterface(nodeId, interfaceName);
- } catch (OpenRoadmInterfaceException e) {
- throw new OpenRoadmInterfaceException(String.format("Failed to check if interface %s exists on node %s!",
- interfaceName, nodeId), e);
+ public <T> void postOTNInterface(String nodeId, T ifBuilder)
+ throws OpenRoadmInterfaceException {
+
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ LOG.error("postOTNInterface unsupported ordm version 1.2.1 error device {}", nodeId);
+ return;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder
+ ifBuilder22 = (org.opendaylight.yang.gen.v1
+ .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder) ifBuilder;
+ openRoadmInterfacesImpl221.postInterface(nodeId, ifBuilder22);
+ return;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder
+ ifBuilder71 = (org.opendaylight.yang.gen.v1
+ .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder) ifBuilder;
+ openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71);
+ return;
+ default:
+ LOG.error("postOTNInterface unknown ordm version error device {}", nodeId);
+ return;
}
- if (intf2DeleteOpt.isPresent()) {
- Interface intf2Delete = intf2DeleteOpt.get();
- // State admin state to out of service
- InterfaceBuilder ifBuilder = new InterfaceBuilder(intf2Delete);
- if (ifBuilder.getType() == OtnOdu.class) {
- Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.getAugmentation(Interface1.class));
- OduBuilder odu = new OduBuilder(oduBuilder.getOdu());
- if (odu.getMaintTestsignal() != null) {
- MaintTestsignalBuilder maintSignalBuilder =
- new MaintTestsignalBuilder();
- maintSignalBuilder.setEnabled(false);
- odu.setMaintTestsignal(maintSignalBuilder.build());
- }
- oduBuilder.setOdu(odu.build());
- ifBuilder.addAugmentation(Interface1.class, oduBuilder.build());
- } else if (ifBuilder.getType() == OtnOtu.class) {
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu
- .interfaces.rev161014.Interface1Builder otuBuilder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu
- .interfaces.rev161014.Interface1Builder(intf2Delete
- .getAugmentation(org.opendaylight.yang.gen.v1
- .http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class));
- OtuBuilder otu = new OtuBuilder(otuBuilder.getOtu());
- if (otu.getMaintLoopback() != null) {
- MaintLoopbackBuilder maintLoopBackBuilder =
- new MaintLoopbackBuilder();
- maintLoopBackBuilder.setEnabled(false);
- otu.setMaintLoopback(maintLoopBackBuilder.build());
- }
- otuBuilder.setOtu(otu.build());
- ifBuilder.addAugmentation(org.opendaylight.yang.gen
- .v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class, otuBuilder.build());
- }
- ifBuilder.setAdministrativeState(AdminStates.OutOfService);
- // post interface with updated admin state
- try {
- postInterface(nodeId, ifBuilder);
- } catch (OpenRoadmInterfaceException ex) {
- throw new OpenRoadmInterfaceException(String.format("Failed to set state of interface %s to %s while"
- + " deleting it!", interfaceName, AdminStates.OutOfService), ex);
- }
-
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(interfaceName));
- Future<Optional<DeviceTransaction>> deviceTxFuture = this.deviceTransactionManager.getDeviceTransaction(nodeId);
- DeviceTransaction deviceTx;
- try {
- Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
- if (deviceTxOpt.isPresent()) {
- deviceTx = deviceTxOpt.get();
- } else {
- throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
- nodeId));
- }
- } catch (InterruptedException | ExecutionException e) {
- throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
- nodeId), e);
- }
-
- deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
- ListenableFuture<Void> submit = deviceTx.submit(
- Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
-
- try {
- submit.get();
- LOG.info("Successfully deleted {} on node {}", interfaceName, nodeId);
- } catch (InterruptedException | ExecutionException e) {
- throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on "
- + "node %s", interfaceName, nodeId), e);
- }
- } else {
- LOG.info("Interface does not exist, cannot delete on node {}", nodeId);
+ }
+
+ @Override
+ public void postOTNEquipmentState(String nodeId, String circuitPackName, boolean activate)
+ throws OpenRoadmInterfaceException {
+
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ LOG.error("postOTNEquipmentState unsupported ordm version 1.2.1 error device {}", nodeId);
+ return;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate);
+ return;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate);
+ return;
+ default:
+ LOG.error("postOTNEquipmentState unknown ordm version error device {}", nodeId);
+ return;
}
}
+ private <T> T convertInstanceOfInterface(Object object, Class<T> classToCast) {
+ try {
+ return classToCast.cast(object);
+ } catch (ClassCastException e) {
+ return null;
+ }
+ }
+
+ @Override
+ public String getSupportedInterface(String nodeId, String interfaceName) {
+ String supportedInterface = "";
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case OPENROADM_DEVICE_VERSION_1_2_1:
+ supportedInterface = openRoadmInterfacesImpl121.getSupportedInterface(nodeId,interfaceName);
+ break;
+ case OPENROADM_DEVICE_VERSION_2_2_1:
+ supportedInterface = openRoadmInterfacesImpl221.getSupportedInterface(nodeId,interfaceName);
+ break;
+ case OPENROADM_DEVICE_VERSION_7_1:
+ supportedInterface = openRoadmInterfacesImpl710.getSupportedInterface(nodeId,interfaceName);
+ break;
+ default:
+ LOG.error("getSupportedInterface unknown ordm version error device {}", nodeId);
+ }
+ return supportedInterface;
+ }
}
Code Review / transportpce.git / blobdiff