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.circuit.packs.CircuitPacks;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
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.equipment.states.types.rev161014.States;
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;
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 NETWORK_TOKEN = "NETWORK";
public static final String TTP_TOKEN = "TTP";
- public static final String CLIENT_TOKEN = "XPDR-CLNT";
+ public static final String CLIENT_TOKEN = "CLIENT";
public static final String PP_TOKEN = "PP";
private final DeviceTransactionManager deviceTransactionManager;
deviceTx = deviceTxOpt.get();
} else {
throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
- nodeId));
+ nodeId));
}
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
- nodeId), e);
+ nodeId), e);
}
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(ifBuilder.getName()));
+ 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);
+ 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);
+ throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!", ifBuilder
+ .getName(), nodeId), e);
}
}
@Override
public Optional<Interface> getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException {
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(interfaceName));
+ 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);
+ interfacesIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
}
@Override
- public void deleteInterface(String nodeId, String interfaceName)
- throws OpenRoadmInterfaceException {
+ 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);
+ interfaceName, nodeId), e);
}
if (intf2DeleteOpt.isPresent()) {
Interface intf2Delete = intf2DeleteOpt.get();
Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.augmentation(Interface1.class));
OduBuilder odu = new OduBuilder(oduBuilder.getOdu());
if (odu.getMaintTestsignal() != null) {
- MaintTestsignalBuilder maintSignalBuilder =
- new MaintTestsignalBuilder();
+ 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
- .augmentation(org.opendaylight.yang.gen.v1
- .http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.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.augmentation(
+ 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 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.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
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);
+ + " 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);
+ 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();
deviceTx = deviceTxOpt.get();
} else {
throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
- nodeId));
+ nodeId));
}
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
- nodeId), e);
+ nodeId), e);
}
deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
- ListenableFuture<Void> submit = deviceTx.submit(
- Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ 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);
+ throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on " + "node %s",
+ interfaceName, nodeId), e);
}
+ // change the equipment state on circuit pack if xpdr node
+ if (intf2Delete.getName().contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN) || intf2Delete.getName().contains(
+ OpenRoadmInterfacesImpl.NETWORK_TOKEN)) {
+ postEquipmentState(nodeId, intf2Delete.getSupportingCircuitPackName(), false);
+ }
+
} else {
LOG.info("Interface does not exist, cannot delete on node {}", nodeId);
}
}
+ @Override
+ public void postEquipmentState(String nodeId, String circuitPackName, boolean activate)
+ throws OpenRoadmInterfaceException {
+
+ InstanceIdentifier<CircuitPacks> circuitPackIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
+ CircuitPacks.class, new CircuitPacksKey(circuitPackName));
+ Optional<CircuitPacks> cpOpt = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.CONFIGURATION, circuitPackIID, Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ CircuitPacks cp = null;
+ if (cpOpt.isPresent()) {
+ cp = cpOpt.get();
+ } else {
+ throw new OpenRoadmInterfaceException(String.format(
+ "Could not find CircuitPack %s in equipment config datastore for node %s", circuitPackName, nodeId));
+ }
+ CircuitPacksBuilder cpBldr = new CircuitPacksBuilder(cp);
+ boolean change = false;
+ if (activate) {
+ if (!cpBldr.getEquipmentState().equals(States.NotReservedInuse)) {
+ cpBldr.setEquipmentState(States.NotReservedInuse);
+ change = true;
+ }
+ } else {
+ if (!cpBldr.getEquipmentState().equals(States.NotReservedAvailable)) {
+ cpBldr.setEquipmentState(States.NotReservedAvailable);
+ change = true;
+ }
+ }
+ if (change) {
+ 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.put(LogicalDatastoreType.CONFIGURATION, circuitPackIID, cpBldr.build());
+ ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
+ Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ try {
+ txSubmitFuture.get();
+ LOG.info("Successfully posted equipment state change on node {}", nodeId);
+ } catch (InterruptedException | ExecutionException e) {
+ throw new OpenRoadmInterfaceException(String.format("Failed to post equipment state on node %s!",
+ nodeId), e);
+ }
+ }
+ }
}
Code Review / transportpce.git / blobdiff