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