common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java

   1 /*
   2  * Copyright © 2017 AT&T and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.transportpce.common.openroadminterfaces;
  10
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import java.util.Optional;
  13 import java.util.concurrent.ExecutionException;
  14 import java.util.concurrent.Future;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.transportpce.common.Timeouts;
  17 import org.opendaylight.transportpce.common.device.DeviceTransaction;
  18 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  19 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  20 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  21 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOdu;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOtu;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev161014.maint.loopback.MaintLoopbackBuilder;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev161014.maint.testsignal.MaintTestsignalBuilder;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces {
  37
  38     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfacesImpl.class);
  39
  40     // TODO move somewhere to constants
  41     public static final String NETWORK_TOKEN = "XPDR-LINE";
  42     public static final String TTP_TOKEN = "TTP";
  43     public static final String CLIENT_TOKEN = "XPDR-CLNT";
  44     public static final String PP_TOKEN = "PP";
  45
  46     private final DeviceTransactionManager deviceTransactionManager;
  47
  48     public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager) {
  49         this.deviceTransactionManager = deviceTransactionManager;
  50     }
  51
  52     @Override
  53     public void postInterface(String nodeId, InterfaceBuilder ifBuilder) throws OpenRoadmInterfaceException {
  54         Future<Optional<DeviceTransaction>> deviceTxFuture = this.deviceTransactionManager.getDeviceTransaction(nodeId);
  55         DeviceTransaction deviceTx;
  56         try {
  57             Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
  58             if (deviceTxOpt.isPresent()) {
  59                 deviceTx = deviceTxOpt.get();
  60             } else {
  61                 throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
  62                         nodeId));
  63             }
  64         } catch (InterruptedException | ExecutionException e) {
  65             throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
  66                     nodeId), e);
  67         }
  68
  69         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
  70                 .child(Interface.class, new InterfaceKey(ifBuilder.getName()));
  71         deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build());
  72         ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
  73                 Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
  74         try {
  75             txSubmitFuture.get();
  76             LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
  77         } catch (InterruptedException | ExecutionException e) {
  78             throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!",
  79                     ifBuilder.getName(), nodeId), e);
  80         }
  81     }
  82
  83     @Override
  84     public Optional<Interface> getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException {
  85         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
  86                 .child(Interface.class, new InterfaceKey(interfaceName));
  87         return this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.CONFIGURATION,
  88                 interfacesIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  89     }
  90
  91     @Override
  92     public void deleteInterface(String nodeId, String interfaceName)
  93             throws OpenRoadmInterfaceException {
  94         Optional<Interface> intf2DeleteOpt;
  95         try {
  96             intf2DeleteOpt = getInterface(nodeId, interfaceName);
  97         } catch (OpenRoadmInterfaceException e) {
  98             throw new OpenRoadmInterfaceException(String.format("Failed to check if interface %s exists on node %s!",
  99                     interfaceName, nodeId), e);
 100         }
 101         if (intf2DeleteOpt.isPresent()) {
 102             Interface intf2Delete = intf2DeleteOpt.get();
 103             // State admin state to out of service
 104             InterfaceBuilder ifBuilder = new InterfaceBuilder(intf2Delete);
 105             if (ifBuilder.getType() == OtnOdu.class) {
 106                 Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.augmentation(Interface1.class));
 107                 OduBuilder odu = new OduBuilder(oduBuilder.getOdu());
 108                 if (odu.getMaintTestsignal() != null) {
 109                     MaintTestsignalBuilder maintSignalBuilder =
 110                             new MaintTestsignalBuilder();
 111                     maintSignalBuilder.setEnabled(false);
 112                     odu.setMaintTestsignal(maintSignalBuilder.build());
 113                 }
 114                 oduBuilder.setOdu(odu.build());
 115                 ifBuilder.addAugmentation(Interface1.class, oduBuilder.build());
 116             } else if (ifBuilder.getType() == OtnOtu.class) {
 117                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu
 118                     .interfaces.rev161014.Interface1Builder otuBuilder =
 119                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu
 120                     .interfaces.rev161014.Interface1Builder(intf2Delete
 121                             .augmentation(org.opendaylight.yang.gen.v1
 122                                     .http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class));
 123                 OtuBuilder otu = new OtuBuilder(otuBuilder.getOtu());
 124                 if (otu.getMaintLoopback() != null) {
 125                     MaintLoopbackBuilder maintLoopBackBuilder =
 126                             new MaintLoopbackBuilder();
 127                     maintLoopBackBuilder.setEnabled(false);
 128                     otu.setMaintLoopback(maintLoopBackBuilder.build());
 129                 }
 130                 otuBuilder.setOtu(otu.build());
 131                 ifBuilder.addAugmentation(org.opendaylight.yang.gen
 132                         .v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class, otuBuilder.build());
 133             }
 134             ifBuilder.setAdministrativeState(AdminStates.OutOfService);
 135             // post interface with updated admin state
 136             try {
 137                 postInterface(nodeId, ifBuilder);
 138             } catch (OpenRoadmInterfaceException ex) {
 139                 throw new OpenRoadmInterfaceException(String.format("Failed to set state of interface %s to %s while"
 140                         + " deleting it!", interfaceName, AdminStates.OutOfService), ex);
 141             }
 142
 143             InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 144                     .child(Interface.class, new InterfaceKey(interfaceName));
 145             Future<Optional<DeviceTransaction>> deviceTxFuture =
 146                 this.deviceTransactionManager.getDeviceTransaction(nodeId);
 147             DeviceTransaction deviceTx;
 148             try {
 149                 Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
 150                 if (deviceTxOpt.isPresent()) {
 151                     deviceTx = deviceTxOpt.get();
 152                 } else {
 153                     throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!",
 154                             nodeId));
 155                 }
 156             } catch (InterruptedException | ExecutionException e) {
 157                 throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
 158                         nodeId), e);
 159             }
 160
 161             deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
 162             ListenableFuture<Void> submit = deviceTx.submit(
 163                     Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
 164
 165             try {
 166                 submit.get();
 167                 LOG.info("Successfully deleted {} on node {}", interfaceName, nodeId);
 168             } catch (InterruptedException | ExecutionException e) {
 169                 throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on "
 170                         + "node %s", interfaceName, nodeId), e);
 171             }
 172         } else {
 173             LOG.info("Interface does not exist, cannot delete on node {}", nodeId);
 174         }
 175     }
 176
 177
 178 }