X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=interfacemgr%2Finterfacemgr-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fvpnservice%2Finterfacemgr%2FInterfacemgrProvider.java;h=3b8f6b0623ae22f1ca71f03aa6885be17c851159;hb=63b42a3937b9ab3facfa83ac0fe954bf70ece35c;hp=f177f17b07ac25a87eed75f13c0f6fafc4d8bfe0;hpb=ccb14a6b49f9f9514a32dbe17cb39c24c3ec76ed;p=vpnservice.git diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfacemgrProvider.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfacemgrProvider.java index f177f17b..3b8f6b06 100644 --- a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfacemgrProvider.java +++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfacemgrProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved. + * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, @@ -7,20 +7,52 @@ */ package org.opendaylight.vpnservice.interfacemgr; -import java.util.concurrent.ExecutionException; - import java.math.BigInteger; import java.util.List; +import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; + import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; +import org.opendaylight.controller.md.sal.binding.api.NotificationService; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext; import org.opendaylight.controller.sal.binding.api.BindingAwareProvider; -import org.opendaylight.idmanager.IdManager; +import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; +import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceManagerCommonUtils; +import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo; +import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo.InterfaceAdminState; import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager; -import org.opendaylight.vpnservice.mdsalutil.InstructionInfo; -import org.opendaylight.vpnservice.mdsalutil.MatchInfo; +import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceConfigListener; +import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceInventoryStateListener; +import org.opendaylight.vpnservice.interfacemgr.listeners.InterfaceTopologyStateListener; +import org.opendaylight.vpnservice.interfacemgr.listeners.VlanMemberConfigListener; +import org.opendaylight.vpnservice.interfacemgr.rpcservice.InterfaceManagerRpcService; +import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.listeners.FlowBasedServicesConfigListener; +import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.listeners.FlowBasedServicesInterfaceStateListener; +import org.opendaylight.vpnservice.mdsalutil.ActionInfo; +import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorListener; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceOutput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEndpointIpForDpnOutput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceOutput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -29,19 +61,68 @@ public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable private static final Logger LOG = LoggerFactory.getLogger(InterfacemgrProvider.class); - private InterfaceManager interfaceManager; - private IfmNodeConnectorListener ifmNcListener; - private IdManager idManager; + private RpcProviderRegistry rpcProviderRegistry; + private IdManagerService idManager; + private NotificationService notificationService; + private AlivenessMonitorService alivenessManager; + private IMdsalApiManager mdsalManager; + private InterfaceConfigListener interfaceConfigListener; + private InterfaceTopologyStateListener topologyStateListener; + private InterfaceInventoryStateListener interfaceInventoryStateListener; + private FlowBasedServicesInterfaceStateListener flowBasedServicesInterfaceStateListener; + private FlowBasedServicesConfigListener flowBasedServicesConfigListener; + private VlanMemberConfigListener vlanMemberConfigListener; + private org.opendaylight.vpnservice.interfacemgr.listeners.AlivenessMonitorListener alivenessMonitorListener; + private DataBroker dataBroker; + private InterfaceManagerRpcService interfaceManagerRpcService; + private BindingAwareBroker.RpcRegistration rpcRegistration; + + public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) { + this.rpcProviderRegistry = rpcProviderRegistry; + } + + public void setMdsalManager(IMdsalApiManager mdsalManager) { + this.mdsalManager = mdsalManager; + } + + public void setNotificationService(NotificationService notificationService) { + this.notificationService = notificationService; + } @Override public void onSessionInitiated(ProviderContext session) { LOG.info("InterfacemgrProvider Session Initiated"); try { - final DataBroker dataBroker = session.getSALService(DataBroker.class); - idManager = new IdManager(dataBroker); - interfaceManager = new InterfaceManager(dataBroker, idManager); - ifmNcListener = new IfmNodeConnectorListener(dataBroker, interfaceManager); + dataBroker = session.getSALService(DataBroker.class); + idManager = rpcProviderRegistry.getRpcService(IdManagerService.class); createIdPool(); + + alivenessManager = rpcProviderRegistry.getRpcService(AlivenessMonitorService.class); + interfaceManagerRpcService = new InterfaceManagerRpcService(dataBroker, mdsalManager); + rpcRegistration = getRpcProviderRegistry().addRpcImplementation( + OdlInterfaceRpcService.class, interfaceManagerRpcService); + + interfaceConfigListener = new InterfaceConfigListener(dataBroker, idManager,alivenessManager, mdsalManager); + interfaceConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker); + + interfaceInventoryStateListener = new InterfaceInventoryStateListener(dataBroker, idManager, mdsalManager, alivenessManager); + interfaceInventoryStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker); + + topologyStateListener = new InterfaceTopologyStateListener(dataBroker); + topologyStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker); + + flowBasedServicesConfigListener = new FlowBasedServicesConfigListener(dataBroker); + flowBasedServicesConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker); + + flowBasedServicesInterfaceStateListener = + new FlowBasedServicesInterfaceStateListener(dataBroker); + flowBasedServicesInterfaceStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker); + + vlanMemberConfigListener = + new VlanMemberConfigListener(dataBroker, idManager, alivenessManager); + vlanMemberConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker); + alivenessMonitorListener = new org.opendaylight.vpnservice.interfacemgr.listeners.AlivenessMonitorListener(dataBroker); + notificationService.registerNotificationListener(alivenessMonitorListener); } catch (Exception e) { LOG.error("Error initializing services", e); } @@ -49,14 +130,14 @@ public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable private void createIdPool() { CreateIdPoolInput createPool = new CreateIdPoolInputBuilder() - .setPoolName("interfaces") - .setIdStart(1L) - .setPoolSize(new BigInteger("65535")) - .build(); + .setPoolName(IfmConstants.IFM_IDPOOL_NAME) + .setLow(IfmConstants.IFM_ID_POOL_START) + .setHigh(IfmConstants.IFM_ID_POOL_END) + .build(); //TODO: Error handling Future> result = idManager.createIdPool(createPool); try { - if((result != null) && (result.get().isSuccessful())) { + if ((result != null) && (result.get().isSuccessful())) { LOG.debug("Created IdPool for InterfaceMgr"); } } catch (InterruptedException | ExecutionException e) { @@ -67,32 +148,167 @@ public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable @Override public void close() throws Exception { LOG.info("InterfacemgrProvider Closed"); - interfaceManager.close(); - ifmNcListener.close(); + interfaceConfigListener.close(); + rpcRegistration.close(); + } + + public RpcProviderRegistry getRpcProviderRegistry() { + return rpcProviderRegistry; } @Override public Long getPortForInterface(String ifName) { - return interfaceManager.getPortForInterface(ifName); + GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(ifName).build(); + Future> output = interfaceManagerRpcService.getPortFromInterface(input); + try { + RpcResult port = output.get(); + if(port.isSuccessful()){ + return port.getResult().getPortno(); + } + }catch(NullPointerException | InterruptedException | ExecutionException e){ + LOG.warn("Exception when getting port for interface",e); + } + return null; + } + + @Override + public Long getPortForInterface(Interface intf) { + GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(intf.getName()).build(); + Future> output = interfaceManagerRpcService.getPortFromInterface(input); + try { + RpcResult port = output.get(); + if(port.isSuccessful()){ + return port.getResult().getPortno(); + } + }catch(NullPointerException | InterruptedException | ExecutionException e){ + LOG.warn("Exception when getting port for interface",e); + } + return null; } @Override - public long getDpnForInterface(String ifName) { - return interfaceManager.getDpnForInterface(ifName); + public InterfaceInfo getInterfaceInfo(String interfaceName) { + //FIXME [ELANBE] This is not working yet, fix this + + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface + ifState = InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName,dataBroker); + + if(ifState == null){ + LOG.error("Interface {} is not present", interfaceName); + return null; + } + + Integer lportTag = ifState.getIfIndex(); + Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker); + + NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(intf, dataBroker); + InterfaceInfo.InterfaceType interfaceType = IfmUtil.getInterfaceType(intf); + InterfaceInfo interfaceInfo = null; + BigInteger dpId = org.opendaylight.vpnservice.interfacemgr.globals.IfmConstants.INVALID_DPID; + Integer portNo = org.opendaylight.vpnservice.interfacemgr.globals.IfmConstants.INVALID_PORT_NO; + if (ncId !=null ) { + dpId = new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId)); + portNo = Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId)); + } + + if(interfaceType == InterfaceInfo.InterfaceType.VLAN_INTERFACE){ + interfaceInfo = IfmUtil.getVlanInterfaceInfo(interfaceName, intf, dpId); + } else if (interfaceType == InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE || interfaceType == InterfaceInfo.InterfaceType.GRE_TRUNK_INTERFACE) {/* + trunkInterfaceInfo trunkInterfaceInfo = (TrunkInterfaceInfo) ConfigIfmUtil.getTrunkInterfaceInfo(ifName, ConfigIfmUtil.getInterfaceByIfName(dataBroker, ifName)); + String higherLayerIf = inf.getHigherLayerIf().get(0); + Interface vlanInterface = ConfigIfmUtil.getInterfaceByIfName(dataBroker, higherLayerIf); + trunkInterfaceInfo.setPortName(vlanInterface.getAugmentation(BaseConfig.class).getParentInterface()); + trunkInterfaceManager.updateTargetMacAddressInInterfaceInfo(trunkInterfaceInfo, trunkInterface); + if (trunkInterface.getPhysAddress() != null) { + trunkInterfaceInfo.setLocalMacAddress(trunkInterface.getPhysAddress().getValue()); + } + interfaceInfo = trunkInterfaceInfo; + interfaceInfo.setL2domainGroupId(IfmUtil.getGroupId(OperationalIfmUtil.getInterfaceStateByIfName(dataBroker, higherLayerIf).getIfIndex(), InterfaceType.VLAN_INTERFACE)); + */} else { + LOG.error("Type of Interface {} is unknown", interfaceName); + return null; + } + interfaceInfo.setDpId(dpId); + interfaceInfo.setPortNo(portNo); + interfaceInfo.setAdminState((intf.isEnabled() == true) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED); + interfaceInfo.setInterfaceName(interfaceName); + interfaceInfo.setInterfaceTag(lportTag); + interfaceInfo.setInterfaceType(interfaceType); + interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType)); + interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN); + + + return interfaceInfo; + + } + + @Override + public InterfaceInfo getInterfaceInfoFromOperationalDataStore(String interfaceName, InterfaceInfo.InterfaceType interfaceType) { + InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName); + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = InterfaceManagerCommonUtils + .getInterfaceStateFromOperDS(interfaceName, dataBroker); + if (ifState == null) { + LOG.error("Interface {} is not present", interfaceName); + return null; + } + Integer lportTag = ifState.getIfIndex(); + Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker); + NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(intf, dataBroker); + if (ncId != null) { + interfaceInfo.setDpId(new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId))); + interfaceInfo.setPortNo(Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId))); + } + interfaceInfo.setAdminState((intf.isEnabled() == true) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED); + interfaceInfo.setInterfaceName(interfaceName); + interfaceInfo.setInterfaceTag(lportTag); + interfaceInfo.setInterfaceType(interfaceType); + interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType)); + interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN); + + + return interfaceInfo; + } + + @Override + public BigInteger getDpnForInterface(String ifName) { + GetDpidFromInterfaceInput input = new GetDpidFromInterfaceInputBuilder().setIntfName(ifName).build(); + Future> output = interfaceManagerRpcService.getDpidFromInterface(input); + try { + RpcResult dpn = output.get(); + if(dpn.isSuccessful()){ + return dpn.getResult().getDpid(); + } + }catch(NullPointerException | InterruptedException | ExecutionException e){ + LOG.warn("Exception when getting port for interface",e); + } + return null; } @Override - public String getEndpointIpForDpn(long dpnId) { - return interfaceManager.getEndpointIpForDpn(dpnId); + public String getEndpointIpForDpn(BigInteger dpnId) { + GetEndpointIpForDpnInput input = new GetEndpointIpForDpnInputBuilder().setDpid(dpnId).build(); + Future> output = interfaceManagerRpcService.getEndpointIpForDpn(input); + try { + RpcResult ipForDpnOutputRpcResult = output.get(); + if(ipForDpnOutputRpcResult.isSuccessful()){ + List localIps = ipForDpnOutputRpcResult.getResult().getLocalIps(); + if(!localIps.isEmpty()) { + return localIps.get(0).getIpv4Address().getValue(); + } + } + }catch(NullPointerException | InterruptedException | ExecutionException e){ + LOG.warn("Exception when getting port for interface",e); + } + return null; } @Override - public List getInterfaceIngressRule(String ifName) { - return interfaceManager.getInterfaceIngressRule(ifName); + public List getInterfaceEgressActions(String ifName) { + return interfaceManagerRpcService.getEgressActionInfosForInterface(ifName); } @Override - public List getInterfaceEgressActions(String ifName) { - return interfaceManager.getInterfaceEgressActions(ifName); + public BigInteger getDpnForInterface(Interface intrf) { + return getDpnForInterface(intrf.getName()); } -} +} \ No newline at end of file