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