interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfacemgrProvider.java

   1 /*
   2  * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. 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 package org.opendaylight.vpnservice.interfacemgr;
   9
  10 import java.math.BigInteger;
  11 import java.util.List;
  12 import java.util.concurrent.ExecutionException;
  13 import java.util.concurrent.Future;
  14
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  17 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
  22 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  23 import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceManagerCommonUtils;
  24 import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo;
  25 import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo.InterfaceAdminState;
  26 import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
  27 import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceConfigListener;
  28 import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceInventoryStateListener;
  29 import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceTopologyStateListener;
  30 import org.opendaylight.vpnservice.interfacemgr.listeners.VlanMemberConfigListener;
  31 import org.opendaylight.vpnservice.interfacemgr.rpcservice.InterfaceManagerRpcService;
  32 import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.listeners.FlowBasedServicesConfigListener;
  33 import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.listeners.FlowBasedServicesInterfaceStateListener;
  34 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  35 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorListener;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorService;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInput;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInputBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceOutput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnInput;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnInputBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnOutput;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInputBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceOutput;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
  56 import org.opendaylight.yangtools.yang.common.RpcResult;
  57 import org.slf4j.Logger;
  58 import org.slf4j.LoggerFactory;
  59
  60 public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable, IInterfaceManager {
  61
  62     private static final Logger LOG = LoggerFactory.getLogger(InterfacemgrProvider.class);
  63
  64     private RpcProviderRegistry rpcProviderRegistry;
  65     private IdManagerService idManager;
  66     private NotificationService notificationService;
  67     private AlivenessMonitorService alivenessManager;
  68     private IMdsalApiManager mdsalManager;
  69     private InterfaceConfigListener interfaceConfigListener;
  70     private InterfaceTopologyStateListener topologyStateListener;
  71     private InterfaceInventoryStateListener interfaceInventoryStateListener;
  72     private FlowBasedServicesInterfaceStateListener flowBasedServicesInterfaceStateListener;
  73     private FlowBasedServicesConfigListener flowBasedServicesConfigListener;
  74     private VlanMemberConfigListener vlanMemberConfigListener;
  75     private org.opendaylight.vpnservice.interfacemgr.listeners.AlivenessMonitorListener alivenessMonitorListener;
  76     private DataBroker dataBroker;
  77     private InterfaceManagerRpcService interfaceManagerRpcService;
  78     private BindingAwareBroker.RpcRegistration<OdlInterfaceRpcService> rpcRegistration;
  79
  80     public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) {
  81         this.rpcProviderRegistry = rpcProviderRegistry;
  82     }
  83
  84     public void setMdsalManager(IMdsalApiManager mdsalManager) {
  85         this.mdsalManager = mdsalManager;
  86     }
  87
  88     public void setNotificationService(NotificationService notificationService) {
  89         this.notificationService = notificationService;
  90     }
  91
  92     @Override
  93     public void onSessionInitiated(ProviderContext session) {
  94         LOG.info("InterfacemgrProvider Session Initiated");
  95         try {
  96             dataBroker = session.getSALService(DataBroker.class);
  97             idManager = rpcProviderRegistry.getRpcService(IdManagerService.class);
  98             createIdPool();
  99
 100             alivenessManager = rpcProviderRegistry.getRpcService(AlivenessMonitorService.class);
 101             interfaceManagerRpcService = new InterfaceManagerRpcService(dataBroker, mdsalManager);
 102             rpcRegistration = getRpcProviderRegistry().addRpcImplementation(
 103                     OdlInterfaceRpcService.class, interfaceManagerRpcService);
 104
 105             interfaceConfigListener = new InterfaceConfigListener(dataBroker, idManager,alivenessManager, mdsalManager);
 106             interfaceConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 107
 108             interfaceInventoryStateListener = new InterfaceInventoryStateListener(dataBroker, idManager, mdsalManager, alivenessManager);
 109             interfaceInventoryStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 110
 111             topologyStateListener = new InterfaceTopologyStateListener(dataBroker);
 112             topologyStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 113
 114             flowBasedServicesConfigListener = new FlowBasedServicesConfigListener(dataBroker);
 115             flowBasedServicesConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 116
 117             flowBasedServicesInterfaceStateListener =
 118                     new FlowBasedServicesInterfaceStateListener(dataBroker);
 119             flowBasedServicesInterfaceStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 120
 121             vlanMemberConfigListener =
 122                                new VlanMemberConfigListener(dataBroker, idManager, alivenessManager,mdsalManager);
 123             vlanMemberConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 124             alivenessMonitorListener = new org.opendaylight.vpnservice.interfacemgr.listeners.AlivenessMonitorListener(dataBroker);
 125             notificationService.registerNotificationListener(alivenessMonitorListener);
 126         } catch (Exception e) {
 127             LOG.error("Error initializing services", e);
 128         }
 129     }
 130
 131     private void createIdPool() {
 132         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
 133             .setPoolName(IfmConstants.IFM_IDPOOL_NAME)
 134                 .setLow(IfmConstants.IFM_ID_POOL_START)
 135                 .setHigh(IfmConstants.IFM_ID_POOL_END)
 136             .build();
 137         //TODO: Error handling
 138         Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
 139         try {
 140             if ((result != null) && (result.get().isSuccessful())) {
 141                 LOG.debug("Created IdPool for InterfaceMgr");
 142             }
 143         } catch (InterruptedException | ExecutionException e) {
 144             LOG.error("Failed to create idPool for InterfaceMgr",e);
 145         }
 146     }
 147
 148     @Override
 149     public void close() throws Exception {
 150         LOG.info("InterfacemgrProvider Closed");
 151         interfaceConfigListener.close();
 152         rpcRegistration.close();
 153     }
 154
 155     public RpcProviderRegistry getRpcProviderRegistry() {
 156         return rpcProviderRegistry;
 157     }
 158
 159     @Override
 160     public Long getPortForInterface(String ifName) {
 161         GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(ifName).build();
 162         Future<RpcResult<GetPortFromInterfaceOutput>> output = interfaceManagerRpcService.getPortFromInterface(input);
 163         try {
 164             RpcResult<GetPortFromInterfaceOutput> port = output.get();
 165             if(port.isSuccessful()){
 166                 return port.getResult().getPortno();
 167             }
 168         }catch(NullPointerException | InterruptedException | ExecutionException e){
 169             LOG.warn("Exception when getting port for interface",e);
 170         }
 171         return null;
 172     }
 173
 174     @Override
 175     public Long getPortForInterface(Interface intf) {
 176         GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(intf.getName()).build();
 177         Future<RpcResult<GetPortFromInterfaceOutput>> output = interfaceManagerRpcService.getPortFromInterface(input);
 178         try {
 179             RpcResult<GetPortFromInterfaceOutput> port = output.get();
 180             if(port.isSuccessful()){
 181                 return port.getResult().getPortno();
 182             }
 183         }catch(NullPointerException | InterruptedException | ExecutionException e){
 184             LOG.warn("Exception when getting port for interface",e);
 185         }
 186         return null;
 187     }
 188
 189     @Override
 190     public InterfaceInfo getInterfaceInfo(String interfaceName) {
 191         //FIXME [ELANBE] This is not working yet, fix this
 192
 193         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface
 194                 ifState = InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName,dataBroker);
 195
 196         if(ifState == null){
 197             LOG.error("Interface {} is not present", interfaceName);
 198             return null;
 199         }
 200
 201         Integer lportTag = ifState.getIfIndex();
 202         Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker);
 203
 204         NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(intf, dataBroker);
 205         InterfaceInfo.InterfaceType interfaceType = IfmUtil.getInterfaceType(intf);
 206         InterfaceInfo interfaceInfo = null;
 207         BigInteger dpId = org.opendaylight.vpnservice.interfacemgr.globals.IfmConstants.INVALID_DPID;
 208         Integer portNo = org.opendaylight.vpnservice.interfacemgr.globals.IfmConstants.INVALID_PORT_NO;
 209         if (ncId !=null ) {
 210             dpId = new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId));
 211             portNo = Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId));
 212         }
 213
 214         if(interfaceType == InterfaceInfo.InterfaceType.VLAN_INTERFACE){
 215             interfaceInfo = IfmUtil.getVlanInterfaceInfo(interfaceName, intf, dpId);
 216         } else if (interfaceType == InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE || interfaceType == InterfaceInfo.InterfaceType.GRE_TRUNK_INTERFACE) {/*
 217             trunkInterfaceInfo trunkInterfaceInfo = (TrunkInterfaceInfo) ConfigIfmUtil.getTrunkInterfaceInfo(ifName, ConfigIfmUtil.getInterfaceByIfName(dataBroker, ifName));
 218             String higherLayerIf = inf.getHigherLayerIf().get(0);
 219             Interface vlanInterface = ConfigIfmUtil.getInterfaceByIfName(dataBroker, higherLayerIf);
 220             trunkInterfaceInfo.setPortName(vlanInterface.getAugmentation(BaseConfig.class).getParentInterface());
 221             trunkInterfaceManager.updateTargetMacAddressInInterfaceInfo(trunkInterfaceInfo, trunkInterface);
 222             if (trunkInterface.getPhysAddress() != null) {
 223                 trunkInterfaceInfo.setLocalMacAddress(trunkInterface.getPhysAddress().getValue());
 224             }
 225             interfaceInfo = trunkInterfaceInfo;
 226             interfaceInfo.setL2domainGroupId(IfmUtil.getGroupId(OperationalIfmUtil.getInterfaceStateByIfName(dataBroker, higherLayerIf).getIfIndex(), InterfaceType.VLAN_INTERFACE));
 227         */} else {
 228             LOG.error("Type of Interface {} is unknown", interfaceName);
 229             return null;
 230         }
 231         interfaceInfo.setDpId(dpId);
 232         interfaceInfo.setPortNo(portNo);
 233         interfaceInfo.setAdminState((intf.isEnabled() == true) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED);
 234         interfaceInfo.setInterfaceName(interfaceName);
 235         interfaceInfo.setInterfaceTag(lportTag);
 236         interfaceInfo.setInterfaceType(interfaceType);
 237         interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType));
 238         interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN);
 239
 240
 241         return interfaceInfo;
 242
 243     }
 244
 245     @Override
 246     public InterfaceInfo getInterfaceInfoFromOperationalDataStore(String interfaceName, InterfaceInfo.InterfaceType interfaceType) {
 247         InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName);
 248         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = InterfaceManagerCommonUtils
 249                 .getInterfaceStateFromOperDS(interfaceName, dataBroker);
 250         if (ifState == null) {
 251             LOG.error("Interface {} is not present", interfaceName);
 252             return null;
 253         }
 254         Integer lportTag = ifState.getIfIndex();
 255         Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker);
 256         NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(intf, dataBroker);
 257         if (ncId != null) {
 258             interfaceInfo.setDpId(new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId)));
 259             interfaceInfo.setPortNo(Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId)));
 260         }
 261         interfaceInfo.setAdminState((intf.isEnabled() == true) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED);
 262         interfaceInfo.setInterfaceName(interfaceName);
 263         interfaceInfo.setInterfaceTag(lportTag);
 264         interfaceInfo.setInterfaceType(interfaceType);
 265         interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType));
 266         interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN);
 267
 268
 269         return interfaceInfo;
 270     }
 271
 272     @Override
 273     public BigInteger getDpnForInterface(String ifName) {
 274         GetDpidFromInterfaceInput input = new GetDpidFromInterfaceInputBuilder().setIntfName(ifName).build();
 275         Future<RpcResult<GetDpidFromInterfaceOutput>> output = interfaceManagerRpcService.getDpidFromInterface(input);
 276         try {
 277             RpcResult<GetDpidFromInterfaceOutput> dpn = output.get();
 278             if(dpn.isSuccessful()){
 279                 return dpn.getResult().getDpid();
 280             }
 281         }catch(NullPointerException | InterruptedException | ExecutionException e){
 282             LOG.warn("Exception when getting port for interface",e);
 283         }
 284         return null;
 285     }
 286
 287     @Override
 288     public String getEndpointIpForDpn(BigInteger dpnId) {
 289         GetEndpointIpForDpnInput input = new GetEndpointIpForDpnInputBuilder().setDpid(dpnId).build();
 290         Future<RpcResult<GetEndpointIpForDpnOutput>> output = interfaceManagerRpcService.getEndpointIpForDpn(input);
 291         try {
 292             RpcResult<GetEndpointIpForDpnOutput> ipForDpnOutputRpcResult = output.get();
 293             if(ipForDpnOutputRpcResult.isSuccessful()){
 294                 List<IpAddress> localIps = ipForDpnOutputRpcResult.getResult().getLocalIps();
 295                 if(!localIps.isEmpty()) {
 296                     return localIps.get(0).getIpv4Address().getValue();
 297                 }
 298             }
 299         }catch(NullPointerException | InterruptedException | ExecutionException e){
 300             LOG.warn("Exception when getting port for interface",e);
 301         }
 302         return null;
 303     }
 304
 305     @Override
 306     public List<ActionInfo> getInterfaceEgressActions(String ifName) {
 307         return interfaceManagerRpcService.getEgressActionInfosForInterface(ifName);
 308     }
 309
 310     @Override
 311     public BigInteger getDpnForInterface(Interface intrf) {
 312         return getDpnForInterface(intrf.getName());
 313     }
 314 }