From dcb58975f7374554fe15ae57010b15e9bc240ddd Mon Sep 17 00:00:00 2001 From: Sasidharan Sambasivam Date: Thu, 4 Jun 2015 15:45:34 +0530 Subject: [PATCH] Handling port up down event for Bug 3558 Change-Id: Ic76ec245aca3d0557a62ec88b6ae17585b3e81fb Signed-off-by: Sasidharan Sambasivam (cherry picked from commit 6284a153d3f187e71892b4bd472a654051b0df5f) --- .../interfaces/IInterfaceManager.java | 1 + .../vpnservice/interfacemgr/IfmUtil.java | 7 + .../interfacemgr/InterfaceManager.java | 24 ++- .../interfacemgr/InterfacemgrProvider.java | 6 + .../mdsalutil/internal/MDSALManager.java | 1 + .../vpnservice/nexthopmgr/NexthopManager.java | 4 +- .../vpnservice/InterfaceChangeListener.java | 82 ++++++++++ .../vpnservice/VpnInterfaceManager.java | 147 +++++++++++++++++- .../org/opendaylight/vpnservice/VpnUtil.java | 12 ++ .../vpnservice/VpnserviceProvider.java | 3 + 10 files changed, 280 insertions(+), 7 deletions(-) create mode 100644 vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/InterfaceChangeListener.java diff --git a/interfacemgr/interfacemgr-api/src/main/java/org/opendaylight/vpnservice/interfacemgr/interfaces/IInterfaceManager.java b/interfacemgr/interfacemgr-api/src/main/java/org/opendaylight/vpnservice/interfacemgr/interfaces/IInterfaceManager.java index 0923c934..8ef4efdb 100644 --- a/interfacemgr/interfacemgr-api/src/main/java/org/opendaylight/vpnservice/interfacemgr/interfaces/IInterfaceManager.java +++ b/interfacemgr/interfacemgr-api/src/main/java/org/opendaylight/vpnservice/interfacemgr/interfaces/IInterfaceManager.java @@ -23,5 +23,6 @@ public interface IInterfaceManager { public String getEndpointIpForDpn(BigInteger dpnId); public List getInterfaceIngressRule(String ifName); public List getInterfaceEgressActions(String ifName); + public Long getPortForInterface(Interface intf); } \ No newline at end of file diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/IfmUtil.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/IfmUtil.java index c36df7f3..a347d9a1 100644 --- a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/IfmUtil.java +++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/IfmUtil.java @@ -31,6 +31,13 @@ public class IfmUtil { return split[1]; } + public static String getPortNoFromNodeConnectorId(NodeConnectorId portId) { + /* + * NodeConnectorId is of form 'openflow:dpnid:portnum' + */ + String[] split = portId.getValue().split(IfmConstants.OF_URI_SEPARATOR); + return split[2]; + } public static NodeId buildDpnNodeId(BigInteger dpnId) { return new NodeId(IfmConstants.OF_URI_PREFIX + dpnId); diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java index 1543b57a..84d4350a 100644 --- a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java +++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java @@ -434,12 +434,34 @@ public class InterfaceManager extends AbstractDataChangeListener impl return getPortNumForInterface(iface); } + Long getPortForInterface(Interface intrf) { + try { + NodeConnector port = getNodeConnectorFromDataStore(intrf); + NodeConnectorId id = null; + if(port == null) { + id = getNodeConnectorIdFromInterface(intrf); + } else { + id = port.getId(); + } + String portNo = IfmUtil.getPortNoFromNodeConnectorId(id); + return Long.parseLong(portNo); + } catch (NullPointerException e) { + LOG.error("Port for Interface {} not found", intrf.getName(), e); + } + return 0L; + } public BigInteger getDpnForInterface(Interface intrf) { try { NodeConnector port = getNodeConnectorFromDataStore(intrf); + NodeConnectorId id = null; + if(port == null) { + id = getNodeConnectorIdFromInterface(intrf); + } else { + id = port.getId(); + } //TODO: This should be an MDSAL Util method - return new BigInteger(IfmUtil.getDpnFromNodeConnectorId(port.getId())); + return new BigInteger(IfmUtil.getDpnFromNodeConnectorId(id)); } catch (NullPointerException e) { LOG.error("dpn for Interface {} not found", intrf.getName(), e); } 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 c8166a7a..74074883 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 @@ -77,6 +77,12 @@ public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable return interfaceManager.getPortForInterface(ifName); } + @Override + public Long getPortForInterface(Interface intf) { + return interfaceManager.getPortForInterface(intf); + } + + @Override public BigInteger getDpnForInterface(String ifName) { return interfaceManager.getDpnForInterface(ifName); diff --git a/mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/vpnservice/mdsalutil/internal/MDSALManager.java b/mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/vpnservice/mdsalutil/internal/MDSALManager.java index fc9a5ff7..5ca603ca 100644 --- a/mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/vpnservice/mdsalutil/internal/MDSALManager.java +++ b/mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/vpnservice/mdsalutil/internal/MDSALManager.java @@ -172,6 +172,7 @@ public class MDSALManager implements AutoCloseable { public void removeFlow(FlowEntity flowEntity) { try { + s_logger.debug("Remove flow {}",flowEntity); Node nodeDpn = buildDpnNode(flowEntity.getDpnId()); FlowKey flowKey = new FlowKey(new FlowId(flowEntity.getFlowId())); InstanceIdentifier flowInstanceId = InstanceIdentifier.builder(Nodes.class) diff --git a/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java b/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java index 052ed98f..1543a819 100644 --- a/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java +++ b/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java @@ -210,7 +210,7 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { GroupEntity groupEntity = MDSALUtil.buildGroupEntity( dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo); mdsalManager.installGroup(groupEntity); - makeRemoteFlow(dpnId, ifName, NwConstants.ADD_FLOW); + //makeRemoteFlow(dpnId, ifName, NwConstants.ADD_FLOW); //update MD-SAL DS addTunnelNexthopToDS(dpnId, ipAddress, groupId); @@ -399,7 +399,7 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null); // remove Group ... mdsalManager.removeGroup(groupEntity); - makeRemoteFlow(dpnId, ifName, NwConstants.DEL_FLOW); + //makeRemoteFlow(dpnId, ifName, NwConstants.DEL_FLOW); //update MD-SAL DS removeTunnelNexthopFromDS(dpnId, ipAddress); } else { diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/InterfaceChangeListener.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/InterfaceChangeListener.java new file mode 100644 index 00000000..7e054145 --- /dev/null +++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/InterfaceChangeListener.java @@ -0,0 +1,82 @@ +package org.opendaylight.vpnservice; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class InterfaceChangeListener extends AbstractDataChangeListener implements AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(InterfaceChangeListener.class); + + private ListenerRegistration listenerRegistration; + private final DataBroker broker; + private VpnInterfaceManager vpnInterfaceManager; + + + public InterfaceChangeListener(final DataBroker db, VpnInterfaceManager vpnInterfaceManager) { + super(Interface.class); + broker = db; + this.vpnInterfaceManager = vpnInterfaceManager; + registerListener(db); + } + + @Override + public void close() throws Exception { + if (listenerRegistration != null) { + try { + listenerRegistration.close(); + } catch (final Exception e) { + LOG.error("Error when cleaning up DataChangeListener.", e); + } + listenerRegistration = null; + } + LOG.info("Interface listener Closed"); + } + + + private void registerListener(final DataBroker db) { + try { + listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, + getWildCardPath(), InterfaceChangeListener.this, DataChangeScope.SUBTREE); + } catch (final Exception e) { + LOG.error("Interface DataChange listener registration failed", e); + throw new IllegalStateException("Nexthop Manager registration Listener failed.", e); + } + } + + @Override + protected void add(InstanceIdentifier identifier, Interface intrf) { + LOG.trace("Adding Interface : key: " + identifier + ", value=" + intrf ); + + } + + + private InstanceIdentifier getWildCardPath() { + return InstanceIdentifier.create(Interfaces.class).child(Interface.class); + } + + @Override + protected void remove(InstanceIdentifier identifier, Interface intrf) { + LOG.trace("Remove interface event - key: {}, value: {}", identifier, intrf ); + VpnInterface vpnInterface = vpnInterfaceManager.getVpnInterface(intrf.getName()); + InstanceIdentifier id = VpnUtil.getVpnInterfaceIdentifier(intrf.getName()); + LOG.debug("Removing VPN Interface associated with Interface {}", intrf.getName()); + vpnInterfaceManager.remove(id, vpnInterface); + } + + @Override + protected void update(InstanceIdentifier identifier, + Interface original, Interface update) { + // TODO Auto-generated method stub + + } + +} diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java index e2101882..92f990df 100644 --- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java +++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java @@ -35,6 +35,7 @@ import org.opendaylight.vpnservice.mdsalutil.MDSALUtil; import org.opendaylight.vpnservice.mdsalutil.MatchFieldType; import org.opendaylight.vpnservice.mdsalutil.MatchInfo; import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil; +import org.opendaylight.vpnservice.mdsalutil.NwConstants; import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.binding.DataObject; @@ -46,8 +47,10 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState; 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.l3vpn.rev130911.AdjacencyList; import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency; import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder; @@ -71,7 +74,7 @@ import org.slf4j.LoggerFactory; public class VpnInterfaceManager extends AbstractDataChangeListener implements AutoCloseable { private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceManager.class); - private ListenerRegistration listenerRegistration; + private ListenerRegistration listenerRegistration, interfaceListenerRegistration; private final DataBroker broker; private final IBgpManager bgpManager; private IFibManager fibManager; @@ -80,6 +83,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener> vpnToDpnsDb; private Map> dpnToInterfaceDb; + private InterfaceListener interfaceListener; private static final FutureCallback DEFAULT_CALLBACK = new FutureCallback() { @@ -104,6 +108,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener(); dpnToInterfaceDb = new ConcurrentHashMap<>(); + interfaceListener = new InterfaceListener(); registerListener(db); } @@ -128,10 +133,12 @@ public class VpnInterfaceManager extends AbstractDataChangeListener getInterfaceListenerPath() { + return InstanceIdentifier.create(InterfacesState.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class); + } + @Override protected void add(final InstanceIdentifier identifier, final VpnInterface vpnInterface) { @@ -407,16 +421,17 @@ public class VpnInterfaceManager extends AbstractDataChangeListener optVpnInterfaces = read(LogicalDatastoreType.CONFIGURATION, VpnUtil.getVpnInterfacesIdentifier()); + if(optVpnInterfaces.isPresent()) { + List interfaces = optVpnInterfaces.get().getVpnInterface(); + for(VpnInterface intf : interfaces) { + if(intf.getName().equals(interfaceName)) { + return intf; + } + } + } + return null; + } + + private Interface getInterface(String interfaceName) { + Optional optInterface = read(LogicalDatastoreType.CONFIGURATION, VpnUtil.getInterfaceIdentifier(interfaceName)); + if(optInterface.isPresent()) { + return optInterface.get(); + } + return null; + } + + private String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) { + return new StringBuilder().append(dpnId).append(tableId).append(ifName).toString(); + } + + + private void makeTunnelIngressFlow(BigInteger dpnId, String ifName, int addOrRemoveFlow) { + long portNo = 0; + String flowName = ifName; + String flowRef = getTunnelInterfaceFlowRef(dpnId, VpnConstants.LPORT_INGRESS_TABLE, ifName); + List matches = new ArrayList(); + List mkInstructions = new ArrayList(); + if (NwConstants.ADD_FLOW == addOrRemoveFlow) { + portNo = interfaceManager.getPortForInterface(ifName); + matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] { + dpnId, BigInteger.valueOf(portNo) })); + mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] {VpnConstants.LFIB_TABLE})); + } + + BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16); + FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId, VpnConstants.LPORT_INGRESS_TABLE, flowRef, + VpnConstants.DEFAULT_FLOW_PRIORITY, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions); + + if (NwConstants.ADD_FLOW == addOrRemoveFlow) { + mdsalManager.installFlow(flowEntity); + } else { + mdsalManager.removeFlow(flowEntity); + } + } + + private class InterfaceListener extends AbstractDataChangeListener { + + public InterfaceListener() { + super(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class); + } + + @Override + protected void remove(InstanceIdentifier identifier, + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface del) { + LOG.trace("Operational Interface remove event - {}", del); + } + + @Override + protected void update(InstanceIdentifier identifier, + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface original, + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface update) { + LOG.trace("Operation Interface update event - Old: {}, New: {}", original, update); + String interfaceName = update.getName(); + Interface intf = getInterface(interfaceName); + if (intf != null && intf.getType().equals(L3tunnel.class)) { + BigInteger dpnId = interfaceManager.getDpnForInterface(interfaceName); + if(update.getOperStatus().equals(OperStatus.Up)) { + //Create ingress to LFIB + LOG.debug("Installing Ingress for tunnel interface {}", interfaceName); + makeTunnelIngressFlow(dpnId, interfaceName, NwConstants.ADD_FLOW); + } else if(update.getOperStatus().equals(OperStatus.Down)) { + LOG.debug("Removing Ingress flow for tunnel interface {}", interfaceName); + makeTunnelIngressFlow(dpnId, interfaceName, NwConstants.DEL_FLOW); + } + } else { + VpnInterface vpnInterface = getVpnInterface(interfaceName); + if(vpnInterface != null) { + if(update.getOperStatus().equals(OperStatus.Up)) { + LOG.debug("Installing VPN related rules for interface {}", interfaceName); + addInterface(VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName()), vpnInterface); + } else if(update.getOperStatus().equals(OperStatus.Down)) { + LOG.debug("Removing VPN related rules for interface {}", interfaceName); + VpnInterfaceManager.this.remove(VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName()), vpnInterface); + } + } else { + LOG.debug("No VPN Interface associated with interface {} to handle Update Operation", interfaceName); + } + } + } + + @Override + protected void add(InstanceIdentifier identifier, + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface add) { + LOG.trace("Operational Interface add event - {}", add); + String interfaceName = add.getName(); + Interface intf = getInterface(interfaceName); + if (intf != null && intf.getType().equals(L3tunnel.class)) { + BigInteger dpnId = interfaceManager.getDpnForInterface(interfaceName); + if(add.getOperStatus().equals(OperStatus.Up)) { + //Create ingress to LFIB + LOG.debug("Installing Ingress for tunnel interface {}", interfaceName); + makeTunnelIngressFlow(dpnId, interfaceName, NwConstants.ADD_FLOW); + } + } else { + VpnInterface vpnInterface = getVpnInterface(interfaceName); + if(vpnInterface != null) { + if(add.getOperStatus().equals(OperStatus.Up)) { + LOG.debug("Installing VPN related rules for interface {}", interfaceName); + addInterface(VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName()), vpnInterface); + } + } else { + LOG.debug("No VPN Interface associated with interface {} to handle add Operation", interfaceName); + } + } + } + } } diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java index fe879013..9befc1fa 100644 --- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java +++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java @@ -19,6 +19,9 @@ import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev14081 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface; import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey; import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +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.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency; import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies; import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder; @@ -54,4 +57,13 @@ public class VpnUtil { InstanceIdentifier id = idBuilder.build(); return id; } + + static InstanceIdentifier getVpnInterfacesIdentifier() { + return InstanceIdentifier.builder(VpnInterfaces.class).build(); + } + + static InstanceIdentifier getInterfaceIdentifier(String interfaceName) { + return InstanceIdentifier.builder(Interfaces.class) + .child(Interface.class, new InterfaceKey(interfaceName)).build(); + } } diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java index a5198ba7..ab166622 100644 --- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java +++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java @@ -39,6 +39,7 @@ public class VpnserviceProvider implements BindingAwareProvider, IVpnManager, private IMdsalApiManager mdsalManager; private IInterfaceManager interfaceManager; private IdManagerService idManager; + private InterfaceChangeListener interfaceListener; @Override public void onSessionInitiated(ProviderContext session) { @@ -52,6 +53,7 @@ public class VpnserviceProvider implements BindingAwareProvider, IVpnManager, vpnInterfaceManager.setInterfaceManager(interfaceManager); vpnInterfaceManager.setIdManager(idManager); vpnManager.setVpnInterfaceManager(vpnInterfaceManager); + interfaceListener = new InterfaceChangeListener(dataBroker, vpnInterfaceManager); createIdPool(); } catch (Exception e) { LOG.error("Error initializing services", e); @@ -99,6 +101,7 @@ public class VpnserviceProvider implements BindingAwareProvider, IVpnManager, public void close() throws Exception { vpnManager.close(); vpnInterfaceManager.close(); + interfaceListener.close(); } @Override -- 2.36.6