From: Tom Pantelis Date: Thu, 14 Dec 2017 17:48:34 +0000 (-0500) Subject: Replace DataStoreCache with DataObjectCache in itm-impl X-Git-Tag: release/oxygen~46 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=5a4c5264714f1b3c1aee617ef5905c771ac9ac71;hp=0974b7935ff0075c090e6f79ff9d7140300c28b1;p=genius.git Replace DataStoreCache with DataObjectCache in itm-impl There were 4 different caches to convert. 2 of them, TunnelMonitorParams and TunnelMonitorInterval, are singleton DataObjects use for global tunnel monitorng configuration. These seem to be condidates for clustered-app-config however dynamic updates would restrart the BP container but it doesn't appear itm-impl is ready for that. So to preserve existing behavior, they're DataObjectCache instances local to a new TunnelMonitoringConfig class. The other 2 caches were replaced by DataObjectCache subclasses, DPNTEPsInfoCache and TunnelStateCache, and injected where needed. Change-Id: I4e4ed505fa46a5af05086436a7593d92d2bdb56c Signed-off-by: Tom Pantelis --- diff --git a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/api/IITMProvider.java b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/api/IITMProvider.java index c4528c901..d1407846c 100644 --- a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/api/IITMProvider.java +++ b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/api/IITMProvider.java @@ -8,6 +8,7 @@ package org.opendaylight.genius.itm.api; import java.math.BigInteger; +import java.util.Collection; import java.util.List; import org.apache.felix.service.command.CommandSession; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -27,7 +28,7 @@ public interface IITMProvider { void showTeps(CommandSession session); - void showState(List tunnels, CommandSession session); + void showState(Collection tunnels, CommandSession session); void showCache(String cacheName); diff --git a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/globals/ITMConstants.java b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/globals/ITMConstants.java index d7ab31c6e..fd4769162 100644 --- a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/globals/ITMConstants.java +++ b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/globals/ITMConstants.java @@ -46,12 +46,6 @@ public interface ITMConstants { String DEFAULT_TRANSPORT_ZONE = "default-transport-zone"; Class DEFAULT_MONITOR_PROTOCOL = TunnelMonitoringTypeBfd.class; - String ITM_MONIRORING_PARAMS_CACHE_NAME = "ItmMonitoringParamsCache"; - String TUNNEL_STATE_CACHE_NAME = "ItmTunnelStateCache"; - // FIXME: the following annotation should be removed once the itm-impl - // changes the name - @SuppressWarnings("checkstyle:ConstantName") - String DPN_TEPs_Info_CACHE_NAME = "ItmDpnTepsInfoCache"; String INTERNAL_TUNNEL_CACHE_NAME = "InternalTunnelCache"; String EXTERNAL_TUNNEL_CACHE_NAME = "ExternalTunnelCache"; String TUNNEL_STATE_UP = "UP"; diff --git a/itm/itm-impl/pom.xml b/itm/itm-impl/pom.xml index 11bdf4fd2..c6ab4a25b 100644 --- a/itm/itm-impl/pom.xml +++ b/itm/itm-impl/pom.xml @@ -150,6 +150,12 @@ and is available at http://www.eclipse.org/legal/epl-v10.html ${project.version} test + + org.opendaylight.infrautils + caches-test + ${genius.infrautils.version} + test + diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java new file mode 100644 index 000000000..bab5525ad --- /dev/null +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017 Inocybe Technologies 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, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.genius.itm.cache; + +import javax.inject.Inject; +import javax.inject.Singleton; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.mdsalutil.cache.DataObjectCache; +import org.opendaylight.infrautils.caches.CacheProvider; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +/** + * Caches DPNTEPsInfo objects. + * + * @author Thomas Pantelis + */ +@SuppressWarnings("checkstyle:AbbreviationAsWordInName") +@Singleton +public class DPNTEPsInfoCache extends DataObjectCache { + + @Inject + public DPNTEPsInfoCache(DataBroker dataBroker, CacheProvider cacheProvider) { + super(DPNTEPsInfo.class, dataBroker, LogicalDatastoreType.CONFIGURATION, + InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class).build(), cacheProvider); + } +} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/TunnelStateCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/TunnelStateCache.java new file mode 100644 index 000000000..2229752b3 --- /dev/null +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/TunnelStateCache.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017 Inocybe Technologies 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, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.genius.itm.cache; + +import javax.inject.Inject; +import javax.inject.Singleton; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.mdsalutil.cache.DataObjectCache; +import org.opendaylight.infrautils.caches.CacheProvider; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +/** + * Caches StateTunnelList objects. + * + * @author Thomas Pantelis + */ +@Singleton +public class TunnelStateCache extends DataObjectCache { + + @Inject + public TunnelStateCache(DataBroker dataBroker, CacheProvider cacheProvider) { + super(StateTunnelList.class, dataBroker, LogicalDatastoreType.OPERATIONAL, + InstanceIdentifier.builder(TunnelsState.class).child(StateTunnelList.class).build(), cacheProvider); + } +} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java index 2c3096307..7a7909744 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java @@ -703,7 +703,7 @@ public class TepCommandHelper { } @SuppressWarnings("checkstyle:RegexpSinglelineJava") - public void showState(List tunnelLists, boolean tunnelMonitorEnabled, + public void showState(Collection tunnelLists, boolean tunnelMonitorEnabled, CommandSession session) throws TepException { if (tunnelLists == null || tunnelLists.isEmpty()) { handleError("No Internal Tunnels Exist", session); diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepShowState.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepShowState.java index a5afe4580..78f52350e 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepShowState.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepShowState.java @@ -7,41 +7,33 @@ */ package org.opendaylight.genius.itm.cli; -import java.util.ArrayList; -import java.util.List; +import java.util.Collection; import org.apache.karaf.shell.commands.Command; import org.apache.karaf.shell.console.OsgiCommandSupport; import org.opendaylight.genius.itm.api.IITMProvider; -import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; +import org.opendaylight.genius.itm.cache.TunnelStateCache; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList; @Command(scope = "tep", name = "show-state", description = "Monitors tunnel state") public class TepShowState extends OsgiCommandSupport { - private IITMProvider itmProvider; + private final IITMProvider itmProvider; + private final TunnelStateCache tunnelStateCache; - public void setItmProvider(IITMProvider itmProvider) { + public TepShowState(IITMProvider itmProvider, TunnelStateCache tunnelStateCache) { this.itmProvider = itmProvider; + this.tunnelStateCache = tunnelStateCache; } @Override protected Object doExecute() { - List tunnels = null ; - List values = null ; - values = DataStoreCache.getValues(ITMConstants.TUNNEL_STATE_CACHE_NAME); - if (values != null) { - tunnels = new ArrayList<>() ; - for (Object value : values) { - tunnels.add((StateTunnelList)value); - } - } - if (tunnels != null) { + Collection tunnels = tunnelStateCache.getAllPresent(); + if (!tunnels.isEmpty()) { itmProvider.showState(tunnels, session); } else { session.getConsole().println("No Internal Tunnels configured on the switch"); } return null; } -} \ No newline at end of file +} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelAddWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelAddWorker.java index f27fb49c5..7e8d7564e 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelAddWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelAddWorker.java @@ -11,12 +11,14 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.ListenableFuture; import java.math.BigInteger; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.List; import org.apache.commons.net.util.SubnetUtils; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.globals.ITMConstants; import org.opendaylight.genius.itm.impl.ItmUtils; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; @@ -45,19 +47,21 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public final class ItmExternalTunnelAddWorker { +public class ItmExternalTunnelAddWorker { private static final Logger LOG = LoggerFactory.getLogger(ItmExternalTunnelAddWorker.class); - private static Integer monitorInterval; - private static Class monitorProtocol; + private final DataBroker dataBroker; + private final ItmConfig itmConfig; + private final DPNTEPsInfoCache dpnTEPsInfoCache; - private ItmExternalTunnelAddWorker() { } + public ItmExternalTunnelAddWorker(DataBroker dataBroker, ItmConfig itmConfig, DPNTEPsInfoCache dpnTEPsInfoCache) { + this.dataBroker = dataBroker; + this.itmConfig = itmConfig; + this.dpnTEPsInfoCache = dpnTEPsInfoCache; + } - public static List> buildTunnelsToExternalEndPoint(DataBroker dataBroker, - List cfgDpnList, - IpAddress extIp, - Class tunType, - ItmConfig itmConfig) { + public List> buildTunnelsToExternalEndPoint(Collection cfgDpnList, + IpAddress extIp, Class tunType) { if (null != cfgDpnList) { WriteTransaction transaction = dataBroker.newWriteOnlyTransaction(); for (DPNTEPsInfo teps : cfgDpnList) { @@ -103,31 +107,26 @@ public final class ItmExternalTunnelAddWorker { return Collections.emptyList(); } - public static List> buildTunnelsFromDpnToExternalEndPoint(DataBroker dataBroker, - List dpnId, - IpAddress extIp, - Class - tunType, - ItmConfig itmConfig) { - List cfgDpnList = dpnId == null ? ItmUtils.getTunnelMeshInfo(dataBroker) - : ItmUtils.getDpnTepListFromDpnId(dataBroker, dpnId); - return buildTunnelsToExternalEndPoint(dataBroker, cfgDpnList, extIp, tunType, itmConfig); + public List> buildTunnelsFromDpnToExternalEndPoint(List dpnId, IpAddress extIp, + Class tunType) { + Collection cfgDpnList = dpnId == null ? dpnTEPsInfoCache.getAllPresent() + : ItmUtils.getDpnTepListFromDpnId(dpnTEPsInfoCache, dpnId); + return buildTunnelsToExternalEndPoint(cfgDpnList, extIp, tunType); } - public static List> buildHwVtepsTunnels(DataBroker dataBroker, - List cfgdDpnList, - List cfgdHwVteps) { + public List> buildHwVtepsTunnels(List cfgdDpnList, List cfgdHwVteps) { + Integer monitorInterval = ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL; + Class monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL; + List> futures = new ArrayList<>(); WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); - monitorInterval = ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL; - monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL; if (null != cfgdDpnList && !cfgdDpnList.isEmpty()) { LOG.trace("calling tunnels from css {}",cfgdDpnList); - tunnelsFromCSS(cfgdDpnList, writeTransaction , dataBroker); + tunnelsFromCSS(cfgdDpnList, writeTransaction, monitorInterval, monitorProtocol); } if (null != cfgdHwVteps && !cfgdHwVteps.isEmpty()) { LOG.trace("calling tunnels from hwTep {}",cfgdHwVteps); - tunnelsFromhWVtep(cfgdHwVteps, writeTransaction, dataBroker); + tunnelsFromhWVtep(cfgdHwVteps, writeTransaction, monitorInterval, monitorProtocol); } if (cfgdDpnList != null && !cfgdDpnList.isEmpty() || cfgdHwVteps != null && !cfgdHwVteps.isEmpty()) { @@ -136,24 +135,24 @@ public final class ItmExternalTunnelAddWorker { return futures; } - private static void tunnelsFromCSS(List cfgdDpnList, - WriteTransaction transaction, - DataBroker dataBroker) { + private void tunnelsFromCSS(List cfgdDpnList, WriteTransaction transaction, Integer monitorInterval, + Class monitorProtocol) { for (DPNTEPsInfo dpn : cfgdDpnList) { LOG.trace("processing dpn {}" , dpn); if (dpn.getTunnelEndPoints() != null && !dpn.getTunnelEndPoints().isEmpty()) { for (TunnelEndPoints tep : dpn.getTunnelEndPoints()) { for (TzMembership zone: tep.getTzMembership()) { createTunnelsFromOVSinTransportZone(zone.getZoneName(), dpn, tep, - transaction, dataBroker); + transaction, monitorInterval, monitorProtocol); } } } } } - private static void createTunnelsFromOVSinTransportZone(String zoneName, DPNTEPsInfo dpn, TunnelEndPoints tep, - WriteTransaction transaction, DataBroker dataBroker) { + private void createTunnelsFromOVSinTransportZone(String zoneName, DPNTEPsInfo dpn, TunnelEndPoints tep, + WriteTransaction transaction, Integer monitorInterval, + Class monitorProtocol) { InstanceIdentifier tzonePath = InstanceIdentifier.builder(TransportZones.class) .child(TransportZone.class, new TransportZoneKey(zoneName)).build(); Optional transportZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, @@ -176,7 +175,8 @@ public final class ItmExternalTunnelAddWorker { if (!wireUp(dpn.getDPNID(), tep.getPortname(), sub.getVlanId(), tep.getIpAddress(), useOfTunnel, nodeId, hwVtepDS.getIpAddress(), tep.getSubnetMask(), sub.getGatewayIp(), sub.getPrefix(), - transportZone.getTunnelType(), false, transaction)) { + transportZone.getTunnelType(), false, monitorInterval, monitorProtocol, + transaction)) { LOG.error("Unable to build tunnel {} -- {}", tep.getIpAddress(), hwVtepDS.getIpAddress()); } @@ -184,8 +184,8 @@ public final class ItmExternalTunnelAddWorker { LOG.trace("wire up {} and {}", hwVtepDS,tep); if (!wireUp(hwVtepDS.getTopologyId(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(), cssID, tep.getIpAddress(), sub.getPrefix(), sub.getGatewayIp(), - tep.getSubnetMask(), transportZone.getTunnelType(), false, - transaction)) { + tep.getSubnetMask(), transportZone.getTunnelType(), false, monitorInterval, + monitorProtocol, transaction)) { LOG.error("Unable to build tunnel {} -- {}", hwVtepDS.getIpAddress(), tep.getIpAddress()); } @@ -197,9 +197,8 @@ public final class ItmExternalTunnelAddWorker { } } - private static void tunnelsFromhWVtep(List cfgdHwVteps, - WriteTransaction transaction, - DataBroker dataBroker) { + private void tunnelsFromhWVtep(List cfgdHwVteps, WriteTransaction transaction, + Integer monitorInterval, Class monitorProtocol) { for (HwVtep hwTep : cfgdHwVteps) { InstanceIdentifier tzonePath = InstanceIdentifier.builder(TransportZones.class) .child(TransportZone.class, new TransportZoneKey(hwTep.getTransportZone())).build(); @@ -219,8 +218,8 @@ public final class ItmExternalTunnelAddWorker { LOG.trace("wire up {} and {}",hwTep, hwVtepDS); if (!wireUp(hwTep.getTopoId(), hwTep.getNodeId(), hwTep.getHwIp(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(), hwTep.getIpPrefix(), - hwTep.getGatewayIP(), sub.getPrefix(), tunType,false, - transaction)) { + hwTep.getGatewayIP(), sub.getPrefix(), tunType, false, + monitorInterval, monitorProtocol, transaction)) { LOG.error("Unable to build tunnel {} -- {}", hwTep.getHwIp(), hwVtepDS.getIpAddress()); } @@ -228,8 +227,8 @@ public final class ItmExternalTunnelAddWorker { LOG.trace("wire up {} and {}", hwVtepDS,hwTep); if (!wireUp(hwTep.getTopoId(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(), hwTep.getNodeId(), hwTep.getHwIp(), sub.getPrefix(), sub.getGatewayIp(), - hwTep.getIpPrefix(), tunType, false, - transaction)) { + hwTep.getIpPrefix(), tunType, false, monitorInterval, + monitorProtocol, transaction)) { LOG.error("Unable to build tunnel {} -- {}", hwVtepDS.getIpAddress(), hwTep.getHwIp()); } @@ -245,7 +244,7 @@ public final class ItmExternalTunnelAddWorker { LOG.trace("wire up {} and {}",hwTep, vtep); if (!wireUp(hwTep.getTopoId(), hwTep.getNodeId(), hwTep.getHwIp(), cssID, vtep.getIpAddress(), hwTep.getIpPrefix(), hwTep.getGatewayIP(), - sub.getPrefix(), tunType,false, + sub.getPrefix(), tunType,false, monitorInterval, monitorProtocol, transaction)) { LOG.error("Unable to build tunnel {} -- {}", hwTep.getHwIp(), vtep.getIpAddress()); @@ -255,7 +254,8 @@ public final class ItmExternalTunnelAddWorker { boolean useOfTunnel = ItmUtils.falseIfNull(vtep.isOptionOfTunnel()); if (!wireUp(vtep.getDpnId(), vtep.getPortname(), sub.getVlanId(), vtep.getIpAddress(), useOfTunnel, hwTep.getNodeId(),hwTep.getHwIp(),sub.getPrefix(), - sub.getGatewayIp(), hwTep.getIpPrefix(), tunType, false, transaction)) { + sub.getGatewayIp(),hwTep.getIpPrefix(), tunType, false, + monitorInterval, monitorProtocol, transaction)) { //do nothing } } @@ -268,10 +268,10 @@ public final class ItmExternalTunnelAddWorker { } //for tunnels from TOR device - private static boolean wireUp(String topoId, String srcNodeid, IpAddress srcIp, String dstNodeId, IpAddress dstIp, - IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet, - Class tunType, Boolean monitorEnabled, - WriteTransaction transaction) { + private boolean wireUp(String topoId, String srcNodeid, IpAddress srcIp, String dstNodeId, IpAddress dstIp, + IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet, Class tunType, + Boolean monitorEnabled, Integer monitorInterval, Class monitorProtocol, + WriteTransaction transaction) { IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray()); IpAddress gwyIpAddress = srcSubnet.equals(dstSubnet) ? gatewayIpObj : gwIp; String parentIf = ItmUtils.getHwParentIf(topoId, srcNodeid); @@ -301,10 +301,10 @@ public final class ItmExternalTunnelAddWorker { } //for tunnels from OVS - private static boolean wireUp(BigInteger dpnId, String portname, Integer vlanId, IpAddress srcIp, - Boolean remoteIpFlow, String dstNodeId, IpAddress dstIp, IpPrefix srcSubnet, - IpAddress gwIp, IpPrefix dstSubnet, Class tunType, - Boolean monitorEnabled, WriteTransaction transaction) { + private boolean wireUp(BigInteger dpnId, String portname, Integer vlanId, IpAddress srcIp, Boolean remoteIpFlow, + String dstNodeId, IpAddress dstIp, IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet, + Class tunType, Boolean monitorEnabled, Integer monitorInterval, + Class monitorProtocol, WriteTransaction transaction) { IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray()); IpAddress gwyIpAddress = srcSubnet.equals(dstSubnet) ? gatewayIpObj : gwIp; String parentIf = ItmUtils.getInterfaceName(dpnId, portname, vlanId); diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java index 5fa59928c..6cff0ff3c 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java @@ -11,6 +11,7 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.ListenableFuture; import java.math.BigInteger; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.List; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -42,7 +43,7 @@ public final class ItmExternalTunnelDeleteWorker { private ItmExternalTunnelDeleteWorker() { } public static List> deleteTunnels(DataBroker dataBroker, - List dpnTepsList, List meshedDpnList, IpAddress extIp, + Collection dpnTepsList, Collection meshedDpnList, IpAddress extIp, Class tunType) { LOG.trace(" Delete Tunnels towards DC Gateway with Ip {}", extIp); @@ -82,7 +83,7 @@ public final class ItmExternalTunnelDeleteWorker { } public static List> deleteTunnels(DataBroker dataBroker, - List dpnTepsList, IpAddress extIp, Class tunType) { + Collection dpnTepsList, IpAddress extIp, Class tunType) { LOG.trace(" Delete Tunnels towards DC Gateway with Ip {}", extIp); if (dpnTepsList == null || dpnTepsList.isEmpty()) { diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelAddWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelAddWorker.java index cdf632f52..e30b39e67 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelAddWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelAddWorker.java @@ -12,6 +12,7 @@ import static java.util.Collections.singletonList; import com.google.common.util.concurrent.ListenableFuture; import java.math.BigInteger; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.concurrent.Callable; @@ -22,6 +23,7 @@ import org.opendaylight.genius.infra.ManagedNewTransactionRunner; import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl; import org.opendaylight.genius.itm.impl.ITMBatchingUtils; import org.opendaylight.genius.itm.impl.ItmUtils; +import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; @@ -47,27 +49,30 @@ import org.slf4j.LoggerFactory; public final class ItmInternalTunnelAddWorker { private static final Logger LOG = LoggerFactory.getLogger(ItmInternalTunnelAddWorker.class) ; - private static Boolean monitorEnabled; - private static Integer monitorInterval; private static ItmConfig itmCfg; - private static Class monitorProtocol; + + private final Integer monitorInterval; + private final boolean isTunnelMonitoringEnabled; + private final Class monitorProtocol; private final DataBroker dataBroker; private final ManagedNewTransactionRunner txRunner; private final JobCoordinator jobCoordinator; - public ItmInternalTunnelAddWorker(DataBroker dataBroker, JobCoordinator jobCoordinator) { + public ItmInternalTunnelAddWorker(DataBroker dataBroker, JobCoordinator jobCoordinator, + TunnelMonitoringConfig tunnelMonitoringConfig) { this.dataBroker = dataBroker; this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker); this.jobCoordinator = jobCoordinator; + + isTunnelMonitoringEnabled = tunnelMonitoringConfig.isTunnelMonitoringEnabled(); + monitorProtocol = tunnelMonitoringConfig.getMonitorProtocol(); + monitorInterval = Integer.valueOf(tunnelMonitoringConfig.getMonitorInterval()); } public List> buildAllTunnels(IMdsalApiManager mdsalManager, List cfgdDpnList, - List meshedDpnList, ItmConfig itmConfig) { + Collection meshedDpnList, ItmConfig itmConfig) { LOG.trace("Building tunnels with DPN List {} " , cfgdDpnList); - monitorInterval = ItmUtils.determineMonitorInterval(dataBroker); - monitorProtocol = ItmUtils.determineMonitorProtocol(dataBroker); - monitorEnabled = ItmUtils.readMonitoringStateFromCache(dataBroker); itmCfg = itmConfig; if (null == cfgdDpnList || cfgdDpnList.isEmpty()) { LOG.error(" Build Tunnels was invoked with empty list"); @@ -96,7 +101,7 @@ public final class ItmInternalTunnelAddWorker { ITMBatchingUtils.update(dep, tnlBuilder, ITMBatchingUtils.EntityType.DEFAULT_CONFIG); } - private void buildTunnelFrom(DPNTEPsInfo srcDpn, List meshedDpnList, + private void buildTunnelFrom(DPNTEPsInfo srcDpn, Collection meshedDpnList, IMdsalApiManager mdsalManager, WriteTransaction transaction) { LOG.trace("Building tunnels from DPN {} " , srcDpn); if (null == meshedDpnList || meshedDpnList.isEmpty()) { @@ -179,9 +184,8 @@ public final class ItmInternalTunnelAddWorker { return true; } - private static void createTunnelInterface(TunnelEndPoints srcte, TunnelEndPoints dstte, - BigInteger srcDpnId, Class tunType, - String trunkInterfaceName, String parentInterfaceName) { + private void createTunnelInterface(TunnelEndPoints srcte, TunnelEndPoints dstte, BigInteger srcDpnId, + Class tunType, String trunkInterfaceName, String parentInterfaceName) { String gateway = srcte.getIpAddress().getIpv4Address() != null ? "0.0.0.0" : "::"; IpAddress gatewayIpObj = new IpAddress(gateway.toCharArray()); IpAddress gwyIpAddress = @@ -192,7 +196,8 @@ public final class ItmInternalTunnelAddWorker { boolean useOfTunnel = ItmUtils.falseIfNull(srcte.isOptionOfTunnel()); List tunOptions = ItmUtils.buildTunnelOptions(srcte, itmCfg); - Boolean isMonitorEnabled = tunType.isAssignableFrom(TunnelTypeLogicalGroup.class) ? false : monitorEnabled; + Boolean isMonitorEnabled = tunType.isAssignableFrom(TunnelTypeLogicalGroup.class) ? false + : isTunnelMonitoringEnabled; Interface iface = ItmUtils.buildTunnelInterface(srcDpnId, trunkInterfaceName, String.format("%s %s",ItmUtils.convertTunnelTypetoString(tunType), "Trunk Interface"), true, tunType, srcte.getIpAddress(), dstte.getIpAddress(), gwyIpAddress, srcte.getVLANID(), true, diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java index 79d8eefa9..6d65a0660 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java @@ -16,13 +16,13 @@ import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.concurrent.Callable; - import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.infra.ManagedNewTransactionRunner; import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl; import org.opendaylight.genius.itm.impl.ItmUtils; +import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; @@ -50,16 +50,19 @@ public class ItmInternalTunnelDeleteWorker { private final DataBroker dataBroker; private final ManagedNewTransactionRunner txRunner; private final JobCoordinator jobCoordinator; + private final TunnelMonitoringConfig tunnelMonitoringConfig; - public ItmInternalTunnelDeleteWorker(DataBroker dataBroker, JobCoordinator jobCoordinator) { + public ItmInternalTunnelDeleteWorker(DataBroker dataBroker, JobCoordinator jobCoordinator, + TunnelMonitoringConfig tunnelMonitoringConfig) { this.dataBroker = dataBroker; this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker); this.jobCoordinator = jobCoordinator; + this.tunnelMonitoringConfig = tunnelMonitoringConfig; } @SuppressWarnings("checkstyle:IllegalCatch") - public List> deleteTunnels(IMdsalApiManager mdsalManager, List dpnTepsList, - List meshedDpnList) { + public List> deleteTunnels(IMdsalApiManager mdsalManager, + Collection dpnTepsList, Collection meshedDpnList) { LOG.trace("TEPs to be deleted {} " , dpnTepsList); return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(writeTransaction -> { if (dpnTepsList == null || dpnTepsList.size() == 0) { @@ -152,7 +155,7 @@ public class ItmInternalTunnelDeleteWorker { // remove the tep from the cache meshedEndPtCache.remove(srcTep); Class monitorProtocol = - ItmUtils.determineMonitorProtocol(dataBroker); + tunnelMonitoringConfig.getMonitorProtocol(); InstanceIdentifier dpnPath = InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class, srcDpn.getKey()) .build(); diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepAddWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepAddWorker.java index e27bd8f27..c5df528b7 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepAddWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepAddWorker.java @@ -9,9 +9,11 @@ package org.opendaylight.genius.itm.confighelpers; import com.google.common.util.concurrent.ListenableFuture; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.concurrent.Callable; import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.impl.ItmUtils; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig; @@ -25,22 +27,26 @@ public class ItmTepAddWorker implements Callable>> { private static final Logger LOG = LoggerFactory.getLogger(ItmTepAddWorker.class); private final DataBroker dataBroker; - private List meshedDpnList; + private Collection meshedDpnList; private final List cfgdDpnList ; private final IMdsalApiManager mdsalManager; private final List cfgdHwVteps; private final ItmConfig itmConfig; private final ItmInternalTunnelAddWorker itmInternalTunnelAddWorker; + private final ItmExternalTunnelAddWorker externalTunnelAddWorker; + private final DPNTEPsInfoCache dpnTEPsInfoCache; public ItmTepAddWorker(List cfgdDpnList, List hwVtepList, DataBroker broker, - IMdsalApiManager mdsalManager, - ItmConfig itmConfig, ItmInternalTunnelAddWorker itmInternalTunnelAddWorker) { + IMdsalApiManager mdsalManager, ItmConfig itmConfig, ItmInternalTunnelAddWorker itmInternalTunnelAddWorker, + ItmExternalTunnelAddWorker externalTunnelAddWorker, DPNTEPsInfoCache dpnTEPsInfoCache) { this.cfgdDpnList = cfgdDpnList ; this.dataBroker = broker ; this.mdsalManager = mdsalManager; this.cfgdHwVteps = hwVtepList; this.itmConfig = itmConfig; this.itmInternalTunnelAddWorker = itmInternalTunnelAddWorker; + this.externalTunnelAddWorker = externalTunnelAddWorker; + this.dpnTEPsInfoCache = dpnTEPsInfoCache; LOG.trace("ItmTepAddWorker initialized with DpnList {}",cfgdDpnList); LOG.trace("ItmTepAddWorker initialized with hwvteplist {}",hwVtepList); } @@ -48,7 +54,7 @@ public class ItmTepAddWorker implements Callable>> { @Override public List> call() { List> futures = new ArrayList<>() ; - this.meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker) ; + this.meshedDpnList = dpnTEPsInfoCache.getAllPresent(); LOG.debug("Invoking Internal Tunnel build method with Configured DpnList {} ; Meshed DpnList {} ", cfgdDpnList, meshedDpnList); futures.addAll(itmInternalTunnelAddWorker.buildAllTunnels(mdsalManager, cfgdDpnList, @@ -57,14 +63,13 @@ public class ItmTepAddWorker implements Callable>> { List dcGatewayIpList = ItmUtils.getDcGatewayIpList(dataBroker); if (dcGatewayIpList != null && !dcGatewayIpList.isEmpty()) { for (DcGatewayIp dcGatewayIp : dcGatewayIpList) { - futures.addAll(ItmExternalTunnelAddWorker.buildTunnelsToExternalEndPoint(dataBroker, - cfgdDpnList, dcGatewayIp.getIpAddress(), dcGatewayIp.getTunnnelType(), itmConfig)); + futures.addAll(externalTunnelAddWorker.buildTunnelsToExternalEndPoint(cfgdDpnList, + dcGatewayIp.getIpAddress(), dcGatewayIp.getTunnnelType())); } } //futures.addAll(ItmExternalTunnelAddWorker.buildTunnelsToExternalEndPoint(dataBroker,meshedDpnList, extIp) ; LOG.debug("invoking build hwVtepTunnels with hwVteplist {}", cfgdHwVteps); - futures.addAll(ItmExternalTunnelAddWorker.buildHwVtepsTunnels(dataBroker, - cfgdDpnList,cfgdHwVteps)); + futures.addAll(externalTunnelAddWorker.buildHwVtepsTunnels(cfgdDpnList,cfgdHwVteps)); return futures ; } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepRemoveWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepRemoveWorker.java index 5fe82db01..794d4a328 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepRemoveWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTepRemoveWorker.java @@ -9,9 +9,11 @@ package org.opendaylight.genius.itm.confighelpers; import com.google.common.util.concurrent.ListenableFuture; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.concurrent.Callable; import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.impl.ItmUtils; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo; @@ -27,21 +29,23 @@ public class ItmTepRemoveWorker implements Callable> private final DataBroker dataBroker; private final List delDpnList ; - private List meshedDpnList ; + private Collection meshedDpnList ; private final IMdsalApiManager mdsalManager; private final List cfgdHwVteps; private final TransportZone originalTZone; private final ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker; + private final DPNTEPsInfoCache dpnTEPsInfoCache; public ItmTepRemoveWorker(List delDpnList, List delHwList, TransportZone originalTZone, - DataBroker broker, IMdsalApiManager mdsalManager, - ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker) { + DataBroker broker, IMdsalApiManager mdsalManager, + ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker, DPNTEPsInfoCache dpnTEPsInfoCache) { this.delDpnList = delDpnList; this.dataBroker = broker; this.mdsalManager = mdsalManager; this.cfgdHwVteps = delHwList; this.originalTZone = originalTZone; this.itmInternalTunnelDeleteWorker = itmInternalTunnelDeleteWorker; + this.dpnTEPsInfoCache = dpnTEPsInfoCache; LOG.trace("ItmTepRemoveWorker initialized with DpnList {}", delDpnList); LOG.trace("ItmTepRemoveWorker initialized with cfgdHwTeps {}", delHwList); } @@ -49,7 +53,7 @@ public class ItmTepRemoveWorker implements Callable> @Override public List> call() { List> futures = new ArrayList<>() ; - this.meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker) ; + this.meshedDpnList = dpnTEPsInfoCache.getAllPresent(); futures.addAll(itmInternalTunnelDeleteWorker.deleteTunnels(mdsalManager, delDpnList, meshedDpnList)); LOG.debug("Invoking Internal Tunnel delete method with DpnList to be deleted {} ; Meshed DpnList {} ", diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateUpdateHelper.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateUpdateHelper.java deleted file mode 100644 index 99aecf53f..000000000 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateUpdateHelper.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) 2017 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.genius.itm.confighelpers; - -import com.google.common.util.concurrent.ListenableFuture; -import java.util.Collections; -import java.util.List; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.genius.itm.impl.ITMBatchingUtils; -import org.opendaylight.genius.itm.impl.ItmUtils; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public final class ItmTunnelStateUpdateHelper { - private static final Logger LOG = LoggerFactory.getLogger(ItmTunnelStateUpdateHelper.class); - - private ItmTunnelStateUpdateHelper() { } - - public static List> updateTunnel(Interface updated, DataBroker broker) throws Exception { - LOG.debug("Invoking ItmTunnelStateUpdateHelper for Interface {} ", updated); - final WriteTransaction writeTransaction = broker.newWriteOnlyTransaction(); - - StateTunnelListKey tlKey = ItmUtils.getTunnelStateKey(updated); - LOG.trace("TunnelStateKey: {} for interface: {}", tlKey, updated.getName()); - InstanceIdentifier stListId = ItmUtils.buildStateTunnelListId(tlKey); - StateTunnelList tunnelsState = ItmUtils.getTunnelState(broker, updated.getName(), stListId); - StateTunnelListBuilder stlBuilder; - TunnelOperStatus tunnelOperStatus; - boolean tunnelState = updated.getOperStatus().equals(Interface.OperStatus.Up); - switch (updated.getOperStatus()) { - case Up: - tunnelOperStatus = TunnelOperStatus.Up; - break; - case Down: - tunnelOperStatus = TunnelOperStatus.Down; - break; - case Unknown: - tunnelOperStatus = TunnelOperStatus.Unknown; - break; - default: - tunnelOperStatus = TunnelOperStatus.Ignore; - } - if (tunnelsState != null) { - stlBuilder = new StateTunnelListBuilder(tunnelsState); - stlBuilder.setTunnelState(tunnelState); - stlBuilder.setOperState(tunnelOperStatus); - StateTunnelList stList = stlBuilder.build(); - LOG.trace("Batching the updation of tunnel_state: {} for Id: {}", stList, stListId); - ITMBatchingUtils.update(stListId, stList, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL); - } - - return Collections.singletonList(writeTransaction.submit()); - } -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java deleted file mode 100644 index 27f889efd..000000000 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (c) 2016, 2017 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.genius.itm.impl; - -import com.google.common.base.Optional; -import java.util.List; -import javax.annotation.PostConstruct; -import javax.annotation.PreDestroy; -import javax.inject.Inject; -import javax.inject.Singleton; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -@Singleton -public class ITMManager implements AutoCloseable { - private static final Logger LOG = LoggerFactory.getLogger(ITMManager.class); - - private final DataBroker broker; - private final IMdsalApiManager mdsalManager; - - List meshedDpnList; - - @Inject - public ITMManager(final DataBroker dataBroker,final IMdsalApiManager mdsalManager) { - this.broker = dataBroker; - this.mdsalManager = mdsalManager; - } - - @PostConstruct - public void start() { - LOG.info("ITMManager Started"); - } - - @Override - @PreDestroy - public void close() { - LOG.info("ITMManager Closed"); - } - - @SuppressWarnings("checkstyle:IllegalCatch") - protected void initTunnelMonitorDataInConfigDS() { - new Thread() { - public void run() { - boolean readSucceeded = false; - InstanceIdentifier monitorPath = - InstanceIdentifier.builder(TunnelMonitorParams.class).build(); - while (!readSucceeded) { - try { - Optional storedTunnelMonitor = - ItmUtils.read(LogicalDatastoreType.CONFIGURATION, monitorPath, broker); - // Store default values only when tunnel monitor data is not initialized - if (!storedTunnelMonitor.isPresent()) { - TunnelMonitorParams monitorEnabled = new TunnelMonitorParamsBuilder() - .setEnabled(ITMConstants.DEFAULT_MONITOR_ENABLED).build(); - ItmUtils.asyncUpdate(LogicalDatastoreType.CONFIGURATION, monitorPath, monitorEnabled, - broker, ItmUtils.DEFAULT_CALLBACK); - - InstanceIdentifier intervalPath = - InstanceIdentifier.builder(TunnelMonitorInterval.class).build(); - TunnelMonitorInterval monitorInteval = new TunnelMonitorIntervalBuilder() - .setInterval(ITMConstants.DEFAULT_MONITOR_INTERVAL).build(); - ItmUtils.asyncUpdate(LogicalDatastoreType.CONFIGURATION, intervalPath, monitorInteval, - broker, ItmUtils.DEFAULT_CALLBACK); - } - readSucceeded = true; - } catch (Exception e) { - LOG.warn("Unable to read monitor enabled info; retrying after some delay"); - try { - Thread.sleep(1000); - } catch (InterruptedException ie) { - return; - } - } - } - } - }.start(); - } - - protected boolean getTunnelMonitorEnabledFromConfigDS() { - InstanceIdentifier path = InstanceIdentifier.builder(TunnelMonitorParams.class).build(); - return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker) - .toJavaUtil().map(TunnelMonitorParams::isEnabled).orElse(true); - } - - protected Class getTunnelMonitorTypeFromConfigDS() { - - Class tunnelMonitorType = TunnelMonitoringTypeBfd.class; - InstanceIdentifier path = InstanceIdentifier.builder(TunnelMonitorParams.class).build(); - Optional storedTunnelMonitor = - ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker); - if (storedTunnelMonitor.isPresent() && storedTunnelMonitor.get().getMonitorProtocol() != null) { - tunnelMonitorType = storedTunnelMonitor.get().getMonitorProtocol(); - } - return tunnelMonitorType; - } - - protected int getTunnelMonitorIntervalFromConfigDS() { - InstanceIdentifier path = - InstanceIdentifier.builder(TunnelMonitorInterval.class).build(); - return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker).toJavaUtil().map( - TunnelMonitorInterval::getInterval).orElse(ITMConstants.DEFAULT_MONITOR_INTERVAL); - } -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java index 4949da390..bceb8a2d6 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java @@ -9,6 +9,7 @@ package org.opendaylight.genius.itm.impl; import com.google.common.base.Preconditions; import java.math.BigInteger; +import java.util.Collection; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; @@ -32,10 +33,6 @@ import org.opendaylight.genius.itm.listeners.TransportZoneListener; import org.opendaylight.genius.itm.listeners.TunnelMonitorChangeListener; import org.opendaylight.genius.itm.listeners.TunnelMonitorIntervalListener; import org.opendaylight.genius.itm.listeners.VtepConfigSchemaListener; -import org.opendaylight.genius.itm.listeners.cache.DpnTepsInfoListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringIntervalListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringListener; -import org.opendaylight.genius.itm.listeners.cache.StateTunnelListListener; import org.opendaylight.genius.itm.monitoring.ItmTunnelEventListener; import org.opendaylight.genius.itm.rpc.ItmManagerRpcService; import org.opendaylight.genius.mdsalutil.MDSALUtil; @@ -61,7 +58,6 @@ public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateServi private static final Logger LOG = LoggerFactory.getLogger(ItmProvider.class); - private final ITMManager itmManager; private final DataBroker dataBroker; private final ItmManagerRpcService itmRpcService ; private final IdManagerService idManager; @@ -73,47 +69,36 @@ public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateServi private final InterfaceStateListener ifStateListener; private RpcProviderRegistry rpcProviderRegistry; private final ItmTunnelEventListener itmStateListener; - private final ItmMonitoringListener itmMonitoringListener; - private final ItmMonitoringIntervalListener itmMonitoringIntervalListener; private final OvsdbNodeListener ovsdbChangeListener; static short flag = 0; - private final StateTunnelListListener tunnelStateListener ; - private final DpnTepsInfoListener dpnTepsInfoListener ; + private final TunnelMonitoringConfig tunnelMonitoringConfig; @Inject public ItmProvider(DataBroker dataBroker, - DpnTepsInfoListener dpnTepsInfoListener, IdManagerService idManagerService, InterfaceStateListener interfaceStateListener, - ITMManager itmManager, ItmManagerRpcService itmManagerRpcService, - ItmMonitoringListener itmMonitoringListener, - ItmMonitoringIntervalListener itmMonitoringIntervalListener, ItmTunnelEventListener itmTunnelEventListener, - StateTunnelListListener stateTunnelListListener, TepCommandHelper tepCommandHelper, TunnelMonitorChangeListener tunnelMonitorChangeListener, TunnelMonitorIntervalListener tunnelMonitorIntervalListener, TransportZoneListener transportZoneListener, VtepConfigSchemaListener vtepConfigSchemaListener, - OvsdbNodeListener ovsdbNodeListener) { + OvsdbNodeListener ovsdbNodeListener, + TunnelMonitoringConfig tunnelMonitoringConfig) { LOG.info("ItmProvider Before register MBean"); this.dataBroker = dataBroker; - this.dpnTepsInfoListener = dpnTepsInfoListener; this.idManager = idManagerService; this.ifStateListener = interfaceStateListener; - this.itmManager = itmManager; this.itmRpcService = itmManagerRpcService; - this.itmMonitoringListener = itmMonitoringListener; - this.itmMonitoringIntervalListener = itmMonitoringIntervalListener; this.itmStateListener = itmTunnelEventListener; - this.tunnelStateListener = stateTunnelListListener; this.tepCommandHelper = tepCommandHelper; this.tnlToggleListener = tunnelMonitorChangeListener; this.tnlIntervalListener = tunnelMonitorIntervalListener; this.tzChangeListener = transportZoneListener; this.vtepConfigSchemaListener = vtepConfigSchemaListener; this.ovsdbChangeListener = ovsdbNodeListener; + this.tunnelMonitoringConfig = tunnelMonitoringConfig; ITMBatchingUtils.registerWithBatchManager(this.dataBroker); } @@ -131,9 +116,6 @@ public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateServi @Override @PreDestroy public void close() { - if (itmManager != null) { - itmManager.close(); - } if (tzChangeListener != null) { tzChangeListener.close(); } @@ -143,12 +125,6 @@ public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateServi if (tnlToggleListener != null) { tnlToggleListener.close(); } - if (tunnelStateListener != null) { - tunnelStateListener.close(); - } - if (dpnTepsInfoListener != null) { - dpnTepsInfoListener.close(); - } if (ovsdbChangeListener != null) { ovsdbChangeListener.close(); } @@ -216,18 +192,18 @@ public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateServi @Override public void showTeps(CommandSession session) { try { - tepCommandHelper.showTeps(itmManager.getTunnelMonitorEnabledFromConfigDS(), - ItmUtils.determineMonitorInterval(this.dataBroker), session); + tepCommandHelper.showTeps(tunnelMonitoringConfig.isTunnelMonitoringEnabled(), + tunnelMonitoringConfig.getMonitorInterval(), session); } catch (TepException e) { LOG.error(e.getMessage()); } } @Override - public void showState(List tunnels,CommandSession session) { + public void showState(Collection tunnels,CommandSession session) { if (tunnels != null) { try { - tepCommandHelper.showState(tunnels, itmManager.getTunnelMonitorEnabledFromConfigDS(), session); + tepCommandHelper.showState(tunnels, tunnelMonitoringConfig.isTunnelMonitoringEnabled(), session); } catch (TepException e) { LOG.error(e.getMessage()); } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java index b1c3529f5..3d5942db2 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java @@ -34,6 +34,7 @@ import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.interfacemanager.globals.IfmConstants; import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager; import org.opendaylight.genius.itm.api.IITMProvider; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.confighelpers.HwVtep; import org.opendaylight.genius.itm.confighelpers.ItmTunnelAggregationHelper; import org.opendaylight.genius.itm.globals.ITMConstants; @@ -47,7 +48,6 @@ import org.opendaylight.genius.mdsalutil.actions.ActionPuntToController; import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId; -import org.opendaylight.genius.utils.cache.DataStoreCache; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; @@ -64,7 +64,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeLogicalGroup; @@ -77,10 +76,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptionsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptionsKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.VtepConfigSchemas; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.VtepIpPools; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchema; @@ -139,7 +134,6 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology. import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -415,56 +409,21 @@ public final class ItmUtils { .setTransportType(tunType).build(); } - public static List getTunnelMeshInfo(DataBroker dataBroker) { - // Read the Mesh Information from Cache if not read from the DS - List dpnTEPs = getTunnelMeshInfo() ; - if (dpnTEPs != null) { - return dpnTEPs; - } - - // Read the EndPoint Info from the operational database - InstanceIdentifierBuilder depBuilder = InstanceIdentifier.builder(DpnEndpoints.class); - InstanceIdentifier deps = depBuilder.build(); - Optional dpnEps = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, deps, dataBroker); - if (dpnEps.isPresent()) { - DpnEndpoints tn = dpnEps.get(); - dpnTEPs = tn.getDPNTEPsInfo(); - LOG.debug("Read from CONFIGURATION datastore - No. of Dpns " , dpnTEPs.size()); - } else { - LOG.debug("No Dpn information in CONFIGURATION datastore "); - } - return dpnTEPs; - } - - // Reading the Mesh Information from Cache - private static List getTunnelMeshInfo() { - List dpnTepsInfo = null; - List values = DataStoreCache.getValues(ITMConstants.DPN_TEPs_Info_CACHE_NAME); - if (values != null) { - dpnTepsInfo = new ArrayList<>() ; - for (Object value : values) { - dpnTepsInfo.add((DPNTEPsInfo)value) ; - } - } - return dpnTepsInfo; - } - private static String getUniqueIdString(String idKey) { return UUID.nameUUIDFromBytes(idKey.getBytes()).toString().substring(0, 12).replace("-", ""); } - public static List getDpnTepListFromDpnId(DataBroker dataBroker, List dpnIds) { - List meshedDpnList = getTunnelMeshInfo(dataBroker) ; + public static List getDpnTepListFromDpnId(DPNTEPsInfoCache dpnTEPsInfoCache, List dpnIds) { + Collection meshedDpnList = dpnTEPsInfoCache.getAllPresent(); List cfgDpnList = new ArrayList<>(); - if (null != meshedDpnList) { - for (BigInteger dpnId : dpnIds) { - for (DPNTEPsInfo teps : meshedDpnList) { - if (dpnId.equals(teps.getDPNID())) { - cfgDpnList.add(teps); - } + for (BigInteger dpnId : dpnIds) { + for (DPNTEPsInfo teps : meshedDpnList) { + if (dpnId.equals(teps.getDPNID())) { + cfgDpnList.add(teps); } } } + return cfgDpnList; } @@ -821,46 +780,6 @@ public final class ItmUtils { interfaceName)).build(); } - public static Boolean readMonitoringStateFromCache(DataBroker dataBroker) { - InstanceIdentifier iid = InstanceIdentifier.create(TunnelMonitorParams.class); - TunnelMonitorParams tunnelMonitorParams = (TunnelMonitorParams) DataStoreCache - .get(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME,iid,"MonitorParams",dataBroker,true); - if (tunnelMonitorParams != null) { - return tunnelMonitorParams.isEnabled(); - } else { - return ITMConstants.DEFAULT_MONITOR_ENABLED; - } - } - - private static Integer readMonitorIntervalfromCache(DataBroker dataBroker) { - InstanceIdentifier iid = InstanceIdentifier.create(TunnelMonitorInterval.class); - TunnelMonitorInterval tunnelMonitorIOptional = (TunnelMonitorInterval)DataStoreCache - .get(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME,iid,"Interval",dataBroker,true); - if (tunnelMonitorIOptional != null) { - return tunnelMonitorIOptional.getInterval(); - } - return null; - } - - public static Integer determineMonitorInterval(DataBroker dataBroker) { - Integer monitorInterval = ItmUtils.readMonitorIntervalfromCache(dataBroker); - LOG.debug("determineMonitorInterval: monitorInterval from DS = {}", monitorInterval); - if (monitorInterval == null) { - Class monitorProtocol = determineMonitorProtocol(dataBroker); - if (monitorProtocol.isAssignableFrom(TunnelMonitoringTypeBfd.class)) { - monitorInterval = ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL; - } else { - monitorInterval = ITMConstants.DEFAULT_MONITOR_INTERVAL; - } - } - LOG.debug("determineMonitorInterval: monitorInterval = {}", monitorInterval); - InstanceIdentifier iid = InstanceIdentifier.builder(TunnelMonitorInterval.class).build(); - TunnelMonitorInterval intervalBuilder = new TunnelMonitorIntervalBuilder().setInterval(monitorInterval).build(); - ItmUtils.asyncUpdate(LogicalDatastoreType.OPERATIONAL,iid, intervalBuilder, dataBroker, - ItmUtils.DEFAULT_CALLBACK); - return monitorInterval; - } - public static List getInternalTunnelInterfaces(DataBroker dataBroker) { List tunnelList = new ArrayList<>(); Collection internalInterfaces = ITM_CACHE.getAllInternalInterfaces(); @@ -1005,7 +924,7 @@ public final class ItmUtils { return new ExternalTunnelKey(dst, src, tunType); } - public static List getTEPsForDpn(BigInteger srcDpn, List dpnList) { + public static List getTEPsForDpn(BigInteger srcDpn, Collection dpnList) { for (DPNTEPsInfo dpn : dpnList) { if (dpn.getDPNID().equals(srcDpn)) { return dpn.getTunnelEndPoints() ; @@ -1109,51 +1028,6 @@ public final class ItmUtils { return result; } - public static StateTunnelList getTunnelState(DataBroker dataBroker, String ifaceName, - InstanceIdentifier stListId) { - StateTunnelList tunnelState = (StateTunnelList)DataStoreCache - .get(ITMConstants.TUNNEL_STATE_CACHE_NAME, ifaceName); - if (tunnelState == null) { - Optional tunnelsState = ItmUtils - .read(LogicalDatastoreType.OPERATIONAL, stListId, dataBroker); - if (tunnelsState.isPresent()) { - return tunnelState; - } - } - return tunnelState; - } - - private static Class readMonitoringProtocolFromCache(DataBroker dataBroker) { - InstanceIdentifier iid = InstanceIdentifier.create(TunnelMonitorParams.class); - TunnelMonitorParams tunnelMonitorParams = (TunnelMonitorParams) DataStoreCache - .get(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME,iid,"MonitorParams",dataBroker,true); - if (tunnelMonitorParams != null) { - return tunnelMonitorParams.getMonitorProtocol(); - } - return null; - } - - public static Class determineMonitorProtocol(DataBroker dataBroker) { - Class monitoringProtocol = - ItmUtils.readMonitoringProtocolFromCache(dataBroker); - LOG.debug("determineMonitorProtocol: monitorProtocol from DS = {}", monitoringProtocol); - if (monitoringProtocol == null) { - monitoringProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL; - } - LOG.debug("determineMonitorProtocol: monitorProtocol = {}", monitoringProtocol); - Boolean monitorState = ItmUtils.readMonitoringStateFromCache(dataBroker); - if (monitorState == null) { - monitorState = true; - } - LOG.debug("determineMonitorProtocol: monitorState = {}", monitorState); - InstanceIdentifier iid = InstanceIdentifier.builder(TunnelMonitorParams.class).build(); - TunnelMonitorParams protocolBuilder = new TunnelMonitorParamsBuilder().setEnabled(monitorState) - .setMonitorProtocol(monitoringProtocol).build(); - ItmUtils.asyncUpdate(LogicalDatastoreType.OPERATIONAL,iid, protocolBuilder, dataBroker, - ItmUtils.DEFAULT_CALLBACK); - return monitoringProtocol; - } - public static List getDcGatewayIpList(DataBroker broker) { InstanceIdentifier dcGatewayIpListid = InstanceIdentifier.builder(DcGatewayIpList.class).build(); @@ -1385,7 +1259,7 @@ public final class ItmUtils { } public static List getOriginalTzMembership(TunnelEndPoints srcTep, BigInteger dpnId, - List meshedDpnList) { + Collection meshedDpnList) { LOG.trace("Original Membership for source DPN {}, source TEP {}", dpnId, srcTep); for (DPNTEPsInfo dstDpn : meshedDpnList) { if (dpnId.equals(dstDpn.getDPNID())) { diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/TunnelMonitoringConfig.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/TunnelMonitoringConfig.java new file mode 100644 index 000000000..b0640fd07 --- /dev/null +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/TunnelMonitoringConfig.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2017 Inocybe Technologies 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, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.genius.itm.impl; + +import com.google.common.base.Optional; +import javax.annotation.PreDestroy; +import javax.inject.Inject; +import javax.inject.Singleton; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.genius.itm.globals.ITMConstants; +import org.opendaylight.genius.mdsalutil.cache.DataObjectCache; +import org.opendaylight.infrautils.caches.CacheProvider; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Maintains configuration for tunnel monitoring parameters. + * + * @author Thomas Pantelis + */ +@Singleton +public class TunnelMonitoringConfig implements AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(ItmProvider.class); + + private static final InstanceIdentifier TUNNEL_MONITOR_PARAMS_PATH = + InstanceIdentifier.create(TunnelMonitorParams.class); + + private static final InstanceIdentifier TUNNEL_MONITOR_INTERVAL_PATH = + InstanceIdentifier.create(TunnelMonitorInterval.class); + + private final DataObjectCache tunnelMonitorIntervalCache; + private final DataObjectCache tunnelMonitorParamsCache; + + @Inject + public TunnelMonitoringConfig(DataBroker dataBroker, CacheProvider cacheProvider) { + tunnelMonitorIntervalCache = new DataObjectCache<>(TunnelMonitorInterval.class, dataBroker, + LogicalDatastoreType.CONFIGURATION, TUNNEL_MONITOR_INTERVAL_PATH, cacheProvider); + tunnelMonitorParamsCache = new DataObjectCache<>(TunnelMonitorParams.class, dataBroker, + LogicalDatastoreType.CONFIGURATION, TUNNEL_MONITOR_PARAMS_PATH, cacheProvider); + } + + public boolean isTunnelMonitoringEnabled() { + try { + Optional maybeTunnelParams = tunnelMonitorParamsCache.get(TUNNEL_MONITOR_PARAMS_PATH); + return maybeTunnelParams.isPresent() ? maybeTunnelParams.get().isEnabled() + : ITMConstants.DEFAULT_MONITOR_ENABLED; + } catch (ReadFailedException e) { + LOG.warn("Read of {} failed", TUNNEL_MONITOR_PARAMS_PATH, e); + return ITMConstants.DEFAULT_MONITOR_ENABLED; + } + } + + public Class getMonitorProtocol() { + try { + Optional maybeTunnelParams = tunnelMonitorParamsCache.get(TUNNEL_MONITOR_PARAMS_PATH); + return maybeTunnelParams.isPresent() ? maybeTunnelParams.get().getMonitorProtocol() + : ITMConstants.DEFAULT_MONITOR_PROTOCOL; + } catch (ReadFailedException e) { + LOG.warn("Read of {} failed", TUNNEL_MONITOR_PARAMS_PATH, e); + return ITMConstants.DEFAULT_MONITOR_PROTOCOL; + } + } + + public int getMonitorInterval() { + try { + Optional maybeTunnelInterval = + tunnelMonitorIntervalCache.get(TUNNEL_MONITOR_INTERVAL_PATH); + return maybeTunnelInterval.isPresent() ? maybeTunnelInterval.get().getInterval() + : ITMConstants.DEFAULT_MONITOR_INTERVAL; + } catch (ReadFailedException e) { + LOG.warn("Read of {} failed", TUNNEL_MONITOR_INTERVAL_PATH, e); + return ITMConstants.DEFAULT_MONITOR_INTERVAL; + } + } + + @Override + @PreDestroy + public void close() { + tunnelMonitorIntervalCache.close(); + tunnelMonitorParamsCache.close(); + } +} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java index 81c81a7ff..859876733 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java @@ -8,24 +8,34 @@ package org.opendaylight.genius.itm.listeners; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.ListenableFuture; +import java.util.Collections; +import java.util.List; import java.util.Objects; import javax.annotation.Nonnull; import javax.inject.Inject; import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.listeners.AbstractSyncDataTreeChangeListener; import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager; +import org.opendaylight.genius.itm.cache.TunnelStateCache; import org.opendaylight.genius.itm.confighelpers.ItmTunnelAggregationHelper; import org.opendaylight.genius.itm.confighelpers.ItmTunnelStateAddHelper; import org.opendaylight.genius.itm.confighelpers.ItmTunnelStateRemoveHelper; -import org.opendaylight.genius.itm.confighelpers.ItmTunnelStateUpdateHelper; import org.opendaylight.genius.itm.globals.ITMConstants; +import org.opendaylight.genius.itm.impl.ITMBatchingUtils; import org.opendaylight.genius.itm.impl.ItmUtils; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; 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.state.Interface; 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.genius.itm.op.rev160406.TunnelOperStatus; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -39,16 +49,19 @@ public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener ItmTunnelStateUpdateHelper.updateTunnel(updatedInterface, dataBroker)); + () -> updateTunnel(updatedInterface)); } if (tunnelAggregationHelper.isTunnelAggregationEnabled()) { tunnelAggregationHelper.updateLogicalTunnelState(originalInterface, updatedInterface, @@ -99,4 +112,40 @@ public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener> updateTunnel(Interface updated) throws Exception { + LOG.debug("Invoking ItmTunnelStateUpdateHelper for Interface {} ", updated); + final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); + + StateTunnelListKey tlKey = ItmUtils.getTunnelStateKey(updated); + LOG.trace("TunnelStateKey: {} for interface: {}", tlKey, updated.getName()); + InstanceIdentifier stListId = ItmUtils.buildStateTunnelListId(tlKey); + Optional tunnelsState = tunnelStateCache.get(stListId); + StateTunnelListBuilder stlBuilder; + TunnelOperStatus tunnelOperStatus; + boolean tunnelState = updated.getOperStatus().equals(Interface.OperStatus.Up); + switch (updated.getOperStatus()) { + case Up: + tunnelOperStatus = TunnelOperStatus.Up; + break; + case Down: + tunnelOperStatus = TunnelOperStatus.Down; + break; + case Unknown: + tunnelOperStatus = TunnelOperStatus.Unknown; + break; + default: + tunnelOperStatus = TunnelOperStatus.Ignore; + } + if (tunnelsState.isPresent()) { + stlBuilder = new StateTunnelListBuilder(tunnelsState.get()); + stlBuilder.setTunnelState(tunnelState); + stlBuilder.setOperState(tunnelOperStatus); + StateTunnelList stList = stlBuilder.build(); + LOG.trace("Batching the updation of tunnel_state: {} for Id: {}", stList, stListId); + ITMBatchingUtils.update(stListId, stList, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL); + } + + return Collections.singletonList(writeTransaction.submit()); + } } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java index 1f7423b7d..2edfae225 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java @@ -25,7 +25,9 @@ import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.genius.datastoreutils.listeners.AbstractSyncDataTreeChangeListener; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.confighelpers.HwVtep; +import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker; import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelAddWorker; import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelDeleteWorker; import org.opendaylight.genius.itm.confighelpers.ItmTepAddWorker; @@ -34,11 +36,11 @@ import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedMoveWorker; import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedRemoveWorker; import org.opendaylight.genius.itm.globals.ITMConstants; import org.opendaylight.genius.itm.impl.ItmUtils; +import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo; @@ -74,11 +76,15 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener oldHwList = createhWVteps(originalTransportZone); List newHwList = createhWVteps(updatedTransportZone); @@ -206,19 +211,15 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener - implements AutoCloseable { - private static final Logger LOG = LoggerFactory.getLogger(DpnTepsInfoListener.class); - private final DataBroker broker; - - /** - * Responsible for listening to DPNTEPsInfo change. - * - */ - @Inject - public DpnTepsInfoListener(final DataBroker dataBroker) { - super(DPNTEPsInfo.class, DpnTepsInfoListener.class); - DataStoreCache.create(ITMConstants.DPN_TEPs_Info_CACHE_NAME) ; - this.broker = dataBroker; - } - - @PostConstruct - public void start() { - registerListener(LogicalDatastoreType.CONFIGURATION, this.broker); - LOG.info("dpnTepsInfo Listener Started"); - } - - @Override - @PreDestroy - public void close() { - LOG.info("dpnTepsInfo Listener Closed"); - } - - @Override - protected void remove(InstanceIdentifier identifier, DPNTEPsInfo del) { - LOG.debug("Remove from cache {} Invoked for data Obj {}", - ITMConstants.DPN_TEPs_Info_CACHE_NAME, del.getDPNID()); - DataStoreCache.remove(ITMConstants.DPN_TEPs_Info_CACHE_NAME, del.getDPNID()) ; - } - - @Override - protected void update(InstanceIdentifier identifier, DPNTEPsInfo original, - DPNTEPsInfo update) { - LOG.debug("Update to cache {} Invoked for data Obj {}", - ITMConstants.DPN_TEPs_Info_CACHE_NAME, update.getDPNID()); - DataStoreCache.add(ITMConstants.DPN_TEPs_Info_CACHE_NAME, update.getDPNID(), update); - } - - @Override - protected void add(InstanceIdentifier identifier, DPNTEPsInfo add) { - LOG.debug("Add to cache {} Invoked for data Obj {}", ITMConstants.DPN_TEPs_Info_CACHE_NAME, add.getDPNID()); - DataStoreCache.add(ITMConstants.DPN_TEPs_Info_CACHE_NAME, add.getDPNID(), add); - } - - @Override - protected DpnTepsInfoListener getDataTreeChangeListener() { - return this; - } - - @Override - protected InstanceIdentifier getWildCardPath() { - return InstanceIdentifier.builder(DpnEndpoints.class) - .child(DPNTEPsInfo.class).build(); - } - -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringIntervalListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringIntervalListener.java deleted file mode 100644 index 39a247082..000000000 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringIntervalListener.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (c) 2015, 2017 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.genius.itm.listeners.cache; - -import javax.annotation.PostConstruct; -import javax.annotation.PreDestroy; -import javax.inject.Inject; -import javax.inject.Singleton; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase; -import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/* - * Created by Dimple Jain on 8/4/2016. - */ -@Singleton -public class ItmMonitoringIntervalListener extends AsyncClusteredDataTreeChangeListenerBase { - - private static final Logger LOG = LoggerFactory.getLogger(ItmMonitoringIntervalListener.class); - - @SuppressWarnings("checkstyle:IllegalCatch") - @Inject - public ItmMonitoringIntervalListener(final DataBroker dataBroker) { - super(TunnelMonitorInterval.class, ItmMonitoringIntervalListener.class); - try { - registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker); - } catch (final Exception e) { - LOG.error("ItmMonitoring Interval listener registration fail!", e); - } - } - - @PostConstruct - public void start() { - LOG.info("ItmMonitoringIntervalListener Started"); - } - - @PreDestroy - public void close() { - LOG.info("ItmMonitoringIntervalListener Closed"); - } - - @Override - protected void remove(InstanceIdentifier key, TunnelMonitorInterval dataObjectModification) { - DataStoreCache.remove(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "Interval"); - } - - @Override - protected void update(InstanceIdentifier identifier, TunnelMonitorInterval original, - TunnelMonitorInterval update) { - DataStoreCache.add(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "Interval", update); - } - - @Override - protected void add(InstanceIdentifier identifier, TunnelMonitorInterval add) { - DataStoreCache.add(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "Interval", add); - } - - @Override protected InstanceIdentifier getWildCardPath() { - return InstanceIdentifier.create(TunnelMonitorInterval.class); - } - - @Override - protected ItmMonitoringIntervalListener getDataTreeChangeListener() { - return this; - } -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringListener.java deleted file mode 100644 index 592e066fc..000000000 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/ItmMonitoringListener.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (c) 2015, 2017 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.genius.itm.listeners.cache; - -import javax.annotation.PostConstruct; -import javax.annotation.PreDestroy; -import javax.inject.Inject; -import javax.inject.Singleton; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase; -import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/* - * Created by Dimple Jain on 8/4/2016. - */ -@Singleton -public class ItmMonitoringListener extends AsyncClusteredDataTreeChangeListenerBase { - private static final Logger LOG = LoggerFactory.getLogger(ItmMonitoringListener.class); - - @SuppressWarnings("checkstyle:IllegalCatch") - @Inject - public ItmMonitoringListener(final DataBroker dataBroker) { - super(TunnelMonitorParams.class, ItmMonitoringListener.class); - DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME); - - try { - registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker); - } catch (final Exception e) { - LOG.error("ItmMonitoring DataChange listener registration fail!", e); - } - } - - @PostConstruct - public void start() { - LOG.info("ItmMonitoring Started"); - } - - @PreDestroy - public void close() { - LOG.info("ItmMonitoring Closed"); - } - - @Override - protected void remove(InstanceIdentifier key, TunnelMonitorParams dataObjectModification) { - DataStoreCache.remove(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "MonitorParams"); - } - - @Override - protected void update(InstanceIdentifier identifier, TunnelMonitorParams original, - TunnelMonitorParams update) { - DataStoreCache.add(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "MonitorParams", update); - } - - @Override - protected void add(InstanceIdentifier identifier, TunnelMonitorParams add) { - DataStoreCache.add(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME, "MonitorParams", add); - } - - @Override protected InstanceIdentifier getWildCardPath() { - return InstanceIdentifier.create(TunnelMonitorParams.class); - } - - @Override - protected ItmMonitoringListener getDataTreeChangeListener() { - return this; - } -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/StateTunnelListListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/StateTunnelListListener.java deleted file mode 100644 index 0a89b9f16..000000000 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/cache/StateTunnelListListener.java +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.genius.itm.listeners.cache; - -import javax.annotation.PostConstruct; -import javax.annotation.PreDestroy; -import javax.inject.Inject; -import javax.inject.Singleton; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase; -import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -@Singleton -public class StateTunnelListListener - extends AsyncClusteredDataTreeChangeListenerBase - implements AutoCloseable { - private static final Logger LOG = LoggerFactory.getLogger(StateTunnelListListener.class); - private final DataBroker broker; - - /** - * Responsible for listening to tunnel interface state change. - * - */ - @SuppressWarnings("checkstyle:IllegalCatch") - @Inject - public StateTunnelListListener(final DataBroker dataBroker) { - super(StateTunnelList.class, StateTunnelListListener.class); - DataStoreCache.create(ITMConstants.TUNNEL_STATE_CACHE_NAME); - this.broker = dataBroker; - try { - registerListener(LogicalDatastoreType.OPERATIONAL, this.broker); - } catch (final Exception e) { - LOG.error("StateTunnelListListener DataChange listener registration fail!", e); - } - } - - @PostConstruct - public void start() { - LOG.info("Tunnel Interface State Listener Started"); - } - - @Override - @PreDestroy - public void close() { - LOG.info("Tunnel Interface State Listener Closed"); - } - - @Override - protected void remove(InstanceIdentifier identifier, StateTunnelList del) { - DataStoreCache.remove(ITMConstants.TUNNEL_STATE_CACHE_NAME, del.getTunnelInterfaceName()); - } - - @Override - protected void update(InstanceIdentifier identifier, StateTunnelList original, - StateTunnelList update) { - DataStoreCache.add(ITMConstants.TUNNEL_STATE_CACHE_NAME, update.getTunnelInterfaceName(), update); - } - - @Override - protected void add(InstanceIdentifier identifier, StateTunnelList add) { - DataStoreCache.add(ITMConstants.TUNNEL_STATE_CACHE_NAME, add.getTunnelInterfaceName(), add); - } - - @Override - protected StateTunnelListListener getDataTreeChangeListener() { - return this; - } - - @Override - protected InstanceIdentifier getWildCardPath() { - return InstanceIdentifier.builder(TunnelsState.class) - .child(StateTunnelList.class).build(); - } - -} diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java index dc97a66dc..12375fadc 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java @@ -14,6 +14,7 @@ import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.SettableFuture; import java.math.BigInteger; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.concurrent.Future; import javax.annotation.PostConstruct; @@ -23,6 +24,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker; import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelDeleteWorker; import org.opendaylight.genius.itm.globals.ITMConstants; @@ -100,14 +102,16 @@ public class ItmManagerRpcService implements ItmRpcService { private static final Logger LOG = LoggerFactory.getLogger(ItmManagerRpcService.class); private final DataBroker dataBroker; private final IMdsalApiManager mdsalManager; - private final ItmConfig itmConfig; + private final DPNTEPsInfoCache dpnTEPsInfoCache; + private final ItmExternalTunnelAddWorker externalTunnelAddWorker; @Inject - public ItmManagerRpcService(final DataBroker dataBroker, - final IMdsalApiManager mdsalManager, final ItmConfig itmConfig) { + public ItmManagerRpcService(final DataBroker dataBroker, final IMdsalApiManager mdsalManager, + final ItmConfig itmConfig, final DPNTEPsInfoCache dpnTEPsInfoCache) { this.dataBroker = dataBroker; this.mdsalManager = mdsalManager; - this.itmConfig = itmConfig; + this.dpnTEPsInfoCache = dpnTEPsInfoCache; + this.externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig, dpnTEPsInfoCache); } @PostConstruct @@ -159,7 +163,7 @@ public class ItmManagerRpcService implements ItmRpcService { RemoveExternalTunnelEndpointInput input) { //Ignore the Futures for now final SettableFuture> result = SettableFuture.create(); - List meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker) ; + Collection meshedDpnList = dpnTEPsInfoCache.getAllPresent(); ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, meshedDpnList, input.getDestinationIp(), input.getTunnelType()); InstanceIdentifier extPath = InstanceIdentifier.builder(DcGatewayIpList.class) @@ -189,7 +193,7 @@ public class ItmManagerRpcService implements ItmRpcService { RemoveExternalTunnelFromDpnsInput input) { //Ignore the Futures for now final SettableFuture> result = SettableFuture.create(); - List cfgDpnList = ItmUtils.getDpnTepListFromDpnId(dataBroker, input.getDpnId()) ; + List cfgDpnList = ItmUtils.getDpnTepListFromDpnId(dpnTEPsInfoCache, input.getDpnId()) ; ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, cfgDpnList, input.getDestinationIp(), input.getTunnelType()); result.set(RpcResultBuilder.success().build()); @@ -201,9 +205,8 @@ public class ItmManagerRpcService implements ItmRpcService { BuildExternalTunnelFromDpnsInput input) { //Ignore the Futures for now final SettableFuture> result = SettableFuture.create(); - List> extTunnelResultList = ItmExternalTunnelAddWorker - .buildTunnelsFromDpnToExternalEndPoint(dataBroker, input.getDpnId(), - input.getDestinationIp(),input.getTunnelType(), itmConfig); + List> extTunnelResultList = externalTunnelAddWorker + .buildTunnelsFromDpnToExternalEndPoint(input.getDpnId(), input.getDestinationIp(),input.getTunnelType()); for (ListenableFuture extTunnelResult : extTunnelResultList) { Futures.addCallback(extTunnelResult, new FutureCallback() { @@ -231,9 +234,9 @@ public class ItmManagerRpcService implements ItmRpcService { //Ignore the Futures for now final SettableFuture> result = SettableFuture.create(); - List meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker) ; - ItmExternalTunnelAddWorker.buildTunnelsToExternalEndPoint(dataBroker, meshedDpnList, - input.getDestinationIp(), input.getTunnelType(), itmConfig); + Collection meshedDpnList = dpnTEPsInfoCache.getAllPresent(); + externalTunnelAddWorker.buildTunnelsToExternalEndPoint(meshedDpnList, + input.getDestinationIp(), input.getTunnelType()); InstanceIdentifier extPath = InstanceIdentifier.builder(DcGatewayIpList.class) .child(DcGatewayIp.class, new DcGatewayIpKey(input.getDestinationIp())).build(); DcGatewayIp dcGatewayIp = @@ -408,7 +411,7 @@ public class ItmManagerRpcService implements ItmRpcService { resultBld = RpcResultBuilder.success(); resultBld.withResult(output.build()) ; } else { - List meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker); + Collection meshedDpnList = dpnTEPsInfoCache.getAllPresent(); if (meshedDpnList == null) { LOG.error("There are no tunnel mesh info in config DS"); return Futures.immediateFuture(resultBld.build()); diff --git a/itm/itm-impl/src/main/resources/org/opendaylight/blueprint/itm.xml b/itm/itm-impl/src/main/resources/org/opendaylight/blueprint/itm.xml index c7b66eea8..2ccfd0034 100644 --- a/itm/itm-impl/src/main/resources/org/opendaylight/blueprint/itm.xml +++ b/itm/itm-impl/src/main/resources/org/opendaylight/blueprint/itm.xml @@ -28,6 +28,9 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + - + + diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelAddTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelAddTest.java index fb46661e9..52713258f 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelAddTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelAddTest.java @@ -29,10 +29,12 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.confighelpers.HwVtep; import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker; import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; +import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl; +import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; @@ -162,10 +164,11 @@ public class ItmExternalTunnelAddTest { @Mock IdManagerService idManagerService; @Mock ItmConfig itmConfig; + private ItmExternalTunnelAddWorker externalTunnelAddWorker; + @Before public void setUp() { setupMocks(); - DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME); optionalDpnEndPoints = Optional.of(dpnEndpointsVxlan); tunnelMonitorParamsOptional = Optional.of(tunnelMonitorParams); @@ -178,6 +181,9 @@ public class ItmExternalTunnelAddTest { doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)) .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorIntervalIdentifier); + externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig, + new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()))); + } @After @@ -286,8 +292,7 @@ public class ItmExternalTunnelAddTest { @Test public void testBuildTunnelsToExternalEndPoint() { - ItmExternalTunnelAddWorker.buildTunnelsToExternalEndPoint(dataBroker, cfgdDpnListVxlan, - ipAddress2,tunnelType1, itmConfig); + externalTunnelAddWorker.buildTunnelsToExternalEndPoint(cfgdDpnListVxlan, ipAddress2, tunnelType1); verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface,true); verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier,externalTunnel,true); @@ -298,8 +303,7 @@ public class ItmExternalTunnelAddTest { @Test public void testBuildTunnelsFromDpnToExternalEndPoint() { - ItmExternalTunnelAddWorker.buildTunnelsFromDpnToExternalEndPoint(dataBroker, bigIntegerList, - ipAddress2,tunnelType1, itmConfig); + externalTunnelAddWorker.buildTunnelsFromDpnToExternalEndPoint(bigIntegerList, ipAddress2, tunnelType1); verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface,true); verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier,externalTunnel,true); @@ -391,8 +395,8 @@ public class ItmExternalTunnelAddTest { doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType .CONFIGURATION,transportZoneIdentifier); - ItmExternalTunnelAddWorker.buildHwVtepsTunnels(dataBroker, cfgdDpnListVxlan,null); - ItmExternalTunnelAddWorker.buildHwVtepsTunnels(dataBroker, null,cfgdHwVtepsList); + externalTunnelAddWorker.buildHwVtepsTunnels(cfgdDpnListVxlan, null); + externalTunnelAddWorker.buildHwVtepsTunnels(null, cfgdHwVtepsList); verify(mockWriteTx, times(2)).merge(LogicalDatastoreType.CONFIGURATION,ifIID1,extTunnelIf1,true); verify(mockWriteTx, times(2)).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier1, diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelDeleteTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelDeleteTest.java index 3b7adfbe8..9d625662c 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelDeleteTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmExternalTunnelDeleteTest.java @@ -33,7 +33,6 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.itm.confighelpers.HwVtep; import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelDeleteWorker; import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.utils.cache.DataStoreCache; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; @@ -146,7 +145,6 @@ public class ItmExternalTunnelDeleteTest { @Before public void setUp() { setupMocks(); - DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME); when(idManagerService.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder .success().build())); diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelAddTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelAddTest.java index 7dc1a856c..69bca4f95 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelAddTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelAddTest.java @@ -30,7 +30,8 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelAddWorker; import org.opendaylight.genius.itm.globals.ITMConstants; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; -import org.opendaylight.genius.utils.cache.DataStoreCache; +import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl; +import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder; @@ -156,7 +157,6 @@ public class ItmInternalTunnelAddTest { public void setUp() { PowerMockito.mockStatic(ITMBatchingUtils.class); setupMocks(); - DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME); tunnelMonitorParamsOptional = Optional.of(tunnelMonitorParams); tunnelMonitorIntervalOptional = Optional.of(tunnelMonitorInterval); @@ -169,7 +169,8 @@ public class ItmInternalTunnelAddTest { doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)).when(mockReadTx) .read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorIntervalIdentifier); - itmInternalTunnelAddWorker = new ItmInternalTunnelAddWorker(dataBroker, jobCoordinator); + itmInternalTunnelAddWorker = new ItmInternalTunnelAddWorker(dataBroker, jobCoordinator, + new TunnelMonitoringConfig(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()))); } @After diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelDeleteTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelDeleteTest.java index b84d0a376..933703344 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelDeleteTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmInternalTunnelDeleteTest.java @@ -27,9 +27,9 @@ import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelDeleteWorker; -import org.opendaylight.genius.itm.globals.ITMConstants; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; -import org.opendaylight.genius.utils.cache.DataStoreCache; +import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl; +import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider; import org.opendaylight.infrautils.jobcoordinator.JobCoordinator; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder; @@ -116,7 +116,6 @@ public class ItmInternalTunnelDeleteTest { @Before public void setUp() { setupMocks(); - DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME); tunnelMonitorParamsOptional = Optional.of(tunnelMonitorParams); tunnelMonitorIntervalOptional = Optional.of(tunnelMonitorInterval); @@ -131,7 +130,8 @@ public class ItmInternalTunnelDeleteTest { doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx) .read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier); - itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator); + itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator, + new TunnelMonitoringConfig(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()))); } @After diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmManagerRpcServiceTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmManagerRpcServiceTest.java index 7080fb04e..41b8a3523 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmManagerRpcServiceTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmManagerRpcServiceTest.java @@ -27,9 +27,12 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache; import org.opendaylight.genius.itm.globals.ITMConstants; import org.opendaylight.genius.itm.rpc.ItmManagerRpcService; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; +import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl; +import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; @@ -200,7 +203,8 @@ public class ItmManagerRpcServiceTest { doReturn(Futures.immediateCheckedFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType .CONFIGURATION,transportZonesIdentifier); - itmManagerRpcService = new ItmManagerRpcService(dataBroker, mdsalApiManager, itmConfig); + itmManagerRpcService = new ItmManagerRpcService(dataBroker, mdsalApiManager, itmConfig, + new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()))); } @After diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmProviderTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmProviderTest.java deleted file mode 100644 index bc38d70e8..000000000 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmProviderTest.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2015 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, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.genius.itm.impl; - -import org.junit.Test; -import org.mockito.Mock; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.genius.itm.cli.TepCommandHelper; -import org.opendaylight.genius.itm.listeners.InterfaceStateListener; -import org.opendaylight.genius.itm.listeners.OvsdbNodeListener; -import org.opendaylight.genius.itm.listeners.TransportZoneListener; -import org.opendaylight.genius.itm.listeners.TunnelMonitorChangeListener; -import org.opendaylight.genius.itm.listeners.TunnelMonitorIntervalListener; -import org.opendaylight.genius.itm.listeners.VtepConfigSchemaListener; -import org.opendaylight.genius.itm.listeners.cache.DpnTepsInfoListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringIntervalListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringListener; -import org.opendaylight.genius.itm.listeners.cache.StateTunnelListListener; -import org.opendaylight.genius.itm.monitoring.ItmTunnelEventListener; -import org.opendaylight.genius.itm.rpc.ItmManagerRpcService; -import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService; - -public class ItmProviderTest { - - @Mock DataBroker dataBroker; - @Mock DpnTepsInfoListener dpnTepsInfoListener; - @Mock IdManagerService idManagerService; - @Mock InterfaceStateListener interfaceStateListener; - @Mock ITMManager itmManager; - @Mock ItmManagerRpcService itmManagerRpcService; - @Mock ItmMonitoringListener itmMonitoringListener; - @Mock ItmMonitoringIntervalListener itmMonitoringIntervalListener; - @Mock ItmTunnelEventListener itmTunnelEventListener; - @Mock StateTunnelListListener stateTunnelListListener; - @Mock TepCommandHelper tepCommandHelper; - @Mock TunnelMonitorChangeListener tunnelMonitorChangeListener; - @Mock TunnelMonitorIntervalListener tunnelMonitorIntervalListener; - @Mock TransportZoneListener transportZoneListener; - @Mock VtepConfigSchemaListener vtepConfigSchemaListener; - @Mock OvsdbNodeListener ovsdbNodeListener; - - @Test - public void testClose() { - ItmProvider provider = new ItmProvider(dataBroker, dpnTepsInfoListener, idManagerService, - interfaceStateListener, itmManager, itmManagerRpcService, itmMonitoringListener, - itmMonitoringIntervalListener, itmTunnelEventListener, stateTunnelListListener, - tepCommandHelper, tunnelMonitorChangeListener, tunnelMonitorIntervalListener, - transportZoneListener, vtepConfigSchemaListener, ovsdbNodeListener); - // ensure no exceptions - // currently this method is empty - provider.close(); - } -} diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmManagerRpcServiceTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmManagerRpcServiceTest.java index 9957db173..ac26738d2 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmManagerRpcServiceTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmManagerRpcServiceTest.java @@ -30,6 +30,7 @@ import org.opendaylight.genius.itm.rpc.ItmManagerRpcService; import org.opendaylight.genius.itm.tests.xtend.ExpectedDeviceVtepsObjects; import org.opendaylight.genius.itm.tests.xtend.ExpectedExternalTunnelObjects; import org.opendaylight.genius.itm.tests.xtend.ExpectedInternalTunnelIdentifierObjects; +import org.opendaylight.infrautils.caches.testutils.CacheModule; import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule; import org.opendaylight.infrautils.testutils.LogRule; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; @@ -94,7 +95,8 @@ public class ItmManagerRpcServiceTest { public @Rule LogRule logRule = new LogRule(); // TODO public @Rule LogCaptureRule logCaptureRule = new LogCaptureRule(); - public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class); + public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class, + CacheModule.class); String trunkInterfaceName; diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTepAutoConfigTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTepAutoConfigTest.java index 92e9ec577..a62dbecae 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTepAutoConfigTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTepAutoConfigTest.java @@ -30,6 +30,7 @@ import org.opendaylight.genius.itm.impl.ItmUtils; import org.opendaylight.genius.itm.tests.xtend.ExpectedDefTransportZoneObjects; import org.opendaylight.genius.itm.tests.xtend.ExpectedTepNotHostedTransportZoneObjects; import org.opendaylight.genius.itm.tests.xtend.ExpectedTransportZoneObjects; +import org.opendaylight.infrautils.caches.testutils.CacheModule; import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule; import org.opendaylight.infrautils.testutils.LogRule; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix; @@ -52,7 +53,8 @@ public class ItmTepAutoConfigTest { public @Rule LogRule logRule = new LogRule(); // TODO public @Rule LogCaptureRule logCaptureRule = new LogCaptureRule(); - public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class); + public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class, + CacheModule.class); TransportZone transportZone; TransportZones transportZones; diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTest.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTest.java index d7fece043..e7b7ce1bb 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTest.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTest.java @@ -15,6 +15,7 @@ import org.junit.rules.MethodRule; import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule; import org.opendaylight.genius.itm.impl.ItmTestUtils; import org.opendaylight.genius.utils.cache.CacheTestUtil; +import org.opendaylight.infrautils.caches.testutils.CacheModule; import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule; import org.opendaylight.infrautils.testutils.LogCaptureRule; import org.opendaylight.infrautils.testutils.LogRule; @@ -26,7 +27,8 @@ public class ItmTest { public @Rule LogRule logRule = new LogRule(); public @Rule LogCaptureRule logCaptureRule = new LogCaptureRule(); - public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class); + public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class, JobCoordinatorTestModule.class, + CacheModule.class); @Before public void before() { diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java index 00e8cbf5c..8344cfc89 100644 --- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java +++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java @@ -18,7 +18,6 @@ import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager; import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService; import org.opendaylight.genius.interfacemanager.rpcservice.InterfaceManagerServiceImpl; import org.opendaylight.genius.itm.globals.ITMConstants; -import org.opendaylight.genius.itm.impl.ITMManager; import org.opendaylight.genius.itm.impl.ItmProvider; import org.opendaylight.genius.itm.listeners.InterfaceStateListener; import org.opendaylight.genius.itm.listeners.OvsdbNodeListener; @@ -26,10 +25,6 @@ import org.opendaylight.genius.itm.listeners.TransportZoneListener; import org.opendaylight.genius.itm.listeners.TunnelMonitorChangeListener; import org.opendaylight.genius.itm.listeners.TunnelMonitorIntervalListener; import org.opendaylight.genius.itm.listeners.VtepConfigSchemaListener; -import org.opendaylight.genius.itm.listeners.cache.DpnTepsInfoListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringIntervalListener; -import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringListener; -import org.opendaylight.genius.itm.listeners.cache.StateTunnelListListener; import org.opendaylight.genius.itm.monitoring.ItmTunnelEventListener; import org.opendaylight.genius.itm.rpc.ItmManagerRpcService; import org.opendaylight.genius.lockmanager.impl.LockManagerServiceImpl; @@ -57,7 +52,6 @@ public class ItmTestModule extends AbstractGuiceJsr250Module { protected void configureBindings() { // Bindings for services from this project bind(ItmRpcService.class).to(ItmManagerRpcService.class); - bind(ITMManager.class); bind(ItmProvider.class); ItmConfig itmConfigObj = new ItmConfigBuilder() .setDefTzEnabled(true) @@ -65,10 +59,6 @@ public class ItmTestModule extends AbstractGuiceJsr250Module { .setGpeExtensionEnabled(false) .build(); bind(ItmConfig.class).toInstance(itmConfigObj); - bind(ItmMonitoringIntervalListener.class); - bind(DpnTepsInfoListener.class); - bind(StateTunnelListListener.class); - bind(ItmMonitoringListener.class); bind(TunnelMonitorIntervalListener.class); bind(TransportZoneListener.class); bind(OvsdbNodeListener.class);