private static final ConcurrentHashMap<String, L2GatewayDevice> EMPTY_MAP = new ConcurrentHashMap<>();
public static final String L2GATEWAY_CONN_CACHE_NAME = "L2GWCONN";
- public static void createElanL2GwDeviceCache() {
- if (CacheUtil.getCache(ElanL2GwCacheUtils.L2GATEWAY_CONN_CACHE_NAME) == null) {
- CacheUtil.createCache(ElanL2GwCacheUtils.L2GATEWAY_CONN_CACHE_NAME);
- }
+ static {
+ CacheUtil.createCache(ElanL2GwCacheUtils.L2GATEWAY_CONN_CACHE_NAME);
}
public static void addL2GatewayDeviceToCache(String elanName, L2GatewayDevice l2GwDevice) {
+++ /dev/null
-module elanmanager-api {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:elanmanager:api";
- prefix "elanmanager-api";
-
- import config { prefix config; revision-date 2013-04-05; }
-
- description
- "Service definition for elanmanager project";
-
- revision "2015-07-07" {
- description
- "Initial revision";
- }
-
- identity elanmanager-api {
- base "config:service-type";
- config:java-class "org.opendaylight.netvirt.elanmanager.api.IElanService";
- }
-}
\ No newline at end of file
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- vi: set et smarttab sw=4 tabstop=4: -->
-<!--
-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
--->
-<snapshot>
- <required-capabilities>
- <capability>urn:opendaylight:params:xml:ns:yang:elanservice:impl?module=elanservice-impl&revision=2015-02-16</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
- <capability>urn:opendaylight:genius:mdsalutil?module=odl-mdsalutil&revision=2016-04-06</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:entity-ownership-service?module=opendaylight-entity-ownership-service&revision=2015-08-10</capability>
- <capability>urn:opendaylight:genius:itm?module=itm&revision=2016-04-06</capability>
- <capability>urn:opendaylight:genius:interfacemanager?module=odl-interface&revision=2016-04-06</capability>
- </required-capabilities>
- <configuration>
-
- <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
- <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <module>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:elanservice:impl">prefix:elanservice-impl</type>
- <name>elanservice-default</name>
- <broker>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
- <name>binding-osgi-broker</name>
- </broker>
- <rpcregistry>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
- <name>binding-rpc-broker</name>
- </rpcregistry>
- <mdsalutil>
- <type xmlns:mdsalutil="urn:opendaylight:genius:mdsalutil">mdsalutil:odl-mdsalutil</type>
- <name>mdsalutil-service</name>
- </mdsalutil>
- <odlinterface>
- <type xmlns:odlif="urn:opendaylight:genius:interfacemanager">odlif:odl-interface</type>
- <name>interfacemgr-service</name>
- </odlinterface>
- <itmmanager>
- <type xmlns:itm="urn:opendaylight:genius:itm">itm:itm</type>
- <name>itm</name>
- </itmmanager>
- <notification-service>
- <type xmlns:bindingimpl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">bindingimpl:binding-new-notification-service</type>
- <name>binding-notification-adapter</name>
- </notification-service>
- <entity-ownership-service>
- <type xmlns:entity-ownership="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:entity-ownership-service">entity-ownership:entity-ownership-service</type>
- <name>entity-ownership-service</name>
- </entity-ownership-service>
- <int-bridge-gen-mac>true</int-bridge-gen-mac>
- </module>
- </modules>
- <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <service>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:elanmanager:api">prefix:elanmanager-api</type>
- <instance>
- <name>elanmanager</name>
- <provider>/modules/module[type='elanservice-impl'][name='elanservice-default']</provider>
- </instance>
- </service>
- </services>
- </data>
- </configuration>
-</snapshot>
private String interfaceName;
private static final Logger logger = LoggerFactory.getLogger(EtreeInterfaceDelete.class);
private IElanService elanProvider;
+ private ElanUtils elanUtils;
public void setElanProvider(IElanService elanServiceProvider) {
this.elanProvider = elanServiceProvider;
}
+ public void setElanUtils(ElanUtils elanUtils) {
+ this.elanUtils = elanUtils;
+ }
+
@Override
protected Object doExecute() {
try {
logger.debug("Deleting EtreeInterface command" + "\t" + etreeName + "\t" + interfaceName + "\t");
- ElanInterface existingInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface existingInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (existingInterface == null || existingInterface.getAugmentation(EtreeInterface.class) == null) {
System.out.println("Etree interface doesn't exist or isn't configured as etree: " + interfaceName);
}
private IInterfaceManager interfaceManager;
public static int MAX_LENGTH = 31;
private IElanService elanProvider;
+ private ElanUtils elanUtils;
public static boolean isDisplay = true;
public void setElanProvider(IElanService elanServiceProvider) {
this.interfaceManager = interfaceManager;
}
+ public void setElanUtils(ElanUtils elanUtils) {
+ this.elanUtils = elanUtils;
+ }
+
@Override
protected Object doExecute() {
try {
if (!interfaceList.isEmpty()) {
for (String elanInterface : interfaceList) {
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(elanInterface);
- EtreeInterface etreeInterface = ElanUtils.getEtreeInterfaceByElanInterfaceName(elanInterface);
+ EtreeInterface etreeInterface = elanUtils.getEtreeInterfaceByElanInterfaceName(elanInterface);
if (interfaceInfo != null) {
System.out.println(String.format(ElanCLIUtils.ETREE_INTERFACE_CLI_FORMAT,
elanInstance.getElanInstanceName() + "/" + elanInstance.getElanTag(),
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ElanDpnInterfaceClusteredListener
extends AsyncClusteredDataChangeListenerBase<DpnInterfaces, ElanDpnInterfaceClusteredListener>
implements AutoCloseable {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanDpnInterfaceClusteredListener elanDpnInterfaceClusteredListener = null;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
private static final Logger LOG = LoggerFactory.getLogger(ElanDpnInterfaceClusteredListener.class);
+ private final DataBroker broker;
+ private final EntityOwnershipService entityOwnershipService;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
- public ElanDpnInterfaceClusteredListener(ElanServiceProvider elanServiceProvider) {
+ public ElanDpnInterfaceClusteredListener(DataBroker broker, EntityOwnershipService entityOwnershipService,
+ ElanL2GatewayUtils elanL2GatewayUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils) {
super(DpnInterfaces.class, ElanDpnInterfaceClusteredListener.class);
- this.elanServiceProvider = elanServiceProvider;
- registerListener(elanServiceProvider.getBroker());
+ this.broker = broker;
+ this.entityOwnershipService = entityOwnershipService;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
}
- public static ElanDpnInterfaceClusteredListener getElanDpnInterfaceClusteredListener(
- ElanServiceProvider elanServiceProvider) {
- if (elanDpnInterfaceClusteredListener == null) {
- synchronized (ElanDpnInterfaceClusteredListener.class) {
- if (elanDpnInterfaceClusteredListener == null) {
- elanDpnInterfaceClusteredListener = new ElanDpnInterfaceClusteredListener(elanServiceProvider);
- }
- }
- }
- return elanDpnInterfaceClusteredListener;
- }
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = elanServiceProvider.getBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), ElanDpnInterfaceClusteredListener.this, AsyncDataBroker.DataChangeScope.BASE);
- } catch (final Exception e) {
- LOG.error("DpnInterfaces DataChange listener registration fail!", e);
- }
+ public void init() {
+ registerListener(LogicalDatastoreType.OPERATIONAL, this.broker);
}
@Override
dpnInterfaces.getDpId());
return;
}
- ElanClusterUtils.runOnlyInLeaderNode(elanName, "updating mcast mac upon tunnel event",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, elanName, "updating mcast mac upon tunnel event",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
return Lists.newArrayList(
- ElanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevices(elanName));
+ elanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevices(elanName));
}
});
}
dpnInterfaces.getDpId());
return;
}
- ElanClusterUtils.runOnlyInLeaderNode(elanName, "handling ElanDpnInterface removed",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, elanName, "handling ElanDpnInterface removed",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
// deleting Elan L2Gw Devices UcastLocalMacs From Dpn
- ElanL2GatewayUtils.deleteElanL2GwDevicesUcastLocalMacsFromDpn(elanName,
+ elanL2GatewayUtils.deleteElanL2GwDevicesUcastLocalMacsFromDpn(elanName,
dpnInterfaces.getDpId());
// updating remote mcast mac on l2gw devices
return Lists.newArrayList(
- ElanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevices(elanName));
+ elanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevices(elanName));
}
});
}
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
public class ElanInstanceManager extends AsyncDataTreeChangeListenerBase<ElanInstance, ElanInstanceManager>
implements AutoCloseable {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanInstanceManager elanInstanceManager = null;
private static final Logger logger = LoggerFactory.getLogger(ElanInstanceManager.class);
- private ElanInstanceManager(ElanServiceProvider elanServiceProvider) {
+ private final DataBroker broker;
+ private final IdManagerService idManager;
+ private final ElanInterfaceManager elanInterfaceManager;
+ private final IInterfaceManager interfaceManager;
+ private final ElanUtils elanUtils;
+
+ public ElanInstanceManager(final DataBroker dataBroker, final IdManagerService managerService,
+ final ElanInterfaceManager elanInterfaceManager,
+ final IInterfaceManager interfaceManager, ElanUtils elanUtils) {
super(ElanInstance.class, ElanInstanceManager.class);
- this.elanServiceProvider = elanServiceProvider;
+ this.broker = dataBroker;
+ this.idManager = managerService;
+ this.elanInterfaceManager = elanInterfaceManager;
+ this.interfaceManager = interfaceManager;
+ this.elanUtils = elanUtils;
}
- public static ElanInstanceManager getElanInstanceManager(ElanServiceProvider elanServiceProvider) {
- if (elanInstanceManager == null) {
- synchronized (ElanInstanceManager.class) {
- if (elanInstanceManager == null) {
- elanInstanceManager = new ElanInstanceManager(elanServiceProvider);
- }
- }
- }
- return elanInstanceManager;
+ public void init() {
+ registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
@Override
List<ListenableFuture<Void>> futures = new ArrayList<>();
String elanName = deletedElan.getElanInstanceName();
// check the elan Instance present in the Operational DataStore
- Elan existingElan = ElanUtils.getElanByName(elanName);
+ Elan existingElan = elanUtils.getElanByName(elanName);
long elanTag = deletedElan.getElanTag();
// Cleaning up the existing Elan Instance
if (existingElan != null) {
List<String> elanInterfaces = existingElan.getElanInterfaces();
if (elanInterfaces != null && !elanInterfaces.isEmpty()) {
for (String elanInterfaceName : elanInterfaces) {
- InstanceIdentifier<ElanInterface> elanInterfaceId = ElanUtils
+ InstanceIdentifier<ElanInterface> elanInterfaceId = elanUtils
.getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager()
- .getInterfaceInfo(elanInterfaceName);
- elanServiceProvider.getElanInterfaceManager().removeElanInterface(futures, deletedElan, elanInterfaceName,
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(elanInterfaceName);
+ elanInterfaceManager.removeElanInterface(futures, deletedElan, elanInterfaceName,
interfaceInfo, false);
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.CONFIGURATION,
+ elanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
elanInterfaceId);
}
}
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL,
- ElanUtils.getElanInstanceOperationalDataPath(elanName));
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL,
+ elanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL,
+ elanUtils.getElanInstanceOperationalDataPath(elanName));
+ elanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL,
getElanDpnOperationDataPath(elanName));
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL,
- ElanUtils.getElanInfoEntriesOperationalDataPath(elanTag));
+ elanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL,
+ elanUtils.getElanInfoEntriesOperationalDataPath(elanTag));
}
// Release tag
- ElanUtils.releaseId(elanServiceProvider.getIdManager(), ElanConstants.ELAN_ID_POOL_NAME, elanName);
+ elanUtils.releaseId(idManager, ElanConstants.ELAN_ID_POOL_NAME, elanName);
if (deletedElan.getAugmentation(EtreeInstance.class) != null) {
removeEtreeInstance(deletedElan);
}
private void removeEtreeInstance(ElanInstance deletedElan) {
// Release leaves tag
- ElanUtils.releaseId(elanServiceProvider.getIdManager(), ElanConstants.ELAN_ID_POOL_NAME,
+ elanUtils.releaseId(idManager, ElanConstants.ELAN_ID_POOL_NAME,
deletedElan.getElanInstanceName() + ElanConstants.LEAVES_POSTFIX);
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL,
- ElanUtils.getElanInfoEntriesOperationalDataPath(
+ elanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL,
+ elanUtils.getElanInfoEntriesOperationalDataPath(
deletedElan.getAugmentation(EtreeInstance.class).getEtreeLeafTagVal().getValue()));
}
return;
} else if (update.getElanTag() == null) {
// update the elan-Instance with new properties
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.updateOperationalDataStore(elanServiceProvider.getBroker(), elanServiceProvider.getIdManager(),
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ elanUtils.updateOperationalDataStore(broker, idManager,
update, new ArrayList<String>(), tx);
- ElanUtils.waitForTransactionToComplete(tx);
+ elanUtils.waitForTransactionToComplete(tx);
return;
}
- elanServiceProvider.getElanInterfaceManager().handleunprocessedElanInterfaces(update);
+ elanInterfaceManager.handleunprocessedElanInterfaces(update);
}
@Override
protected void add(InstanceIdentifier<ElanInstance> identifier, ElanInstance elanInstanceAdded) {
- Elan elanInfo = ElanUtils.getElanByName(elanInstanceAdded.getElanInstanceName());
+ Elan elanInfo = elanUtils.getElanByName(elanInstanceAdded.getElanInstanceName());
if (elanInfo == null) {
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.updateOperationalDataStore(elanServiceProvider.getBroker(), elanServiceProvider.getIdManager(),
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ elanUtils.updateOperationalDataStore(broker, idManager,
elanInstanceAdded, new ArrayList<String>(), tx);
- ElanUtils.waitForTransactionToComplete(tx);
+ elanUtils.waitForTransactionToComplete(tx);
}
}
public ElanInstance getElanInstanceByName(String elanInstanceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
- Optional<ElanInstance> elanInstance = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanInstance> elanInstance = elanUtils.read(broker,
LogicalDatastoreType.CONFIGURATION, elanIdentifierId);
if (elanInstance.isPresent()) {
return elanInstance.get();
public List<DpnInterfaces> getElanDPNByName(String elanInstanceName) {
InstanceIdentifier<ElanDpnInterfacesList> elanIdentifier = getElanDpnOperationDataPath(elanInstanceName);
- Optional<ElanDpnInterfacesList> elanInstance = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanDpnInterfacesList> elanInstance = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, elanIdentifier);
if (elanInstance.isPresent()) {
ElanDpnInterfacesList elanDPNs = elanInstance.get();
protected ElanInstanceManager getDataTreeChangeListener() {
return this;
}
-
}
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
-
import org.apache.commons.lang3.StringUtils;
+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.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.ActionType;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
+import org.opendaylight.netvirt.elan.utils.ElanForwardingEntriesHandler;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
public class ElanInterfaceManager extends AsyncDataTreeChangeListenerBase<ElanInterface, ElanInterfaceManager>
implements AutoCloseable {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanInterfaceManager elanInterfaceManager = null;
- private static long waitTimeForSyncInstall;
+ private final DataBroker broker;
+ private final IMdsalApiManager mdsalManager;
+ private final IInterfaceManager interfaceManager;
+ private final IdManagerService idManager;
+ private final ElanForwardingEntriesHandler elanForwardingEntriesHandler;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanUtils elanUtils;
+
+ private static final long waitTimeForSyncInstall = Long.getLong("wait.time.sync.install", 300L);
+
private Map<String, ConcurrentLinkedQueue<ElanInterface>> unProcessedElanInterfaces = new ConcurrentHashMap<>();
private static final Logger logger = LoggerFactory.getLogger(ElanInterfaceManager.class);
- public ElanInterfaceManager(ElanServiceProvider elanServiceProvider) {
+ public ElanInterfaceManager(final DataBroker dataBroker,
+ final IdManagerService managerService,
+ final IMdsalApiManager mdsalApiManager,
+ IInterfaceManager interfaceManager,
+ final ElanForwardingEntriesHandler elanForwardingEntriesHandler,
+ final ElanL2GatewayUtils elanL2GatewayUtils, ElanUtils elanUtils) {
super(ElanInterface.class, ElanInterfaceManager.class);
- this.elanServiceProvider = elanServiceProvider;
+ this.broker = dataBroker;
+ this.idManager = managerService;
+ this.mdsalManager = mdsalApiManager;
+ this.interfaceManager = interfaceManager;
+ this.elanForwardingEntriesHandler = elanForwardingEntriesHandler;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanUtils = elanUtils;
}
- public static ElanInterfaceManager getElanInterfaceManager(ElanServiceProvider elanServiceProvider) {
- if (elanInterfaceManager == null) {
- synchronized (ElanInterfaceManager.class) {
- if (elanInterfaceManager == null) {
- elanInterfaceManager = new ElanInterfaceManager(elanServiceProvider);
- Long waitTime = Long.getLong("wait.time.sync.install");
- if (waitTime == null) {
- waitTime = 300L;
- }
- waitTimeForSyncInstall = waitTime;
- }
- }
- }
- return elanInterfaceManager;
+ public void init() {
+ registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
@Override
@Override
protected void remove(InstanceIdentifier<ElanInterface> identifier, ElanInterface del) {
String interfaceName = del.getName();
- ElanInstance elanInfo = ElanUtils.getElanInstanceByName(del.getElanInstanceName());
+ ElanInstance elanInfo = elanUtils.getElanInstanceByName(del.getElanInstanceName());
/*
* Handling in case the elan instance is deleted.If the Elan instance is
* deleted, there is no need to explicitly delete the elan interfaces
if (elanInfo == null) {
return;
}
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
String elanInstanceName = elanInfo.getElanInstanceName();
DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
InterfaceRemoveWorkerOnElan configWorker = new InterfaceRemoveWorkerOnElan(elanInstanceName, elanInfo,
String elanName = elanInfo.getElanInstanceName();
boolean isLastElanInterface = false;
long elanTag = elanInfo.getElanTag();
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- WriteTransaction deleteFlowGroupTx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ WriteTransaction deleteFlowGroupTx = broker.newWriteOnlyTransaction();
Elan elanState = removeElanStateForInterface(elanInfo, interfaceName, tx);
if (elanState == null) {
return;
private void removeEtreeUnknownDmacFlow(BigInteger dpId, ElanInstance elanInfo,
WriteTransaction deleteFlowGroupTx) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanInfo.getElanTag());
+ EtreeLeafTagName etreeLeafTag = elanUtils.getEtreeLeafTagByElanTag(elanInfo.getElanTag());
if (etreeLeafTag != null) {
long leafTag = etreeLeafTag.getEtreeLeafTag().getValue();
removeUnknownDmacFlow(dpId, elanInfo, deleteFlowGroupTx, leafTag);
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBuckets));
logger.trace("deleted the localBroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().removeGroupToTx(dpnId, group, deleteFlowGroupTx);
+ mdsalManager.removeGroupToTx(dpnId, group, deleteFlowGroupTx);
}
}
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBuckets));
logger.trace("deleting the remoteBroadCast group:{}", group);
- elanServiceProvider.getMdsalManager().removeGroupToTx(dpnId, group, deleteFlowGroupTx);
+ mdsalManager.removeGroupToTx(dpnId, group, deleteFlowGroupTx);
}
}
private Elan removeElanStateForInterface(ElanInstance elanInfo, String interfaceName, WriteTransaction tx) {
String elanName = elanInfo.getElanInstanceName();
- Elan elanState = ElanUtils.getElanByName(elanName);
+ Elan elanState = elanUtils.getElanByName(elanName);
if (elanState == null) {
return elanState;
}
private void deleteElanInterfaceFromConfigDS(String interfaceName, WriteTransaction tx) {
// removing the ElanInterface from the config data_store if interface is
// not present in Interface config DS
- if (elanServiceProvider.getInterfaceManager().getInterfaceInfoFromConfigDataStore(interfaceName) == null) {
+ if (interfaceManager.getInterfaceInfoFromConfigDataStore(interfaceName) == null) {
tx.delete(LogicalDatastoreType.CONFIGURATION,
ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName));
}
void removeEntriesForElanInterface(List<ListenableFuture<Void>> futures, ElanInstance elanInfo, InterfaceInfo interfaceInfo, String interfaceName,
boolean isInterfaceStateRemoved, boolean isLastElanInterface) {
String elanName = elanInfo.getElanInstanceName();
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- WriteTransaction deleteFlowGroupTx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ WriteTransaction deleteFlowGroupTx = broker.newWriteOnlyTransaction();
InstanceIdentifier<ElanInterfaceMac> elanInterfaceId = ElanUtils
.getElanInterfaceMacEntriesOperationalDataPath(interfaceName);
logger.debug("Removing the Interface:{} from elan:{}", interfaceName, elanName);
if (interfaceInfo != null) {
- Optional<ElanInterfaceMac> existingElanInterfaceMac = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanInterfaceMac> existingElanInterfaceMac = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, elanInterfaceId);
if (existingElanInterfaceMac.isPresent()) {
List<PhysAddress> macAddresses = new ArrayList<PhysAddress>();
tx.delete(LogicalDatastoreType.OPERATIONAL,
ElanUtils.getMacEntryOperationalDataPath(elanName, macEntry.getMacAddress()));
}
- ElanUtils.deleteMacFlows(elanInfo, interfaceInfo, macEntry, deleteFlowGroupTx);
+ elanUtils.deleteMacFlows(elanInfo, interfaceInfo, macEntry, deleteFlowGroupTx);
macAddresses.add(macEntry.getMacAddress());
}
// Removing all those MACs from External Devices belonging
// to this ELAN
if (ElanUtils.isVxlan(elanInfo)) {
- ElanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInfo, macAddresses);
+ elanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInfo, macAddresses);
}
}
}
} else {
// Interface does not exist in ConfigDS, so lets remove everything
// about that interface related to Elan
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
+ ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
for (MacEntry macEntry : macEntries) {
private DpnInterfaces removeElanDpnInterfaceFromOperationalDataStore(String elanName, BigInteger dpId,
String interfaceName, long elanTag, WriteTransaction tx) {
- DpnInterfaces dpnInterfaces = ElanUtils.getElanInterfaceInfoByElanDpn(elanName, dpId);
+ DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanName, dpId);
if (dpnInterfaces != null) {
List<String> interfaceLists = dpnInterfaces.getInterfaces();
interfaceLists.remove(interfaceName);
}
private void deleteAllRemoteMacsInADpn(String elanName, BigInteger dpId, long elanTag) {
- List<DpnInterfaces> dpnInterfaces = ElanUtils.getInvolvedDpnsInElan(elanName);
+ List<DpnInterfaces> dpnInterfaces = elanUtils.getInvolvedDpnsInElan(elanName);
for (DpnInterfaces dpnInterface : dpnInterfaces) {
BigInteger currentDpId = dpnInterface.getDpId();
if (!currentDpId.equals(dpId)) {
for (String elanInterface : dpnInterface.getInterfaces()) {
- ElanInterfaceMac macs = ElanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
+ ElanInterfaceMac macs = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (macs == null || macs.getMacEntry() == null) {
continue;
}
}
private void removeEtreeMacFlowInTheDPN(BigInteger dpId, long elanTag, BigInteger currentDpId, MacEntry mac) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeLeafTag = elanUtils.getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
removeTheMacFlowInTheDPN(dpId, etreeLeafTag.getEtreeLeafTag().getValue(), currentDpId, mac);
}
}
private void removeTheMacFlowInTheDPN(BigInteger dpId, long elanTag, BigInteger currentDpId, MacEntry mac) {
- elanServiceProvider.getMdsalManager()
+ mdsalManager
.removeFlow(dpId,
MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE,
ElanUtils.getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, currentDpId,
if (updatedPhysAddress.size() > 0) {
for (PhysAddress physAddress : updatedPhysAddress) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanName, physAddress);
- Optional<MacEntry> existingMacEntry = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<MacEntry> existingMacEntry = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, macId);
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
if (existingMacEntry.isPresent()) {
- elanServiceProvider.getElanForwardingEntriesHandler().updateElanInterfaceForwardingTablesList(
+ elanForwardingEntriesHandler.updateElanInterfaceForwardingTablesList(
elanName, interfaceName, existingMacEntry.get().getInterface(), existingMacEntry.get(),
tx);
} else {
- elanServiceProvider.getElanForwardingEntriesHandler().addElanInterfaceForwardingTableList(
- ElanUtils.getElanInstanceByName(elanName), interfaceName, physAddress, tx);
+ elanForwardingEntriesHandler.addElanInterfaceForwardingTableList(
+ elanUtils.getElanInstanceByName(elanName), interfaceName, physAddress, tx);
}
ElanUtils.waitForTransactionToComplete(tx);
}
protected void add(InstanceIdentifier<ElanInterface> identifier, ElanInterface elanInterfaceAdded) {
String elanInstanceName = elanInterfaceAdded.getElanInstanceName();
String interfaceName = elanInterfaceAdded.getName();
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
if (interfaceInfo == null) {
logger.warn("Interface {} is removed from Interface Oper DS due to port down ", interfaceName);
return;
}
- ElanInstance elanInstance = ElanUtils.getElanInstanceByName(elanInstanceName);
+ ElanInstance elanInstance = elanUtils.getElanInstanceByName(elanInstanceName);
if (elanInstance == null) {
elanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
.setDescription(elanInterfaceAdded.getDescription()).build();
// Add the ElanInstance in the Configuration data-store
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
List<String> elanInterfaces = new ArrayList<String>();
elanInterfaces.add(interfaceName);
- ElanUtils.updateOperationalDataStore(elanServiceProvider.getBroker(), elanServiceProvider.getIdManager(),
+ ElanUtils.updateOperationalDataStore(broker, idManager,
elanInstance, elanInterfaces, tx);
ElanUtils.waitForTransactionToComplete(tx);
- elanInstance = ElanUtils.getElanInstanceByName(elanInstanceName);
+ elanInstance = elanUtils.getElanInstanceByName(elanInstanceName);
}
Long elanTag = elanInstance.getElanTag();
}
for (ElanInterface elanInterface : elanInterfaces) {
String interfaceName = elanInterface.getName();
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
addElanInterface(futures, elanInterface, interfaceInfo, elanInstance);
}
}
void programRemoteDmacFlow(ElanInstance elanInstance, InterfaceInfo interfaceInfo,
WriteTransaction writeFlowGroupTx) {
- ElanDpnInterfacesList elanDpnInterfacesList = ElanUtils
+ ElanDpnInterfacesList elanDpnInterfacesList = elanUtils
.getElanDpnInterfacesList(elanInstance.getElanInstanceName());
List<DpnInterfaces> dpnInterfaceLists = null;
if (elanDpnInterfacesList != null) {
}
List<String> remoteElanInterfaces = dpnInterfaces.getInterfaces();
for (String remoteIf : remoteElanInterfaces) {
- ElanInterfaceMac elanIfMac = ElanUtils.getElanInterfaceMacByInterfaceName(remoteIf);
- InterfaceInfo remoteInterface = elanServiceProvider.getInterfaceManager().getInterfaceInfo(remoteIf);
+ ElanInterfaceMac elanIfMac = elanUtils.getElanInterfaceMacByInterfaceName(remoteIf);
+ InterfaceInfo remoteInterface = interfaceManager.getInterfaceInfo(remoteIf);
if (elanIfMac == null) {
continue;
}
if (remoteMacEntries != null) {
for (MacEntry macEntry : remoteMacEntries) {
PhysAddress physAddress = macEntry.getMacAddress();
- ElanUtils.setupRemoteDmacFlow(interfaceInfo.getDpId(), remoteInterface.getDpId(),
+ elanUtils.setupRemoteDmacFlow(interfaceInfo.getDpId(), remoteInterface.getDpId(),
remoteInterface.getInterfaceTag(), elanInstance.getElanTag(), physAddress.getValue(),
elanInstance.getElanInstanceName(), writeFlowGroupTx, remoteIf);
}
String interfaceName = elanInterface.getName();
String elanInstanceName = elanInterface.getElanInstanceName();
- Elan elanInfo = ElanUtils.getElanByName(elanInstanceName);
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ Elan elanInfo = elanUtils.getElanByName(elanInstanceName);
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
if (elanInfo == null) {
List<String> elanInterfaces = new ArrayList<String>();
elanInterfaces.add(interfaceName);
- ElanUtils.updateOperationalDataStore(elanServiceProvider.getBroker(), elanServiceProvider.getIdManager(),
+ ElanUtils.updateOperationalDataStore(broker, idManager,
elanInstance, elanInterfaces, tx);
} else {
createElanStateList(elanInstanceName, interfaceName, tx);
if (dpId != null && !dpId.equals(ElanConstants.INVALID_DPN)) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfaces = ElanUtils
.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId);
- Optional<DpnInterfaces> existingElanDpnInterfaces = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<DpnInterfaces> existingElanDpnInterfaces = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaces);
if (!existingElanDpnInterfaces.isPresent()) {
isFirstInterfaceInDpn = true;
if (ElanUtils.isVxlan(elanInstance)) {
setExternalTunnelTable(dpId, elanInstance);
}
- ElanL2GatewayUtils.installElanL2gwDevicesLocalMacsInDpn(dpId, elanInstance, interfaceName);
+ elanL2GatewayUtils.installElanL2gwDevicesLocalMacsInDpn(dpId, elanInstance, interfaceName);
} else {
List<String> elanInterfaces = existingElanDpnInterfaces.get().getInterfaces();
elanInterfaces.add(interfaceName);
if (elanInterfaces.size() == 1) {// 1st dpn interface
- ElanL2GatewayUtils.installElanL2gwDevicesLocalMacsInDpn(dpId, elanInstance, interfaceName);
+ elanL2GatewayUtils.installElanL2gwDevicesLocalMacsInDpn(dpId, elanInstance, interfaceName);
}
dpnInterfaces = updateElanDpnInterfacesList(elanInstanceName, dpId, elanInterfaces, tx);
}
InterfaceInfo interfaceInfo, boolean isFirstInterfaceInDpn) {
String elanInstanceName = elanInstance.getElanInstanceName();
String interfaceName = elanInterface.getName();
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
BigInteger dpId = interfaceInfo.getDpId();
- WriteTransaction writeFlowGroupTx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction writeFlowGroupTx = broker.newWriteOnlyTransaction();
installEntriesForElanInterface(elanInstance, interfaceInfo, isFirstInterfaceInDpn, tx, writeFlowGroupTx);
List<PhysAddress> staticMacAddresses = elanInterface.getStaticMacEntries();
if (staticMacAddresses != null) {
boolean isInterfaceOperational = isOperational(interfaceInfo);
for (PhysAddress physAddress : staticMacAddresses) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanInstanceName, physAddress);
- Optional<MacEntry> existingMacEntry = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<MacEntry> existingMacEntry = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, macId);
if (existingMacEntry.isPresent()) {
- elanServiceProvider.getElanForwardingEntriesHandler().updateElanInterfaceForwardingTablesList(
+ elanForwardingEntriesHandler.updateElanInterfaceForwardingTablesList(
elanInstanceName, interfaceName, existingMacEntry.get().getInterface(),
existingMacEntry.get(), tx);
} else {
- elanServiceProvider.getElanForwardingEntriesHandler()
+ elanForwardingEntriesHandler
.addElanInterfaceForwardingTableList(elanInstance, interfaceName, physAddress, tx);
}
if (isInterfaceOperational) {
// Setting SMAC, DMAC, UDMAC in this DPN and also in other
// DPNs
- ElanUtils.setupMacFlows(elanInstance, interfaceInfo, ElanConstants.STATIC_MAC_TIMEOUT,
+ elanUtils.setupMacFlows(elanInstance, interfaceInfo, ElanConstants.STATIC_MAC_TIMEOUT,
physAddress.getValue(), writeFlowGroupTx);
}
}
if (isInterfaceOperational) {
// Add MAC in TOR's remote MACs via OVSDB. Outside of the loop
// on purpose.
- ElanL2GatewayUtils.scheduleAddDpnMacInExtDevices(elanInstance.getElanInstanceName(), dpId,
+ elanL2GatewayUtils.scheduleAddDpnMacInExtDevices(elanInstance.getElanInstanceName(), dpId,
staticMacAddresses);
}
}
protected void removeInterfaceStaticMacEntires(String elanInstanceName, String interfaceName,
PhysAddress physAddress) {
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanInstanceName, physAddress);
- Optional<MacEntry> existingMacEntry = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<MacEntry> existingMacEntry = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, macId);
if (!existingMacEntry.isPresent()) {
MacEntry macEntry = new MacEntryBuilder().setMacAddress(physAddress).setInterface(interfaceName)
.setKey(new MacEntryKey(physAddress)).build();
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- elanServiceProvider.getElanForwardingEntriesHandler().deleteElanInterfaceForwardingEntries(
- ElanUtils.getElanInstanceByName(elanInstanceName), interfaceInfo, macEntry, tx);
- elanServiceProvider.getElanForwardingEntriesHandler().deleteElanInterfaceMacForwardingEntries(interfaceName,
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ elanForwardingEntriesHandler.deleteElanInterfaceForwardingEntries(
+ elanUtils.getElanInstanceByName(elanInstanceName), interfaceInfo, macEntry, tx);
+ elanForwardingEntriesHandler.deleteElanInterfaceMacForwardingEntries(interfaceName,
physAddress, tx);
ElanUtils.waitForTransactionToComplete(tx);
}
return;
}
BigInteger dpId = interfaceInfo.getDpId();
- ElanUtils.setupTermDmacFlows(interfaceInfo, elanServiceProvider.getMdsalManager(), writeFlowGroupTx);
+ elanUtils.setupTermDmacFlows(interfaceInfo, mdsalManager, writeFlowGroupTx);
setupFilterEqualsTable(elanInstance, interfaceInfo, writeFlowGroupTx);
if (isFirstInterfaceInDpn) {
// Terminating Service , UnknownDMAC Table.
programRemoteDmacFlow(elanInstance, interfaceInfo, writeFlowGroupTx);
}
// bind the Elan service to the Interface
- bindService(elanInstance, ElanUtils.getElanInterfaceByElanInterfaceName(interfaceInfo.getInterfaceName()), tx);
+ bindService(elanInstance, elanUtils.getElanInterfaceByElanInterfaceName(interfaceInfo.getInterfaceName()), tx);
}
public void installEntriesForFirstInterfaceonDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
getFlowRef(NwConstants.ELAN_FILTER_EQUALS_TABLE, ifTag), 9, elanInfo.getElanInstanceName(), 0, 0,
ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)),
getTunnelIdMatchForFilterEqualsLPortTag(ifTag),
- ElanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
+ elanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
- elanServiceProvider.getMdsalManager().addFlowToTx(interfaceInfo.getDpId(), flow, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(interfaceInfo.getDpId(), flow, writeFlowGroupTx);
Flow flowEntry = MDSALUtil.buildFlowNew(NwConstants.ELAN_FILTER_EQUALS_TABLE,
getFlowRef(NwConstants.ELAN_FILTER_EQUALS_TABLE, 1000 + ifTag), 10, elanInfo.getElanInstanceName(), 0,
0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)),
getMatchesForFilterEqualsLPortTag(ifTag), MDSALUtil.buildInstructionsDrop());
- elanServiceProvider.getMdsalManager().addFlowToTx(interfaceInfo.getDpId(), flowEntry, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(interfaceInfo.getDpId(), flowEntry, writeFlowGroupTx);
}
public void removeFilterEqualsTable(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
getFlowRef(NwConstants.ELAN_FILTER_EQUALS_TABLE, ifTag), 9, elanInfo.getElanInstanceName(), 0, 0,
ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)),
getTunnelIdMatchForFilterEqualsLPortTag(ifTag),
- ElanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
+ elanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
- elanServiceProvider.getMdsalManager().removeFlowToTx(interfaceInfo.getDpId(), flow, deleteFlowGroupTx);
+ mdsalManager.removeFlowToTx(interfaceInfo.getDpId(), flow, deleteFlowGroupTx);
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.ELAN_FILTER_EQUALS_TABLE,
getFlowRef(NwConstants.ELAN_FILTER_EQUALS_TABLE, 1000 + ifTag), 10, elanInfo.getElanInstanceName(), 0,
0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)),
getMatchesForFilterEqualsLPortTag(ifTag), MDSALUtil.buildInstructionsDrop());
- elanServiceProvider.getMdsalManager().removeFlowToTx(interfaceInfo.getDpId(), flowEntity, deleteFlowGroupTx);
+ mdsalManager.removeFlowToTx(interfaceInfo.getDpId(), flowEntity, deleteFlowGroupTx);
}
private List<Bucket> getRemoteBCGroupBucketInfos(ElanInstance elanInfo, int bucketKeyStart,
private List<Bucket> getRemoteBCGroupBuckets(ElanInstance elanInfo, DpnInterfaces dpnInterfaces, BigInteger dpnId,
int bucketId, long elanTag) {
List<Bucket> listBucketInfo = new ArrayList<Bucket>();
- ElanDpnInterfacesList elanDpns = ElanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
+ ElanDpnInterfacesList elanDpns = elanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
listBucketInfo.addAll(getRemoteBCGroupTunnelBuckets(elanDpns, dpnId, bucketId, elanTag));
listBucketInfo.addAll(getRemoteBCGroupExternalPortBuckets(elanDpns, dpnInterfaces, dpnId, bucketId));
listBucketInfo.addAll(getRemoteBCGroupBucketsOfElanL2GwDevices(elanInfo, dpnId, bucketId));
List<Bucket> listBucketInfo = new ArrayList<Bucket>();
if (elanDpns != null) {
for (DpnInterfaces dpnInterface : elanDpns.getDpnInterfaces()) {
- if (ElanUtils.isDpnPresent(dpnInterface.getDpId()) && dpnInterface.getDpId() != dpnId
+ if (elanUtils.isDpnPresent(dpnInterface.getDpId()) && dpnInterface.getDpId() != dpnId
&& dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
try {
- List<Action> listActionInfo = ElanUtils.getInternalTunnelItmEgressAction(dpnId,
+ List<Action> listActionInfo = elanUtils.getInternalTunnelItmEgressAction(dpnId,
dpnInterface.getDpId(), elanTag);
if (listActionInfo.isEmpty()) {
continue;
private List<Bucket> getRemoteBCGroupExternalPortBuckets(ElanDpnInterfacesList elanDpns,
DpnInterfaces dpnInterfaces, BigInteger dpnId, int bucketId) {
DpnInterfaces currDpnInterfaces = dpnInterfaces != null ? dpnInterfaces : getDpnInterfaces(elanDpns, dpnId);
- if (currDpnInterfaces == null || !ElanUtils.isDpnPresent(currDpnInterfaces.getDpId())
+ if (currDpnInterfaces == null || !elanUtils.isDpnPresent(currDpnInterfaces.getDpId())
|| currDpnInterfaces.getInterfaces() == null || currDpnInterfaces.getInterfaces().isEmpty()) {
return Collections.emptyList();
}
List<Bucket> listBucketInfo = new ArrayList<Bucket>();
for (String interfaceName : currDpnInterfaces.getInterfaces()) {
- if (ElanUtils.isExternal(interfaceName)) {
- List<Action> listActionInfo = ElanUtils.getExternalPortItmEgressAction(interfaceName);
+ if (elanUtils.isExternal(interfaceName)) {
+ List<Action> listActionInfo = elanUtils.getExternalPortItmEgressAction(interfaceName);
if (!listActionInfo.isEmpty()) {
listBucketInfo.add(MDSALUtil.buildBucket(listActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
long groupId = ElanUtils.getElanRemoteBCGID(elanTag);
List<Bucket> listBucket = new ArrayList<Bucket>();
int bucketId = 0;
- ElanDpnInterfacesList elanDpns = ElanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
+ ElanDpnInterfacesList elanDpns = elanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
if (elanDpns != null) {
List<DpnInterfaces> dpnInterfaceses = elanDpns.getDpnInterfaces();
for (DpnInterfaces dpnInterface : dpnInterfaceses) {
List<Bucket> remoteListBucketInfo = new ArrayList<Bucket>();
- if (ElanUtils.isDpnPresent(dpnInterface.getDpId()) && !dpnInterface.getDpId().equals(dpId)
+ if (elanUtils.isDpnPresent(dpnInterface.getDpId()) && !dpnInterface.getDpId().equals(dpId)
&& dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
List<Action> listAction = new ArrayList<Action>();
int actionKey = 0;
bucketId++;
remoteListBucketInfo.addAll(listBucket);
for (DpnInterfaces otherFes : dpnInterfaceses) {
- if (ElanUtils.isDpnPresent(otherFes.getDpId()) && otherFes.getDpId() != dpnInterface.getDpId()
+ if (elanUtils.isDpnPresent(otherFes.getDpId()) && otherFes.getDpId() != dpnInterface.getDpId()
&& otherFes.getInterfaces() != null && !otherFes.getInterfaces().isEmpty()) {
try {
- List<Action> remoteListActionInfo = ElanUtils.getInternalTunnelItmEgressAction(
+ List<Action> remoteListActionInfo = elanUtils.getInternalTunnelItmEgressAction(
dpnInterface.getDpId(), otherFes.getDpId(), elanTag);
if (!remoteListActionInfo.isEmpty()) {
remoteListBucketInfo
}
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(remoteListBucketInfo));
- elanServiceProvider.getMdsalManager().addGroupToTx(dpnInterface.getDpId(), group, tx);
+ mdsalManager.addGroupToTx(dpnInterface.getDpId(), group, tx);
}
}
}
// Install DMAC entry on dst DPN
public void installDMacAddressTables(ElanInstance elanInfo, InterfaceInfo interfaceInfo, BigInteger dstDpId) {
String interfaceName = interfaceInfo.getInterfaceName();
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
+ ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
- WriteTransaction writeFlowTx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction writeFlowTx = broker.newWriteOnlyTransaction();
List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
for (MacEntry macEntry : macEntries) {
PhysAddress physAddress = macEntry.getMacAddress();
- ElanUtils.setupDMacFlowonRemoteDpn(elanInfo, interfaceInfo, dstDpId, physAddress.getValue(),
+ elanUtils.setupDMacFlowonRemoteDpn(elanInfo, interfaceInfo, dstDpId, physAddress.getValue(),
writeFlowTx);
}
writeFlowTx.submit();
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBucket));
logger.trace("Installing the remote BroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().syncInstallGroup(dpnId, group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
+ mdsalManager.syncInstallGroup(dpnId, group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
public void setupLeavesEtreeBroadcastGroups(ElanInstance elanInfo, DpnInterfaces dpnInterfaces, BigInteger dpnId) {
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBucket));
logger.trace("Installing the remote BroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().syncInstallGroup(dpnId, group,
+ mdsalManager.syncInstallGroup(dpnId, group,
ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
}
for (String ifName : interfaces) {
// In case if there is a InterfacePort in the cache which is not in
// operational state, skip processing it
- InterfaceInfo ifInfo = elanServiceProvider.getInterfaceManager()
+ InterfaceInfo ifInfo = interfaceManager
.getInterfaceInfoFromOperationalDataStore(ifName, interfaceInfo.getInterfaceType());
if (!isOperational(ifInfo)) {
continue;
}
- if (!ElanUtils.isExternal(ifName)) {
+ if (!elanUtils.isExternal(ifName)) {
listBucket.add(MDSALUtil.buildBucket(getInterfacePortActions(ifInfo), MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
bucketId++;
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBucket));
logger.trace("installing the localBroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().syncInstallGroup(interfaceInfo.getDpId(), group,
+ mdsalManager.syncInstallGroup(interfaceInfo.getDpId(), group,
ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
// In case if there is a InterfacePort in the cache which is not
// in
// operational state, skip processing it
- InterfaceInfo ifInfo = elanServiceProvider.getInterfaceManager()
+ InterfaceInfo ifInfo = interfaceManager
.getInterfaceInfoFromOperationalDataStore(ifName, interfaceInfo.getInterfaceType());
if (!isOperational(ifInfo)) {
continue;
}
- if (!ElanUtils.isExternal(ifName)) {
+ if (!elanUtils.isExternal(ifName)) {
// only add root interfaces
bucketId = addInterfaceIfRootInterface(bucketId, ifName, listBucket, ifInfo);
}
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBucket));
logger.trace("installing the localBroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().syncInstallGroup(interfaceInfo.getDpId(), group,
+ mdsalManager.syncInstallGroup(interfaceInfo.getDpId(), group,
ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
}
private int addInterfaceIfRootInterface(int bucketId, String ifName, List<Bucket> listBucket,
InterfaceInfo ifInfo) {
- EtreeInterface etreeInterface = ElanUtils.getEtreeInterfaceByElanInterfaceName(ifName);
+ EtreeInterface etreeInterface = elanUtils.getEtreeInterfaceByElanInterfaceName(ifName);
if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
listBucket.add(MDSALUtil.buildBucket(getInterfacePortActions(ifInfo), MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBuckets));
logger.trace("deleted the localBroadCast Group:{}", group);
- elanServiceProvider.getMdsalManager().removeGroupToTx(dpnId, group, deleteFlowGroupTx);
+ mdsalManager.removeGroupToTx(dpnId, group, deleteFlowGroupTx);
}
public void removeElanBroadcastGroup(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBuckets));
logger.trace("deleting the remoteBroadCast group:{}", group);
- elanServiceProvider.getMdsalManager().removeGroupToTx(dpnId, group, deleteFlowGroupTx);
+ mdsalManager.removeGroupToTx(dpnId, group, deleteFlowGroupTx);
}
/**
ITMConstants.COOKIE_ITM_EXTERNAL.add(BigInteger.valueOf(elanTag)),
buildMatchesForVni(elanInfo.getSegmentationId()), getInstructionsExtTunnelTable(elanTag));
- elanServiceProvider.getMdsalManager().installFlow(flowEntity);
+ mdsalManager.installFlow(flowEntity);
}
/**
FlowEntity flowEntity = new FlowEntity(dpnId);
flowEntity.setTableId(NwConstants.EXTERNAL_TUNNEL_TABLE);
flowEntity.setFlowId(flowId);
- elanServiceProvider.getMdsalManager().removeFlow(flowEntity);
+ mdsalManager.removeFlow(flowEntity);
}
public void setupTerminateServiceTable(ElanInstance elanInfo, BigInteger dpId, WriteTransaction writeFlowGroupTx) {
ElanUtils.getTunnelMatchesForServiceId((int) elanTag),
getInstructionsForOutGroup(ElanUtils.getElanLocalBCGID(elanTag)));
- elanServiceProvider.getMdsalManager().addFlowToTx(dpId, flowEntity, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(dpId, flowEntity, writeFlowGroupTx);
}
public void setupUnknownDMacTable(ElanInstance elanInfo, BigInteger dpId, WriteTransaction writeFlowGroupTx) {
private void setupEtreeUnknownDMacTable(ElanInstance elanInfo, BigInteger dpId, long elanTag,
WriteTransaction writeFlowGroupTx) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeLeafTag = elanUtils.getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
long leafTag = etreeLeafTag.getEtreeLeafTag().getValue();
installRemoteUnknownFlow(elanInfo, dpId, leafTag, writeFlowGroupTx);
getMatchesForElanTag(elanTag, /* SH flag */false),
getInstructionsForOutGroup(ElanUtils.getElanRemoteBCGID(elanTag)));
- elanServiceProvider.getMdsalManager().addFlowToTx(dpId, flowEntity, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(dpId, flowEntity, writeFlowGroupTx);
}
private void installRemoteUnknownFlow(ElanInstance elanInfo, BigInteger dpId, long elanTag,
ElanConstants.COOKIE_ELAN_UNKNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
getMatchesForElanTag(elanTag, /* SH flag */true),
getInstructionsForOutGroup(ElanUtils.getElanLocalBCGID(elanTag)));
- elanServiceProvider.getMdsalManager().addFlowToTx(dpId, flowEntity2, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(dpId, flowEntity2, writeFlowGroupTx);
}
}
long elanTag) {
Flow flow = new FlowBuilder().setId(new FlowId(getUnknownDmacFlowRef(NwConstants.ELAN_UNKNOWN_DMAC_TABLE,
elanTag, /* SH flag */ false))).setTableId(NwConstants.ELAN_UNKNOWN_DMAC_TABLE).build();
- elanServiceProvider.getMdsalManager().removeFlowToTx(dpId, flow, deleteFlowGroupTx);
+ mdsalManager.removeFlowToTx(dpId, flow, deleteFlowGroupTx);
if (ElanUtils.isVxlan(elanInfo)) {
Flow flow2 = new FlowBuilder().setId(new FlowId(getUnknownDmacFlowRef(NwConstants.ELAN_UNKNOWN_DMAC_TABLE,
elanTag, /* SH flag */ true))).setTableId(NwConstants.ELAN_UNKNOWN_DMAC_TABLE)
.build();
- elanServiceProvider.getMdsalManager().removeFlowToTx(dpId, flow2, deleteFlowGroupTx);
+ mdsalManager.removeFlowToTx(dpId, flow2, deleteFlowGroupTx);
}
}
private void removeDefaultTermFlow(BigInteger dpId, long elanTag) {
- ElanUtils.removeTerminatingServiceAction(dpId, (int) elanTag);
+ elanUtils.removeTerminatingServiceAction(dpId, (int) elanTag);
}
private void bindService(ElanInstance elanInfo, ElanInterface elanInterface, WriteTransaction tx) {
private void createElanInterfaceTablesList(String interfaceName, WriteTransaction tx) {
InstanceIdentifier<ElanInterfaceMac> elanInterfaceMacTables = ElanUtils
.getElanInterfaceMacEntriesOperationalDataPath(interfaceName);
- Optional<ElanInterfaceMac> interfaceMacTables = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanInterfaceMac> interfaceMacTables = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, elanInterfaceMacTables);
// Adding new Elan Interface Port to the operational DataStore without
// Static-Mac Entries..
private void createElanStateList(String elanInstanceName, String interfaceName, WriteTransaction tx) {
InstanceIdentifier<Elan> elanInstance = ElanUtils.getElanInstanceOperationalDataPath(elanInstanceName);
- Optional<Elan> elanInterfaceLists = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<Elan> elanInterfaceLists = elanUtils.read(broker,
LogicalDatastoreType.OPERATIONAL, elanInstance);
// Adding new Elan Interface Port to the operational DataStore without
// Static-Mac Entries..
}
public void handleInternalTunnelStateEvent(BigInteger srcDpId, BigInteger dstDpId) {
- ElanDpnInterfaces dpnInterfaceLists = ElanUtils.getElanDpnInterfacesList();
+ ElanDpnInterfaces dpnInterfaceLists = elanUtils.getElanDpnInterfacesList();
if (dpnInterfaceLists == null) {
return;
}
}
if (cnt == 2) {
logger.debug("Elan instance:{} is present b/w srcDpn:{} and dstDpn:{}", elanName, srcDpId, dstDpId);
- ElanInstance elanInfo = ElanUtils.getElanInstanceByName(elanName);
+ ElanInstance elanInfo = elanUtils.getElanInstanceByName(elanName);
// update Remote BC Group
setupElanBroadcastGroups(elanInfo, srcDpId);
- DpnInterfaces dpnInterface = ElanUtils.getElanInterfaceInfoByElanDpn(elanName, dstDpId);
+ DpnInterfaces dpnInterface = elanUtils.getElanInterfaceInfoByElanDpn(elanName, dstDpId);
Set<String> interfaceLists = new HashSet<>();
interfaceLists.addAll(dpnInterface.getInterfaces());
for (String ifName : interfaceLists) {
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(ifName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(ifName);
if (isOperational(interfaceInfo)) {
installDMacAddressTables(elanInfo, interfaceInfo, srcDpId);
}
return;
}
- ElanDpnInterfaces dpnInterfaceLists = ElanUtils.getElanDpnInterfacesList();
+ ElanDpnInterfaces dpnInterfaceLists = elanUtils.getElanDpnInterfacesList();
if (dpnInterfaceLists == null) {
return;
}
List<ElanDpnInterfacesList> elanDpnIf = dpnInterfaceLists.getElanDpnInterfacesList();
for (ElanDpnInterfacesList elanDpns : elanDpnIf) {
String elanName = elanDpns.getElanInstanceName();
- ElanInstance elanInfo = ElanUtils.getElanInstanceByName(elanName);
+ ElanInstance elanInfo = elanUtils.getElanInstanceByName(elanName);
- DpnInterfaces dpnInterfaces = ElanUtils.getElanInterfaceInfoByElanDpn(elanName, dpId);
+ DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanName, dpId);
if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null
|| dpnInterfaces.getInterfaces().isEmpty()) {
continue;
setupElanBroadcastGroups(elanInfo, dpId);
// install L2gwDevices local macs in dpn.
- ElanL2GatewayUtils.installL2gwDeviceMacsInDpn(dpId, externalNodeId, elanInfo, intrf.getName());
+ elanL2GatewayUtils.installL2gwDeviceMacsInDpn(dpId, externalNodeId, elanInfo, intrf.getName());
// Install dpn macs on external device
- ElanL2GatewayUtils.installDpnMacsInL2gwDevice(elanName, new HashSet<>(dpnInterfaces.getInterfaces()), dpId,
+ elanL2GatewayUtils.installDpnMacsInL2gwDevice(elanName, new HashSet<>(dpnInterfaces.getInterfaces()), dpId,
externalNodeId);
}
logger.info("Handled ExternalTunnelStateEvent for {}", externalTunnel);
if (intrf.getOperStatus() == Interface.OperStatus.Up) {
String srcDevice = externalTunnel.getDestinationDevice();
String destDevice = externalTunnel.getSourceDevice();
- ExternalTunnel otherEndPointExtTunnel = ElanUtils.getExternalTunnel(srcDevice, destDevice,
+ ExternalTunnel otherEndPointExtTunnel = elanUtils.getExternalTunnel(srcDevice, destDevice,
LogicalDatastoreType.CONFIGURATION);
if (logger.isTraceEnabled()) {
logger.trace("Validating external tunnel state: src tunnel {}, dest tunnel {}", externalTunnel,
}
if (otherEndPointExtTunnel != null) {
boolean otherEndPointInterfaceOperational = ElanUtils.isInterfaceOperational(
- otherEndPointExtTunnel.getTunnelInterfaceName(), elanServiceProvider.getBroker());
+ otherEndPointExtTunnel.getTunnelInterfaceName(), broker);
if (otherEndPointInterfaceOperational) {
return true;
} else {
}
public void updateRemoteBroadcastGroupForAllElanDpns(ElanInstance elanInfo) {
- List<DpnInterfaces> dpns = ElanUtils.getInvolvedDpnsInElan(elanInfo.getElanInstanceName());
+ List<DpnInterfaces> dpns = elanUtils.getInvolvedDpnsInElan(elanInfo.getElanInstanceName());
if (dpns == null) {
return;
}
}
}
- public static List<Bucket> getRemoteBCGroupBucketsOfElanL2GwDevices(ElanInstance elanInfo, BigInteger dpnId,
+ public List<Bucket> getRemoteBCGroupBucketsOfElanL2GwDevices(ElanInstance elanInfo, BigInteger dpnId,
int bucketId) {
List<Bucket> listBucketInfo = new ArrayList<Bucket>();
ConcurrentMap<String, L2GatewayDevice> map = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elanInfo.getElanInstanceName());
for (L2GatewayDevice device : map.values()) {
- String interfaceName = ElanL2GatewayUtils.getExternalTunnelInterfaceName(String.valueOf(dpnId),
+ String interfaceName = elanL2GatewayUtils.getExternalTunnelInterfaceName(String.valueOf(dpnId),
device.getHwvtepNodeId());
if (interfaceName == null) {
continue;
}
- List<Action> listActionInfo = ElanUtils.buildTunnelItmEgressActions(interfaceName,
+ List<Action> listActionInfo = elanUtils.buildTunnelItmEgressActions(interfaceName,
elanInfo.getSegmentationId());
listBucketInfo.add(MDSALUtil.buildBucket(listActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
return listBucketInfo;
}
- public ElanServiceProvider getElanServiceProvider() {
- return elanServiceProvider;
- }
-
- public void setElanServiceProvider(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
- }
-
@Override
protected ElanInterfaceManager getDataTreeChangeListener() {
return this;
import java.math.BigInteger;
import java.util.List;
-
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
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.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.opendaylight.genius.itm.op.rev160406.TunnelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ElanInterfaceStateChangeListener extends AsyncDataTreeChangeListenerBase<Interface,ElanInterfaceStateChangeListener> implements AutoCloseable {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanInterfaceStateChangeListener elanInterfaceStateChangeListener = null;
private static final Logger logger = LoggerFactory.getLogger(ElanInterfaceStateChangeListener.class);
+ private final DataBroker broker;
+ private final ElanInterfaceManager elanInterfaceManager;
+ private final IInterfaceManager interfaceManager;
+ private final ElanUtils elanUtils;
- private ElanInterfaceStateChangeListener(ElanServiceProvider elanServiceProvider) {
+ public ElanInterfaceStateChangeListener(final DataBroker db, final ElanInterfaceManager ifManager,
+ final IInterfaceManager interfaceManager, ElanUtils elanUtils) {
super(Interface.class, ElanInterfaceStateChangeListener.class);
- this.elanServiceProvider = elanServiceProvider;
- registerListener(LogicalDatastoreType.OPERATIONAL,this.elanServiceProvider.getBroker());
-
+ broker = db;
+ elanInterfaceManager = ifManager;
+ this.interfaceManager = interfaceManager;
+ this.elanUtils = elanUtils;
}
- public static ElanInterfaceStateChangeListener getElanInterfaceStateChangeListener(
- ElanServiceProvider elanServiceProvider) {
- if (elanInterfaceStateChangeListener == null)
- synchronized (ElanInterfaceStateChangeListener.class) {
- if (elanInterfaceStateChangeListener == null)
- {
- ElanInterfaceStateChangeListener elanInterfaceStateChangeListener = new ElanInterfaceStateChangeListener(elanServiceProvider);
- return elanInterfaceStateChangeListener;
-
- }
- }
- return elanInterfaceStateChangeListener;
+ public void init() {
+ registerListener(LogicalDatastoreType.OPERATIONAL, broker);
}
@Override
protected void remove(InstanceIdentifier<Interface> identifier, Interface delIf) {
logger.trace("Received interface {} Down event", delIf);
String interfaceName = delIf.getName();
- ElanInterface elanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface elanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (elanInterface == null) {
logger.debug("No Elan Interface is created for the interface:{} ", interfaceName);
return;
interfaceInfo.setInterfaceType(InterfaceInfo.InterfaceType.VLAN_INTERFACE);
interfaceInfo.setInterfaceTag(delIf.getIfIndex());
String elanInstanceName = elanInterface.getElanInstanceName();
- ElanInstance elanInstance = ElanUtils.getElanInstanceByName(elanInstanceName);
+ ElanInstance elanInstance = elanUtils.getElanInstanceByName(elanInstanceName);
DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
InterfaceRemoveWorkerOnElan removeWorker = new InterfaceRemoveWorkerOnElan(elanInstanceName, elanInstance,
- interfaceName, interfaceInfo, true, elanServiceProvider.getElanInterfaceManager());
+ interfaceName, interfaceInfo, true, elanInterfaceManager);
coordinator.enqueueJob(elanInstanceName, removeWorker, ElanConstants.JOB_MAX_RETRIES);
}
if (update.getOperStatus().equals(Interface.OperStatus.Up)) {
InternalTunnel internalTunnel = getTunnelState(interfaceName);
if (internalTunnel != null) {
- elanServiceProvider.getElanInterfaceManager().handleInternalTunnelStateEvent(internalTunnel.getSourceDPN(), internalTunnel.getDestinationDPN());
+ elanInterfaceManager.handleInternalTunnelStateEvent(internalTunnel.getSourceDPN(), internalTunnel.getDestinationDPN());
}
}
}
protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
logger.trace("Received interface {} up event", intrf);
String interfaceName = intrf.getName();
- ElanInterface elanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface elanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (elanInterface == null) {
if (intrf.getType() != null && intrf.getType().equals(Tunnel.class)) {
if (intrf.getOperStatus().equals(Interface.OperStatus.Up)) {
InternalTunnel internalTunnel = getTunnelState(interfaceName);
if (internalTunnel != null) {
- elanServiceProvider.getElanInterfaceManager().handleInternalTunnelStateEvent(internalTunnel.getSourceDPN(),
+ elanInterfaceManager.handleInternalTunnelStateEvent(internalTunnel.getSourceDPN(),
internalTunnel.getDestinationDPN());
}
}
return;
}
InstanceIdentifier<ElanInterface> elanInterfaceId = ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName);
- elanServiceProvider.getElanInterfaceManager().add(elanInterfaceId, elanInterface);
+ elanInterfaceManager.add(elanInterfaceId, elanInterface);
}
@Override
public InternalTunnel getTunnelState(String interfaceName) {
InternalTunnel internalTunnel = null;
- TunnelList tunnelList = ElanUtils.buildInternalTunnel(elanServiceProvider.getBroker());
+ TunnelList tunnelList = elanUtils.buildInternalTunnel(broker);
if (tunnelList != null && tunnelList.getInternalTunnel() != null) {
List<InternalTunnel> internalTunnels = tunnelList.getInternalTunnel();
for (InternalTunnel tunnel : internalTunnels) {
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
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.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ElanInterfaceStateClusteredListener extends
AsyncClusteredDataChangeListenerBase<Interface, ElanInterfaceStateClusteredListener> implements AutoCloseable {
- public ElanServiceProvider getElanServiceProvider() {
- return elanServiceProvider;
- }
- public void setElanServiceProvider(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
- }
-
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanInterfaceStateClusteredListener elanInterfaceStateClusteredListener = null;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
private static final Logger logger = LoggerFactory.getLogger(ElanInterfaceStateClusteredListener.class);
+ private final DataBroker broker;
+ private final ElanInterfaceManager elanInterfaceManager;
+ private final ElanUtils elanUtils;
+ private final EntityOwnershipService entityOwnershipService;
- public ElanInterfaceStateClusteredListener(ElanServiceProvider elanServiceProvider) {
+ public ElanInterfaceStateClusteredListener(DataBroker broker, ElanInterfaceManager elanInterfaceManager,
+ ElanUtils elanUtils, EntityOwnershipService entityOwnershipService) {
super(Interface.class, ElanInterfaceStateClusteredListener.class);
- this.elanServiceProvider = elanServiceProvider;
- registerListener(this.elanServiceProvider.getBroker());
+ this.broker = broker;
+ this.elanInterfaceManager = elanInterfaceManager;
+ this.elanUtils = elanUtils;
+ this.entityOwnershipService = entityOwnershipService;
}
- public static ElanInterfaceStateClusteredListener getElanInterfaceStateClusteredListener(
- ElanServiceProvider elanServiceProvider) {
- if (elanInterfaceStateClusteredListener == null)
- synchronized (ElanInterfaceStateClusteredListener.class) {
- if (elanInterfaceStateClusteredListener == null)
- {
- ElanInterfaceStateClusteredListener elanInterfaceStateClusteredListener = new ElanInterfaceStateClusteredListener(elanServiceProvider);
- return elanInterfaceStateClusteredListener;
- }
- }
- return elanInterfaceStateClusteredListener;
- }
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = elanServiceProvider.getBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), ElanInterfaceStateClusteredListener.this, AsyncDataBroker.DataChangeScope.BASE);
- } catch (final Exception e) {
- logger.error("Elan Interfaces DataChange listener registration fail!", e);
- throw new IllegalStateException("ElanInterface registration Listener failed.", e);
- }
+ public void init() {
+ registerListener(LogicalDatastoreType.OPERATIONAL, broker);
}
@Override
if (intrf.getOperStatus().equals(Interface.OperStatus.Up)) {
final String interfaceName = intrf.getName();
- ElanClusterUtils.runOnlyInLeaderNode(new Runnable() {
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, new Runnable() {
@Override
public void run() {
logger.debug("running external tunnel update job for interface {} added", interfaceName);
}
private void handleExternalTunnelUpdate(String interfaceName, Interface update) {
- ExternalTunnel externalTunnel = ElanUtils.getExternalTunnel(interfaceName, LogicalDatastoreType.CONFIGURATION);
+ ExternalTunnel externalTunnel = elanUtils.getExternalTunnel(interfaceName, LogicalDatastoreType.CONFIGURATION);
if (externalTunnel != null) {
logger.debug("handling external tunnel update event for ext device dst {} src {} ",
externalTunnel.getDestinationDevice(), externalTunnel.getSourceDevice());
- elanServiceProvider.getElanInterfaceManager().handleExternalTunnelStateEvent(externalTunnel, update);
+ elanInterfaceManager.handleExternalTunnelStateEvent(externalTunnel, update);
} else {
logger.trace("External tunnel not found with interfaceName: {}", interfaceName);
}
*/
package org.opendaylight.netvirt.elan.internal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
-import org.opendaylight.genius.mdsalutil.*;
+import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.ActionType;
+import org.opendaylight.genius.mdsalutil.FlowEntity;
+import org.opendaylight.genius.mdsalutil.InstructionInfo;
+import org.opendaylight.genius.mdsalutil.InstructionType;
+import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.mdsalutil.MatchInfo;
+import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-
-public class ElanNodeListener extends AbstractDataChangeListener<Node> {
+public class ElanNodeListener extends AbstractDataChangeListener<Node> implements AutoCloseable {
private static final Logger logger = LoggerFactory.getLogger(ElanNodeListener.class);
- private static volatile ElanNodeListener elanNodeListener = null;
- private ElanServiceProvider elanServiceProvider = null;
+
+ private final DataBroker broker;
+ private final IMdsalApiManager mdsalManager;
+
private ListenerRegistration<DataChangeListener> listenerRegistration;
- public static ElanNodeListener getElanNodeListener(ElanServiceProvider elanServiceProvider) {
- if (elanNodeListener == null)
- synchronized (ElanNodeListener.class) {
- if (elanNodeListener == null)
- {
- ElanNodeListener elanNodeListener = new ElanNodeListener(elanServiceProvider);
- return elanNodeListener;
-
- }
- }
- return elanNodeListener;
- }
- public ElanNodeListener(ElanServiceProvider elanServiceProvider) {
+ public ElanNodeListener(DataBroker dataBroker, IMdsalApiManager mdsalManager) {
super(Node.class);
- this.elanServiceProvider= elanServiceProvider;
- registerListener(this.elanServiceProvider.getBroker());
+ this.broker = dataBroker;
+ this.mdsalManager = mdsalManager;
+ }
+
+ public void init() {
+ registerListener(broker);
}
private void registerListener(final DataBroker db) {
FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, NwConstants.ELAN_SMAC_TABLE, getTableMissFlowRef(NwConstants.ELAN_SMAC_TABLE),
0, "ELAN sMac Table Miss Flow", 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_SMAC,
mkMatches, mkInstructions);
- this.elanServiceProvider.getMdsalManager().installFlow(flowEntity);
+ mdsalManager.installFlow(flowEntity);
}
private void setupTableMissDmacFlow(BigInteger dpId) {
FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, NwConstants.ELAN_DMAC_TABLE, getTableMissFlowRef(NwConstants.ELAN_DMAC_TABLE),
0, "ELAN dMac Table Miss Flow", 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_DMAC,
mkMatches, mkInstructions);
- this.elanServiceProvider.getMdsalManager().installFlow(flowEntity);
+ mdsalManager.installFlow(flowEntity);
}
private String getTableMissFlowRef(long tableId) {
return new StringBuffer().append(tableId).toString();
}
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ }
+ }
}
import java.math.BigInteger;
import java.util.Arrays;
import org.opendaylight.controller.liblldp.NetUtils;
+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.interfacemanager.globals.InterfaceInfo;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NWUtil;
@SuppressWarnings("deprecation")
public class ElanPacketInHandler implements PacketProcessingListener {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanPacketInHandler elanPacketInHandler = null;
private static final Logger logger = LoggerFactory.getLogger(ElanPacketInHandler.class);
- public ElanPacketInHandler(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
- }
-
- public static ElanPacketInHandler getElanPacketInHandler(ElanServiceProvider elanServiceProvider) {
- if (elanPacketInHandler == null) {
- synchronized (ElanPacketInHandler.class) {
- if (elanPacketInHandler == null) {
- ElanPacketInHandler elanPacketInHandler = new ElanPacketInHandler(elanServiceProvider);
- return elanPacketInHandler;
-
- }
- }
- }
- return elanPacketInHandler;
+ private final DataBroker broker;
+ private final IInterfaceManager interfaceManager;
+ private final ElanUtils elanUtils;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+
+ public ElanPacketInHandler(DataBroker dataBroker, final IInterfaceManager interfaceManager, ElanUtils elanUtils,
+ ElanL2GatewayUtils elanL2GatewayUtils) {
+ broker = dataBroker;
+ this.interfaceManager = interfaceManager;
+ this.elanUtils = elanUtils;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
}
@Override
long portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
- Optional<IfIndexInterface> interfaceInfoOp = ElanUtils.getInterfaceInfoByInterfaceTag(portTag);
+ Optional<IfIndexInterface> interfaceInfoOp = elanUtils.getInterfaceInfoByInterfaceTag(portTag);
if (!interfaceInfoOp.isPresent()) {
logger.warn("There is no interface for given portTag {}", portTag);
return;
String interfaceName = interfaceInfoOp.get().getInterfaceName();
logger.debug("Received a packet with srcMac: {} ElanTag: {} PortTag: {} InterfaceName: {}", macAddress,
elanTag, portTag, interfaceName);
- ElanTagName elanTagName = ElanUtils.getElanInfoByElanTag(elanTag);
+ ElanTagName elanTagName = elanUtils.getElanInfoByElanTag(elanTag);
if (elanTagName == null) {
logger.warn("not able to find elanTagName in elan-tag-name-map for elan tag {}", elanTag);
return;
}
String elanName = elanTagName.getName();
- MacEntry macEntry = ElanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
+ MacEntry macEntry = elanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
if (macEntry != null && macEntry.getInterface() == interfaceName) {
BigInteger macTimeStamp = macEntry.getControllerLearnedForwardingEntryTimestamp();
if (System.currentTimeMillis() > macTimeStamp.longValue() + 2000) {
*/
InstanceIdentifier<MacEntry> macEntryId = ElanUtils
.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, macEntryId);
+ ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, macEntryId);
} else {
// Protection time running. Ignore packets for 2 seconds
return;
InstanceIdentifier<MacEntry> macEntryId = ElanUtils
.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
- ElanUtils.delete(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, macEntryId);
+ ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, macEntryId);
tryAndRemoveInvalidMacEntry(elanName, macEntry);
} else {
// New FEs flood their packets on all interfaces. This
.setIsStaticAddress(false).build();
InstanceIdentifier<MacEntry> macEntryId = ElanUtils
.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
- MDSALUtil.syncWrite(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, macEntryId,
+ MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, macEntryId,
macEntry);
InstanceIdentifier<MacEntry> elanMacEntryId = ElanUtils.getMacEntryOperationalDataPath(elanName,
physAddress);
- MDSALUtil.syncWrite(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, elanMacEntryId,
+ MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, elanMacEntryId,
macEntry);
- ElanInstance elanInstance = ElanUtils.getElanInstanceByName(elanName);
- WriteTransaction flowWritetx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.setupMacFlows(elanInstance,
- elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName),
+ ElanInstance elanInstance = elanUtils.getElanInstanceByName(elanName);
+ WriteTransaction flowWritetx = broker.newWriteOnlyTransaction();
+ elanUtils.setupMacFlows(elanInstance,
+ interfaceManager.getInterfaceInfo(interfaceName),
elanInstance.getMacTimeout(), macAddress, flowWritetx);
flowWritetx.submit();
- BigInteger dpId = elanServiceProvider.getInterfaceManager().getDpnForInterface(interfaceName);
- ElanL2GatewayUtils.scheduleAddDpnMacInExtDevices(elanInstance.getElanInstanceName(), dpId,
+ BigInteger dpId = interfaceManager.getDpnForInterface(interfaceName);
+ elanL2GatewayUtils.scheduleAddDpnMacInExtDevices(elanInstance.getElanInstanceName(), dpId,
Arrays.asList(physAddress));
} catch (Exception e) {
logger.trace("Failed to decode packet: {}", e);
* Static MAC having been added on a wrong ELAN.
*/
private void tryAndRemoveInvalidMacEntry(String elanName, MacEntry macEntry) {
- ElanInstance elanInfo = ElanUtils.getElanInstanceByName(elanName);
+ ElanInstance elanInfo = elanUtils.getElanInstanceByName(elanName);
if (elanInfo == null) {
logger.warn(String.format("MAC %s is been added (either statically or dynamically) for an invalid Elan %s. "
+ "Manual cleanup may be necessary", macEntry.getMacAddress(), elanName));
return;
}
- InterfaceInfo oldInterfaceLport = elanServiceProvider.getInterfaceManager()
- .getInterfaceInfo(macEntry.getInterface());
+ InterfaceInfo oldInterfaceLport = interfaceManager.getInterfaceInfo(macEntry.getInterface());
if (oldInterfaceLport == null) {
logger.warn(
String.format(
macEntry.getMacAddress(), macEntry.getInterface()));
return;
}
- WriteTransaction flowDeletetx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.deleteMacFlows(elanInfo, oldInterfaceLport, macEntry, flowDeletetx);
+ WriteTransaction flowDeletetx = broker.newWriteOnlyTransaction();
+ elanUtils.deleteMacFlows(elanInfo, oldInterfaceLport, macEntry, flowDeletetx);
flowDeletetx.submit();
- ElanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInfo, Arrays.asList(macEntry.getMacAddress()));
+ elanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInfo, Arrays.asList(macEntry.getMacAddress()));
}
}
package org.opendaylight.netvirt.elan.internal;
import com.google.common.base.Optional;
-
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.Future;
import java.util.function.BiFunction;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.interfacemanager.exceptions.InterfaceAlreadyExistsException;
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.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.netvirt.elan.l2gw.internal.ElanL2GatewayProvider;
-import org.opendaylight.netvirt.elan.statisitcs.ElanStatisticsImpl;
import org.opendaylight.netvirt.elan.statusanddiag.ElanStatusMonitor;
-import org.opendaylight.netvirt.elan.utils.CacheElanInstanceListener;
-import org.opendaylight.netvirt.elan.utils.CacheElanInterfaceListener;
-import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanForwardingEntriesHandler;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.Elan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.statistics.rev150824.ElanStatisticsService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class ElanServiceProvider implements BindingAwareProvider, IElanService, AutoCloseable {
-
- private IdManagerService idManager;
- private IMdsalApiManager mdsalManager;
- private IInterfaceManager interfaceManager;
- private OdlInterfaceRpcService interfaceManagerRpcService;
- private ElanInstanceManager elanInstanceManager;
- private ElanForwardingEntriesHandler elanForwardingEntriesHandler;
- private ElanBridgeManager bridgeMgr;
-
- public IdManagerService getIdManager() {
- return idManager;
- }
-
- public ElanForwardingEntriesHandler getElanForwardingEntriesHandler() {
- return elanForwardingEntriesHandler;
- }
-
- public ElanPacketInHandler getElanPacketInHandler() {
- return elanPacketInHandler;
- }
-
- public ElanSmacFlowEventListener getElanSmacFlowEventListener() {
- return elanSmacFlowEventListener;
- }
-
- public ElanInterfaceStateChangeListener getElanInterfaceStateChangeListener() {
- return elanInterfaceStateChangeListener;
- }
-
- public ElanInterfaceStateClusteredListener getInfStateChangeClusteredListener() {
- return infStateChangeClusteredListener;
- }
-
- public ElanDpnInterfaceClusteredListener getElanDpnInterfaceClusteredListener() {
- return elanDpnInterfaceClusteredListener;
- }
-
- public ElanNodeListener getElanNodeListener() {
- return elanNodeListener;
- }
-
- public NotificationService getNotificationService() {
- return notificationService;
- }
-
- public RpcProviderRegistry getRpcProviderRegistry() {
- return rpcProviderRegistry;
- }
-
- public ElanL2GatewayProvider getElanL2GatewayProvider() {
- return elanL2GatewayProvider;
- }
+public class ElanServiceProvider implements IElanService {
- public static ElanStatusMonitor getElanstatusmonitor() {
- return elanStatusMonitor;
- }
-
- public ElanItmEventListener getElanItmEventListener() {
- return elanItmEventListener;
- }
-
- public static Logger getLogger() {
- return logger;
- }
+ private static final Logger logger = LoggerFactory.getLogger(ElanServiceProvider.class);
- private ElanInterfaceManager elanInterfaceManager;
- private ElanPacketInHandler elanPacketInHandler;
- private ElanSmacFlowEventListener elanSmacFlowEventListener;
- private ElanInterfaceStateChangeListener elanInterfaceStateChangeListener;
- private ElanInterfaceStateClusteredListener infStateChangeClusteredListener;
- private ElanDpnInterfaceClusteredListener elanDpnInterfaceClusteredListener;
- private ElanNodeListener elanNodeListener;
- private NotificationService notificationService;
- private RpcProviderRegistry rpcProviderRegistry;
- private IITMProvider itmManager;
- private ItmRpcService itmRpcService;
- private DataBroker broker;
- private ElanL2GatewayProvider elanL2GatewayProvider;
- private ElanStatisticsService interfaceStatsService;
- private EntityOwnershipService entityOwnershipService;
- private CacheElanInstanceListener cacheElanInstanceListener;
- private CacheElanInterfaceListener cacheElanInterfaceListener;
- private static final ElanStatusMonitor elanStatusMonitor = ElanStatusMonitor.getInstance();
- static DataStoreJobCoordinator dataStoreJobCoordinator;
- private ElanOvsdbNodeListener elanOvsdbNodeListener;
+ private final IdManagerService idManager;
+ private final IInterfaceManager interfaceManager;
+ private final ElanInstanceManager elanInstanceManager;
+ private final ElanBridgeManager bridgeMgr;
+ private final DataBroker broker;
+ private final ElanStatusMonitor elanStatusMonitor;
+ private final ElanUtils elanUtils;
private boolean generateIntBridgeMac = true;
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
- dataStoreJobCoordinator = ds;
- }
-
- public void setBroker(DataBroker broker) {
+ public ElanServiceProvider(IdManagerService idManager, IInterfaceManager interfaceManager,
+ ElanInstanceManager elanInstanceManager, ElanBridgeManager bridgeMgr, DataBroker broker,
+ ElanStatusMonitor elanStatusMonitor, ElanUtils elanUtils) {
+ this.idManager = idManager;
+ this.interfaceManager = interfaceManager;
+ this.elanInstanceManager = elanInstanceManager;
+ this.bridgeMgr = bridgeMgr;
this.broker = broker;
+ this.elanStatusMonitor = elanStatusMonitor;
+ this.elanUtils = elanUtils;
}
- public static DataStoreJobCoordinator getDataStoreJobCoordinator() {
- if (dataStoreJobCoordinator == null) {
- dataStoreJobCoordinator = DataStoreJobCoordinator.getInstance();
- }
- return dataStoreJobCoordinator;
- }
-
- public ElanServiceProvider(RpcProviderRegistry rpcRegistry) {
- rpcProviderRegistry = rpcRegistry;
- elanStatusMonitor.registerMbean();
- }
-
- // private ElanInterfaceStateChangeListener elanInterfaceEventListener;
- private ElanItmEventListener elanItmEventListener;
-
- private static final Logger logger = LoggerFactory.getLogger(ElanServiceProvider.class);
-
- @Override
- public void onSessionInitiated(ProviderContext session) {
+ public void init() {
+ logger.info("Starting ElnaServiceProvider");
elanStatusMonitor.reportStatus("STARTING");
try {
createIdPool();
- getDataStoreJobCoordinator();
- broker = session.getSALService(DataBroker.class);
-
- bridgeMgr = new ElanBridgeManager(broker);
- elanOvsdbNodeListener = new ElanOvsdbNodeListener(broker, generateIntBridgeMac, bridgeMgr, this);
- ElanUtils.setElanServiceProvider(this);
- elanForwardingEntriesHandler = ElanForwardingEntriesHandler.getElanForwardingEntriesHandler(this);
- elanInterfaceManager = ElanInterfaceManager.getElanInterfaceManager(this);
- elanInstanceManager = ElanInstanceManager.getElanInstanceManager(this);
- elanNodeListener = ElanNodeListener.getElanNodeListener(this);
- elanPacketInHandler = ElanPacketInHandler.getElanPacketInHandler(this);
- elanSmacFlowEventListener = ElanSmacFlowEventListener.getElanSmacFlowEventListener(this);
- // Initialize statistics rpc provider for elan
- interfaceStatsService = ElanStatisticsImpl.getElanStatisticsService(this);
- rpcProviderRegistry.addRpcImplementation(ElanStatisticsService.class, interfaceStatsService);
- elanInterfaceStateChangeListener = ElanInterfaceStateChangeListener
- .getElanInterfaceStateChangeListener(this);
- infStateChangeClusteredListener = ElanInterfaceStateClusteredListener
- .getElanInterfaceStateClusteredListener(this);
- elanDpnInterfaceClusteredListener = ElanDpnInterfaceClusteredListener
- .getElanDpnInterfaceClusteredListener(this);
- ElanClusterUtils.setElanServiceProvider(this);
- this.elanL2GatewayProvider = new ElanL2GatewayProvider(this);
- cacheElanInstanceListener = new CacheElanInstanceListener(this);
- cacheElanInterfaceListener = new CacheElanInterfaceListener(this);
- elanInterfaceManager.registerListener(LogicalDatastoreType.CONFIGURATION, broker);
- elanInstanceManager.registerListener(LogicalDatastoreType.CONFIGURATION, broker);
- notificationService.registerNotificationListener(elanSmacFlowEventListener);
- notificationService.registerNotificationListener(elanPacketInHandler);
+
elanStatusMonitor.reportStatus("OPERATIONAL");
} catch (Exception e) {
logger.error("Error initializing services", e);
}
}
- public void setIdManager(IdManagerService idManager) {
- this.idManager = idManager;
- }
-
- public void setMdsalManager(IMdsalApiManager mdsalManager) {
- this.mdsalManager = mdsalManager;
- }
-
- public void setInterfaceManager(IInterfaceManager interfaceManager) {
- this.interfaceManager = interfaceManager;
- }
-
- public void setEntityOwnershipService(EntityOwnershipService entityOwnershipService) {
- this.entityOwnershipService = entityOwnershipService;
- }
-
- public IInterfaceManager getInterfaceManager() {
- return this.interfaceManager;
- }
-
- public IMdsalApiManager getMdsalManager() {
- return mdsalManager;
- }
-
- public IITMProvider getItmManager() {
- return itmManager;
- }
-
- public DataBroker getBroker() {
- return broker;
- }
-
- public void setNotificationService(NotificationService notificationService) {
- this.notificationService = notificationService;
- }
-
- public void setInterfaceManagerRpcService(OdlInterfaceRpcService interfaceManager) {
- this.interfaceManagerRpcService = interfaceManager;
- }
-
- public OdlInterfaceRpcService getInterfaceManagerRpcService() {
- return interfaceManagerRpcService;
- }
-
- public void setItmManager(IITMProvider itmManager) {
- this.itmManager = itmManager;
- }
-
- public void setItmRpcService(ItmRpcService itmRpcService) {
- this.itmRpcService = itmRpcService;
- }
-
- public ItmRpcService getItmRpcService() {
- return itmRpcService;
- }
-
- public ElanInstanceManager getElanInstanceManager() {
- return elanInstanceManager;
- }
-
- public ElanInterfaceManager getElanInterfaceManager() {
- return elanInterfaceManager;
- }
-
- public EntityOwnershipService getEntityOwnershipService() {
- return entityOwnershipService;
- }
-
private void createIdPool() {
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(ElanConstants.ELAN_ID_POOL_NAME)
.setLow(ElanConstants.ELAN_ID_LOW_VALUE).setHigh(ElanConstants.ELAN_ID_HIGH_VALUE).build();
@Override
public void updateElanInterface(String elanInstanceName, String interfaceName,
List<String> updatedStaticMacAddresses, String newDescription) {
- ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface existingElanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (existingElanInterface == null) {
return;
}
@Override
public void deleteElanInterface(String elanInstanceName, String interfaceName) {
- ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface existingElanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (existingElanInterface != null) {
ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName));
@Override
public void addStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress) {
- ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface existingElanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
PhysAddress updateStaticMacAddress = new PhysAddress(macAddress);
if (existingElanInterface != null) {
List<PhysAddress> existingMacAddress = existingElanInterface.getStaticMacEntries();
@Override
public void deleteStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress)
throws MacNotFoundException {
- ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface existingElanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
PhysAddress physAddress = new PhysAddress(macAddress);
if (existingElanInterface == null) {
return;
@Override
public Collection<MacEntry> getElanMacTable(String elanInstanceName) {
- Elan elanInfo = ElanUtils.getElanByName(elanInstanceName);
+ Elan elanInfo = elanUtils.getElanByName(elanInstanceName);
List<MacEntry> macAddress = new ArrayList<>();
if (elanInfo == null) {
return macAddress;
List<String> elanInterfaces = elanInfo.getElanInterfaces();
if (elanInterfaces != null && elanInterfaces.size() > 0) {
for (String elanInterface : elanInterfaces) {
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
+ ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null
&& elanInterfaceMac.getMacEntry().size() > 0) {
macAddress.addAll(elanInterfaceMac.getMacEntry());
@Override
public void flushMACTable(String elanInstanceName) {
- Elan elanInfo = ElanUtils.getElanByName(elanInstanceName);
+ Elan elanInfo = elanUtils.getElanByName(elanInstanceName);
if (elanInfo == null) {
return;
}
return;
}
for (String elanInterface : elanInterfaces) {
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
+ ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
for (MacEntry macEntry : macEntries) {
}
- @Override
- public void close() throws Exception {
- this.elanInstanceManager.close();
- this.elanL2GatewayProvider.close();
- this.cacheElanInstanceListener.close();
- this.cacheElanInterfaceListener.close();
- }
-
public static List<PhysAddress> getPhysAddress(List<String> macAddress) {
List<PhysAddress> physAddresses = new ArrayList<>();
for (String mac : macAddress) {
@Override
public ElanInstance getElanInstance(String elanName) {
- return ElanUtils.getElanInstanceByName(elanName);
+ return elanUtils.getElanInstanceByName(elanName);
}
@Override
List<ElanInstance> elanList = new ArrayList<>();
InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
.build();
- Optional<ElanInstances> elansOptional = ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
+ Optional<ElanInstances> elansOptional = elanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
elanInstancesIdentifier);
if (elansOptional.isPresent()) {
elanList.addAll(elansOptional.get().getElanInstance());
List<String> elanInterfaces = new ArrayList<>();
InstanceIdentifier<ElanInterfaces> elanInterfacesIdentifier = InstanceIdentifier.builder(ElanInterfaces.class)
.build();
- Optional<ElanInterfaces> elanInterfacesOptional = ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
+ Optional<ElanInterfaces> elanInterfacesOptional = elanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
elanInterfacesIdentifier);
if (!elanInterfacesOptional.isPresent()) {
return elanInterfaces;
@Override
public String getExternalElanInterface(String elanInstanceName, BigInteger dpnId) {
- DpnInterfaces dpnInterfaces = ElanUtils.getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
+ DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null) {
logger.trace("Elan {} does not have interfaces in DPN {}", elanInstanceName, dpnId);
return null;
}
for (String dpnInterface : dpnInterfaces.getInterfaces()) {
- if (ElanUtils.isExternal(dpnInterface)) {
+ if (elanUtils.isExternal(dpnInterface)) {
return dpnInterface;
}
}
Set<String> externalElanInterfaces = new HashSet<>();
for (String elanInterface : elanInterfaces) {
- if (ElanUtils.isExternal(elanInterface)) {
+ if (elanUtils.isExternal(elanInterface)) {
externalElanInterfaces.add(elanInterface);
}
}
@Override
public boolean isExternalInterface(String interfaceName) {
- return ElanUtils.isExternal(interfaceName);
+ return elanUtils.isExternal(interfaceName);
}
/**
*/
package org.opendaylight.netvirt.elan.internal;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
-
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.mdsalutil.NwConstants;
-import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAdded;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeErrorNotification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeExperimenterErrorNotification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SwitchFlowRemoved;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
@SuppressWarnings("deprecation")
public class ElanSmacFlowEventListener implements SalFlowListener {
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanSmacFlowEventListener elanSmacFlowEventListener = null;
private static final Logger logger = LoggerFactory.getLogger(ElanSmacFlowEventListener.class);
- public ElanSmacFlowEventListener(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
- }
+ private final DataBroker broker;
+ private final IInterfaceManager interfaceManager;
+ private final ElanUtils elanUtils;
- public static ElanSmacFlowEventListener getElanSmacFlowEventListener(ElanServiceProvider elanServiceProvider) {
- if (elanSmacFlowEventListener == null)
- synchronized (ElanPacketInHandler.class) {
- if (elanSmacFlowEventListener == null) {
- elanSmacFlowEventListener = new ElanSmacFlowEventListener(elanServiceProvider);
- }
- }
- return elanSmacFlowEventListener;
+ public ElanSmacFlowEventListener(DataBroker broker, IInterfaceManager interfaceManager, ElanUtils elanUtils) {
+ this.broker = broker;
+ this.interfaceManager = interfaceManager;
+ this.elanUtils = elanUtils;
}
-
- public void setMdSalApiManager(IMdsalApiManager mdsalManager) {
- }
@Override
public void onFlowAdded(FlowAdded arg0) {
// TODO Auto-generated method stub
if (tableId == NwConstants.ELAN_SMAC_TABLE) {
BigInteger metadata = flowRemoved.getMatch().getMetadata().getMetadata();
long elanTag = MetaDataUtil.getElanTagFromMetadata(metadata);
- ElanTagName elanTagInfo = ElanUtils.getElanInfoByElanTag(elanTag);
+ ElanTagName elanTagInfo = elanUtils.getElanInfoByElanTag(elanTag);
if (elanTagInfo == null) {
return;
}
logger.debug(String.format("Flow removed event on SMAC flow entry. But having port Tag as 0 "));
return;
}
- Optional<IfIndexInterface> existingInterfaceInfo = ElanUtils.getInterfaceInfoByInterfaceTag(portTag);
+ Optional<IfIndexInterface> existingInterfaceInfo = elanUtils.getInterfaceInfoByInterfaceTag(portTag);
if (!existingInterfaceInfo.isPresent()) {
logger.debug("Interface is not available for port Tag {}", portTag);
return;
logger.error(String.format("LPort record not found for tag %d", portTag));
return;
}
- MacEntry macEntry = ElanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ MacEntry macEntry = elanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
if (macEntry != null && interfaceInfo != null) {
- WriteTransaction deleteFlowTx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.deleteMacFlows(ElanUtils.getElanInstanceByName(elanTagInfo.getName()), interfaceInfo, macEntry, deleteFlowTx);
+ WriteTransaction deleteFlowTx = broker.newWriteOnlyTransaction();
+ elanUtils.deleteMacFlows(elanUtils.getElanInstanceByName(elanTagInfo.getName()), interfaceInfo, macEntry, deleteFlowTx);
ListenableFuture<Void> result = deleteFlowTx.submit();
addCallBack(result, srcMacAddress);
}
InstanceIdentifier<MacEntry> macEntryIdForElanInterface = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
InstanceIdentifier<MacEntry> macEntryIdForElanInstance = ElanUtils.getMacEntryOperationalDataPath(elanTagInfo.getName(), physAddress);
- WriteTransaction tx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.delete(LogicalDatastoreType.OPERATIONAL, macEntryIdForElanInterface);
tx.delete(LogicalDatastoreType.OPERATIONAL, macEntryIdForElanInstance);
ListenableFuture<Void> writeResult = tx.submit();
+++ /dev/null
-/*
- * 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.netvirt.elan.l2gw.internal;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.clustering.CandidateAlreadyRegisteredException;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepLogicalSwitchListener;
-import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepPhysicalSwitchListener;
-import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepRemoteMcastMacListener;
-import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
-import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
-import org.opendaylight.netvirt.elan.internal.ElanInterfaceManager;
-import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepLocalUcastMacListener;
-import org.opendaylight.netvirt.elan.l2gw.listeners.L2GatewayConnectionListener;
-import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
-import org.opendaylight.netvirt.elan.internal.ElanInstanceManager;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
-import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepTerminationPointListener;
-import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
-import org.opendaylight.genius.utils.clustering.EntityOwnerUtils;
-import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Elan L2 Gateway provider class.
- */
-public class ElanL2GatewayProvider implements AutoCloseable {
-
- private static final Logger LOG = LoggerFactory.getLogger(ElanL2GatewayProvider.class);
-
- private DataBroker broker;
- private EntityOwnershipService entityOwnershipService;
- private ItmRpcService itmRpcService;
- private ElanInstanceManager elanInstanceManager;
- private ElanInterfaceManager elanInterfaceManager;
-
- private L2GatewayConnectionListener l2GwConnListener;
- private HwvtepPhysicalSwitchListener hwvtepPhySwitchListener;
- private HwvtepLocalUcastMacListener torMacsListener;
- private HwvtepTerminationPointListener physicalLocatorListener;
-
- static DataStoreJobCoordinator dataStoreJobCoordinator;
-
- /**
- * Instantiates a new elan l2 gateway provider.
- *
- * @param elanServiceProvider
- * the elan service provider
- */
- public ElanL2GatewayProvider(ElanServiceProvider elanServiceProvider) {
- this.broker = elanServiceProvider.getBroker();
- this.entityOwnershipService = elanServiceProvider.getEntityOwnershipService();
- this.itmRpcService = elanServiceProvider.getItmRpcService();
- this.elanInstanceManager = elanServiceProvider.getElanInstanceManager();
- this.elanInterfaceManager = elanServiceProvider.getElanInterfaceManager();
- dataStoreJobCoordinator = elanServiceProvider.getDataStoreJobCoordinator();
- init();
-
- LOG.info("ElanL2GatewayProvider Initialized");
- }
-
- /**
- * Initialize Elan L2 Gateway.
- */
- private void init() {
- ElanL2GwCacheUtils.createElanL2GwDeviceCache();
- ElanL2GatewayUtils.setDataBroker(broker);
- ElanL2GatewayUtils.setItmRpcService(itmRpcService);
- ElanL2GatewayUtils.setDataStoreJobCoordinator(dataStoreJobCoordinator);
-
- ElanL2GatewayMulticastUtils.setBroker(broker);
- ElanL2GatewayMulticastUtils.setElanInstanceManager(elanInstanceManager);
- ElanL2GatewayMulticastUtils.setElanInterfaceManager(elanInterfaceManager);
- ElanL2GatewayMulticastUtils.setDataStoreJobCoordinator(dataStoreJobCoordinator);
-
- L2GatewayConnectionUtils.setElanInstanceManager(elanInstanceManager);
- L2GatewayConnectionUtils.setBroker(broker);
- L2GatewayConnectionUtils.setDataStoreJobCoordinator(dataStoreJobCoordinator);
-
- HwvtepRemoteMcastMacListener.setDataStoreJobCoordinator(dataStoreJobCoordinator);
- HwvtepLogicalSwitchListener.setDataStoreJobCoordinator(dataStoreJobCoordinator);
-
- this.torMacsListener = new HwvtepLocalUcastMacListener(broker);
- this.l2GwConnListener = new L2GatewayConnectionListener(broker, elanInstanceManager);
- this.hwvtepPhySwitchListener = new HwvtepPhysicalSwitchListener(broker, itmRpcService);
- this.hwvtepPhySwitchListener.registerListener(LogicalDatastoreType.OPERATIONAL, broker);
-
- physicalLocatorListener = new HwvtepTerminationPointListener(broker);
- try {
- EntityOwnerUtils.registerEntityCandidateForOwnerShip(entityOwnershipService,
- HwvtepSouthboundConstants.ELAN_ENTITY_TYPE, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
- null/*listener*/);
- } catch (CandidateAlreadyRegisteredException e) {
- LOG.error("failed to register the entity");
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @see java.lang.AutoCloseable#close()
- */
- @Override
- public void close() throws Exception {
- this.torMacsListener.close();
- this.l2GwConnListener.close();
- this.hwvtepPhySwitchListener.close();
- LOG.info("ElanL2GatewayProvider Closed");
- }
-}
import java.util.concurrent.Callable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
+import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
* Created by ekvsver on 4/15/2016.
*/
public class AssociateHwvtepToElanJob implements Callable<List<ListenableFuture<Void>>> {
- DataBroker broker;
- L2GatewayDevice l2GatewayDevice;
- ElanInstance elanInstance;
- Devices l2Device;
- Integer defaultVlan;
- boolean createLogicalSwitch;
private static final Logger LOG = LoggerFactory.getLogger(AssociateHwvtepToElanJob.class);
- public AssociateHwvtepToElanJob(DataBroker broker, L2GatewayDevice l2GatewayDevice, ElanInstance elanInstance,
- Devices l2Device, Integer defaultVlan, boolean createLogicalSwitch) {
+ private final DataBroker broker;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanUtils elanUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+ private final L2GatewayDevice l2GatewayDevice;
+ private final ElanInstance elanInstance;
+ private final Devices l2Device;
+ private final Integer defaultVlan;
+ private final boolean createLogicalSwitch;
+
+ public AssociateHwvtepToElanJob(DataBroker broker, ElanL2GatewayUtils elanL2GatewayUtils, ElanUtils elanUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils,
+ L2GatewayDevice l2GatewayDevice, ElanInstance elanInstance, Devices l2Device,
+ Integer defaultVlan, boolean createLogicalSwitch) {
this.broker = broker;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanUtils = elanUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.l2GatewayDevice = l2GatewayDevice;
this.elanInstance = elanInstance;
this.l2Device = l2Device;
String logicalSwitchName = ElanL2GatewayUtils.getLogicalSwitchFromElan(elanInstanceName);
LOG.info("{} is already created in {}; adding remaining configurations", logicalSwitchName, hwvtepNodeId);
- LogicalSwitchAddedJob logicalSwitchAddedJob = new LogicalSwitchAddedJob(logicalSwitchName, l2Device,
- l2GatewayDevice, defaultVlan);
+ LogicalSwitchAddedJob logicalSwitchAddedJob =
+ new LogicalSwitchAddedJob(broker, elanL2GatewayUtils, elanUtils, elanL2GatewayMulticastUtils,
+ logicalSwitchName, l2Device,
+ l2GatewayDevice, defaultVlan);
return logicalSwitchAddedJob.call();
}
* Created by ekvsver on 4/15/2016.
*/
public class DisAssociateHwvtepFromElanJob implements Callable<List<ListenableFuture<Void>>> {
- DataBroker broker;
- L2GatewayDevice l2GatewayDevice;
- ElanInstance elanInstance;
- Devices l2Device;
- Integer defaultVlan;
- boolean isLastL2GwConnDeleted;
-
private static final Logger LOG = LoggerFactory.getLogger(DisAssociateHwvtepFromElanJob.class);
- public DisAssociateHwvtepFromElanJob(DataBroker broker, L2GatewayDevice l2GatewayDevice, ElanInstance elanInstance,
+ private final DataBroker broker;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+ private final L2GatewayDevice l2GatewayDevice;
+ private final ElanInstance elanInstance;
+ private final Devices l2Device;
+ private final Integer defaultVlan;
+ private final boolean isLastL2GwConnDeleted;
+
+ public DisAssociateHwvtepFromElanJob(DataBroker broker, ElanL2GatewayUtils elanL2GatewayUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils,
+ L2GatewayDevice l2GatewayDevice, ElanInstance elanInstance,
Devices l2Device, Integer defaultVlan, boolean isLastL2GwConnDeleted) {
this.broker = broker;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.l2GatewayDevice = l2GatewayDevice;
this.elanInstance = elanInstance;
this.l2Device = l2Device;
// Once all above configurations are deleted, delete logical
// switch
LOG.info("delete vlan bindings for {} {}", elanName, strHwvtepNodeId);
- futures.add(ElanL2GatewayUtils.deleteVlanBindingsFromL2GatewayDevice(hwvtepNodeId, l2Device, defaultVlan));
+ futures.add(elanL2GatewayUtils.deleteVlanBindingsFromL2GatewayDevice(hwvtepNodeId, l2Device, defaultVlan));
if (isLastL2GwConnDeleted) {
LOG.info("delete remote ucast macs {} {}", elanName, strHwvtepNodeId);
- futures.add(ElanL2GatewayUtils.deleteElanMacsFromL2GatewayDevice(l2GatewayDevice, elanName));
+ futures.add(elanL2GatewayUtils.deleteElanMacsFromL2GatewayDevice(l2GatewayDevice, elanName));
LOG.info("delete mcast mac for {} {}", elanName, strHwvtepNodeId);
- futures.addAll(ElanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceDelete(elanInstance,
+ futures.addAll(elanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceDelete(elanInstance,
l2GatewayDevice));
LOG.info("delete local ucast macs {} {}", elanName, strHwvtepNodeId);
- futures.addAll(ElanL2GatewayUtils.deleteL2GwDeviceUcastLocalMacsFromElan(l2GatewayDevice, elanName));
+ futures.addAll(elanL2GatewayUtils.deleteL2GwDeviceUcastLocalMacsFromElan(l2GatewayDevice, elanName));
LOG.info("scheduled delete logical switch {} {}", elanName, strHwvtepNodeId);
- ElanL2GatewayUtils.scheduleDeleteLogicalSwitch(hwvtepNodeId,
+ elanL2GatewayUtils.scheduleDeleteLogicalSwitch(hwvtepNodeId,
ElanL2GatewayUtils.getLogicalSwitchFromElan(elanName));
}
public class HwvtepDeviceMcastMacUpdateJob implements Callable<List<ListenableFuture<Void>>> {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepDeviceMcastMacUpdateJob.class);
- String elanName;
- L2GatewayDevice l2GatewayDevice;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+ private final String elanName;
+ private final L2GatewayDevice l2GatewayDevice;
- public HwvtepDeviceMcastMacUpdateJob(String elanName, L2GatewayDevice l2GatewayDevice) {
+ public HwvtepDeviceMcastMacUpdateJob(ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils, String elanName,
+ L2GatewayDevice l2GatewayDevice) {
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.l2GatewayDevice = l2GatewayDevice;
this.elanName = elanName;
}
LOG.info("running update mcast mac entry job for {} {}",
elanName, l2GatewayDevice.getHwvtepNodeId());
return Lists.newArrayList(
- ElanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevice(elanName, l2GatewayDevice));
+ elanL2GatewayMulticastUtils.updateRemoteMcastMacOnElanL2GwDevice(elanName, l2GatewayDevice));
}
}
import java.util.List;
import java.util.concurrent.Callable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepRemoteMcastMacListener;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
-import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
+import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchAddedJob.class);
- public LogicalSwitchAddedJob(String logicalSwitchName, Devices physicalDevice, L2GatewayDevice l2GatewayDevice,
+ private final DataBroker broker;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanUtils elanUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+
+ public LogicalSwitchAddedJob(DataBroker dataBroker, ElanL2GatewayUtils elanL2GatewayUtils, ElanUtils elanUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils, String logicalSwitchName,
+ Devices physicalDevice, L2GatewayDevice l2GatewayDevice,
Integer defaultVlanId) {
+ this.broker = dataBroker;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanUtils = elanUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.logicalSwitchName = logicalSwitchName;
this.physicalDevice = physicalDevice;
this.elanL2GwDevice = l2GatewayDevice;
String elan = ElanL2GatewayUtils.getElanFromLogicalSwitch(logicalSwitchName);
LOG.info("creating vlan bindings for {} {}", logicalSwitchName, elanL2GwDevice.getHwvtepNodeId());
- futures.add(ElanL2GatewayUtils.updateVlanBindingsInL2GatewayDevice(
+ futures.add(elanL2GatewayUtils.updateVlanBindingsInL2GatewayDevice(
new NodeId(elanL2GwDevice.getHwvtepNodeId()), logicalSwitchName, physicalDevice, defaultVlanId));
LOG.info("creating mast mac entries for {} {}", logicalSwitchName, elanL2GwDevice.getHwvtepNodeId());
- futures.add(ElanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceAdd(logicalSwitchName, elanL2GwDevice));
+ futures.add(elanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceAdd(logicalSwitchName, elanL2GwDevice));
List<IpAddress> expectedPhyLocatorIps = Lists.newArrayList();
- HwvtepRemoteMcastMacListener list = new HwvtepRemoteMcastMacListener(ElanUtils.getElanServiceProvider().getBroker(),
- logicalSwitchName, elanL2GwDevice, expectedPhyLocatorIps,
+ HwvtepRemoteMcastMacListener list = new HwvtepRemoteMcastMacListener(broker,
+ elanUtils, logicalSwitchName, elanL2GwDevice, expectedPhyLocatorIps,
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() {
LOG.info("adding remote ucast macs for {} {}", logicalSwitchName,
elanL2GwDevice.getHwvtepNodeId());
List<ListenableFuture<Void>> futures = new ArrayList<>();
- futures.add(ElanL2GatewayUtils.installElanMacsInL2GatewayDevice(
+ futures.add(elanL2GatewayUtils.installElanMacsInL2GatewayDevice(
logicalSwitchName, elanL2GwDevice));
return futures;
}
import com.google.common.collect.Lists;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataChangeListenerBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HwvtepLocalUcastMacListener extends
AsyncClusteredDataChangeListenerBase<LocalUcastMacs, HwvtepLocalUcastMacListener> implements AutoCloseable {
- private DataBroker broker;
- private ListenerRegistration<DataChangeListener> lstnerRegistration;
-
private static final Logger logger = LoggerFactory.getLogger(HwvtepLocalUcastMacListener.class);
- public HwvtepLocalUcastMacListener(DataBroker broker) {
+ private final DataBroker broker;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+
+ public HwvtepLocalUcastMacListener(DataBroker broker, ElanL2GatewayUtils elanL2GatewayUtils) {
super(LocalUcastMacs.class, HwvtepLocalUcastMacListener.class);
this.broker = broker;
- registerListener();
- }
-
- protected void registerListener() {
- try {
- lstnerRegistration = this.broker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- HwvtepUtils.getWildCardPathForLocalUcastMacs(), this, DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- logger.error("Hwvtep LocalUcasMacs DataChange listener registration failed !", e);
- throw new IllegalStateException("Hwvtep LocalUcasMacs DataChange listener registration failed .", e);
- }
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
}
- @Override
- public void close() throws Exception {
- if (lstnerRegistration != null) {
- try {
- lstnerRegistration.close();
- } catch (final Exception e) {
- logger.error("Error when cleaning up DataChangeListener.", e);
- }
- lstnerRegistration = null;
- }
+ public void init() {
+ registerListener(LogicalDatastoreType.OPERATIONAL, broker);
}
@Override
logger.trace("LocalUcastMacs {} removed from {}", macAddress, hwvtepNodeId);
- ElanInstance elan = ElanL2GatewayUtils.getElanInstanceForUcastLocalMac(macRemoved);
+ ElanInstance elan = elanL2GatewayUtils.getElanInstanceForUcastLocalMac(macRemoved);
if (elan == null) {
logger.warn("Could not find ELAN for mac {} being deleted", macAddress);
return;
// Remove MAC from cache
elanL2GwDevice.removeUcastLocalMac(macRemoved);
- ElanL2GatewayUtils.unInstallL2GwUcastMacFromElan(elan, elanL2GwDevice,
+ elanL2GatewayUtils.unInstallL2GwUcastMacFromElan(elan, elanL2GwDevice,
Lists.newArrayList(macRemoved.getMacEntryKey()));
}
logger.trace("LocalUcastMacs {} added to {}", macAddress, hwvtepNodeId);
- ElanInstance elan = ElanL2GatewayUtils.getElanInstanceForUcastLocalMac(macAdded);
+ ElanInstance elan = elanL2GatewayUtils.getElanInstanceForUcastLocalMac(macAdded);
if (elan == null) {
logger.warn("Could not find ELAN for mac {} being added", macAddress);
return;
// Cache MAC for furthur processing later
elanL2GwDevice.addUcastLocalMac(macAdded);
- ElanL2GatewayUtils.installL2GwUcastMacInElan(elan, elanL2GwDevice, macAddress, null);
+ elanL2GatewayUtils.installL2GwUcastMacInElan(elan, elanL2GwDevice, macAddress, null);
}
@Override
protected InstanceIdentifier<LocalUcastMacs> getWildCardPath() {
- return InstanceIdentifier.create(LocalUcastMacs.class);
+ return HwvtepUtils.getWildCardPathForLocalUcastMacs();
}
@Override
package org.opendaylight.netvirt.elan.l2gw.listeners;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataChangeListenerBase;
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.netvirt.elan.l2gw.jobs.LogicalSwitchAddedJob;
+import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
+import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
+import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
/** Id of L2 Gateway connection responsible for this logical switch creation */
private Uuid l2GwConnId;
- static DataStoreJobCoordinator dataStoreJobCoordinator;
-
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
- dataStoreJobCoordinator = ds;
- }
+ private final DataBroker broker;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final EntityOwnershipService entityOwnershipService;
+ private final ElanUtils elanUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
/**
* Instantiates a new hardware vtep logical switch listener.
*
- * @param l2GatewayDevice
- * the l2 gateway device
- * @param logicalSwitchName
- * the logical switch name
- * @param physicalDevice
- * the physical device
- * @param defaultVlanId
- * the default vlan id
+ * @param entityOwnershipService the entity ownership service
+ * @param elanUtils the ELAN utilities
+ * @param elanL2GatewayMulticastUtils
+ * @param l2GatewayDevice the l2 gateway device
+ * @param logicalSwitchName the logical switch name
+ * @param physicalDevice the physical device
+ * @param defaultVlanId the default vlan id
* @param l2GwConnId
- * the l2 gateway connection id
*/
- public HwvtepLogicalSwitchListener(L2GatewayDevice l2GatewayDevice, String logicalSwitchName,
- Devices physicalDevice, Integer defaultVlanId, Uuid l2GwConnId) {
+ public HwvtepLogicalSwitchListener(DataBroker dataBroker, ElanL2GatewayUtils elanL2GatewayUtils,
+ EntityOwnershipService entityOwnershipService, ElanUtils elanUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils,
+ L2GatewayDevice l2GatewayDevice,
+ String logicalSwitchName,
+ Devices physicalDevice, Integer defaultVlanId, Uuid l2GwConnId) {
super(LogicalSwitches.class, HwvtepLogicalSwitchListener.class);
+ this.broker = dataBroker;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.entityOwnershipService = entityOwnershipService;
+ this.elanUtils = elanUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.nodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
this.logicalSwitchName = logicalSwitchName;
this.physicalDevice = physicalDevice;
L2GatewayDevice elanDevice = L2GatewayConnectionUtils.addL2DeviceToElanL2GwCache(
logicalSwitchNew.getHwvtepNodeName().getValue(), l2GatewayDevice, l2GwConnId);
- LogicalSwitchAddedJob logicalSwitchAddedWorker = new LogicalSwitchAddedJob(
- logicalSwitchName, physicalDevice, elanDevice, defaultVlanId);
- ElanClusterUtils.runOnlyInLeaderNode(logicalSwitchAddedWorker.getJobKey() ,
+ LogicalSwitchAddedJob logicalSwitchAddedWorker = new LogicalSwitchAddedJob(broker, elanL2GatewayUtils,
+ elanUtils, elanL2GatewayMulticastUtils, logicalSwitchName, physicalDevice, elanDevice, defaultVlanId);
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, logicalSwitchAddedWorker.getJobKey() ,
"create vlan mappings and mcast configurations",
logicalSwitchAddedWorker);
} catch (Exception e) {
package org.opendaylight.netvirt.elan.l2gw.listeners;
-import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.utils.L2GatewayCacheUtils;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.L2gatewayConnections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
/**
private static final Logger LOG = LoggerFactory.getLogger(HwvtepPhysicalSwitchListener.class);
/** The data broker. */
- private DataBroker dataBroker;
+ private final DataBroker dataBroker;
/** The itm rpc service. */
- private ItmRpcService itmRpcService;
+ private final ItmRpcService itmRpcService;
+
+ /** The entity ownership service. */
+ private final EntityOwnershipService entityOwnershipService;
+
+ private final L2GatewayConnectionUtils l2GatewayConnectionUtils;
/**
* Instantiates a new hwvtep physical switch listener.
* @param dataBroker
* the data broker
* @param itmRpcService
- * the itm rpc service
+ * @param entityOwnershipService
+ * @param l2GatewayConnectionUtils
*/
- public HwvtepPhysicalSwitchListener(final DataBroker dataBroker, ItmRpcService itmRpcService) {
+ public HwvtepPhysicalSwitchListener(final DataBroker dataBroker, ItmRpcService itmRpcService,
+ EntityOwnershipService entityOwnershipService,
+ L2GatewayConnectionUtils l2GatewayConnectionUtils) {
super(PhysicalSwitchAugmentation.class, HwvtepPhysicalSwitchListener.class);
this.dataBroker = dataBroker;
this.itmRpcService = itmRpcService;
+ this.entityOwnershipService = entityOwnershipService;
+ this.l2GatewayConnectionUtils = l2GatewayConnectionUtils;
+ }
+
+ public void init() {
+ registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
/*
if (isTunnelIpNewlyConfigured(phySwitchBefore, phySwitchAfter)) {
final L2GatewayDevice l2GwDevice = updateL2GatewayCache(psName, phySwitchAfter);
- ElanClusterUtils.runOnlyInLeaderNode(HwvtepSouthboundConstants.ELAN_ENTITY_NAME,
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_NAME,
"handling Physical Switch add", new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
final L2GatewayDevice l2GwDevice = updateL2GatewayCache(psName, phySwitchAdded);
- ElanClusterUtils.runOnlyInLeaderNode(HwvtepSouthboundConstants.ELAN_ENTITY_NAME, "handling Physical Switch add",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_NAME, "handling Physical Switch add",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
LOG.trace("L2GatewayConnection {} changes executed on physical switch {}",
l2GwConn.getL2gatewayId(), psName);
- L2GatewayConnectionUtils.addL2GatewayConnection(l2GwConn, psName);
+ l2GatewayConnectionUtils.addL2GatewayConnection(l2GwConn, psName);
}
}
// TODO handle deleted l2gw connections while the device is
private List<IpAddress> expectedPhyLocatorIps;
- DataBroker broker;
+ private final DataBroker broker;
+ private final ElanUtils elanUtils;
String logicalSwitchName;
Callable<List<ListenableFuture<Void>>> taskToRun;
- static DataStoreJobCoordinator dataStoreJobCoordinator;
-
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
- dataStoreJobCoordinator = ds;
- }
+ private final DataStoreJobCoordinator dataStoreJobCoordinator = DataStoreJobCoordinator.getInstance();
/**
* Instantiates a new remote mcast mac listener.
*
* @param broker
* the mdsal databroker reference
- * @param logicalSwitchName
+ * @param elanUtils
+ *@param logicalSwitchName
* the logical switch name
* @param l2GatewayDevice
- * the l2 gateway device
+ * the l2 gateway device
* @param expectedPhyLocatorIps
- * the expected phy locator ips
+* the expected phy locator ips
* @param task
- * the task to be run upon data presence
- * @throws Exception
+* the task to be run upon data presence @throws Exception
* the exception
*/
- public HwvtepRemoteMcastMacListener(DataBroker broker, String logicalSwitchName, L2GatewayDevice l2GatewayDevice,
- List<IpAddress> expectedPhyLocatorIps, Callable<List<ListenableFuture<Void>>> task) throws Exception {
+ public HwvtepRemoteMcastMacListener(DataBroker broker, ElanUtils elanUtils, String logicalSwitchName,
+ L2GatewayDevice l2GatewayDevice,
+ List<IpAddress> expectedPhyLocatorIps,
+ Callable<List<ListenableFuture<Void>>> task) throws Exception {
super(RemoteMcastMacs.class, HwvtepRemoteMcastMacListener.class);
+ this.elanUtils = elanUtils;
this.nodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
this.broker = broker;
this.taskToRun = task;
private boolean isDataPresentInOpDs(InstanceIdentifier<RemoteMcastMacs> path) throws Exception {
Optional<RemoteMcastMacs> mac = null;
try {
- mac = ElanUtils.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ mac = elanUtils.read(broker, LogicalDatastoreType.OPERATIONAL, path);
} catch (Throwable e) {
}
if (mac == null || !mac.isPresent()) {
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataChangeListenerBase;
public class HwvtepTerminationPointListener extends
AsyncClusteredDataChangeListenerBase<TerminationPoint, HwvtepTerminationPointListener> implements AutoCloseable {
+ private static final Logger logger = LoggerFactory.getLogger(HwvtepTerminationPointListener.class);
+
private DataBroker broker;
private ListenerRegistration<DataChangeListener> lstnerRegistration;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final EntityOwnershipService entityOwnershipService;
- private static final Logger logger = LoggerFactory.getLogger(HwvtepTerminationPointListener.class);
-
- public HwvtepTerminationPointListener(DataBroker broker) {
+ public HwvtepTerminationPointListener(DataBroker broker, ElanL2GatewayUtils elanL2GatewayUtils,
+ EntityOwnershipService entityOwnershipService) {
super(TerminationPoint.class, HwvtepTerminationPointListener.class);
this.broker = broker;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.entityOwnershipService = entityOwnershipService;
registerListener();
logger.debug("created HwvtepTerminationPointListener");
}
add.getAugmentation(HwvtepPhysicalPortAugmentation.class);
if (portAugmentation != null) {
final NodeId nodeId = identifier.firstIdentifierOf(Node.class).firstKeyOf(Node.class).getNodeId();
- ElanClusterUtils.runOnlyInLeaderNode(HwvtepSouthboundConstants.ELAN_ENTITY_NAME,
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_NAME,
"handling Physical Switch add", new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
NodeId hwvtepNodeId = new NodeId(l2GwDevice.getHwvtepNodeId());
List<VlanBindings> vlanBindings = getVlanBindings(l2GwConns, hwvtepNodeId, psName, newPortId);
List<ListenableFuture<Void>> futures = new ArrayList<>();
- futures.add(ElanL2GatewayUtils.updateVlanBindingsInL2GatewayDevice(hwvtepNodeId, psName,
+ futures.add(elanL2GatewayUtils.updateVlanBindingsInL2GatewayDevice(hwvtepNodeId, psName,
newPortId, vlanBindings));
return futures;
}
private ListenerRegistration<DataChangeListener> listenerRegistration;
private final DataBroker broker;
- private ElanInstanceManager elanInstanceManager;
+ private final ElanInstanceManager elanInstanceManager;
+ private final L2GatewayConnectionUtils l2GatewayConnectionUtils;
- public L2GatewayConnectionListener(final DataBroker db, ElanInstanceManager elanInstanceManager) {
+ public L2GatewayConnectionListener(final DataBroker db, ElanInstanceManager elanInstanceManager,
+ L2GatewayConnectionUtils l2GatewayConnectionUtils) {
super(L2gatewayConnection.class, L2GatewayConnectionListener.class);
broker = db;
this.elanInstanceManager = elanInstanceManager;
+ this.l2GatewayConnectionUtils = l2GatewayConnectionUtils;
registerListener(db);
}
// Create logical switch in each of the L2GwDevices part of L2Gw
// Logical switch name is network UUID
// Add L2GwDevices to ELAN
- L2GatewayConnectionUtils.addL2GatewayConnection(input);
+ l2GatewayConnectionUtils.addL2GatewayConnection(input);
}
@Override
LOG.trace("Removing L2gatewayConnection: {}", input);
}
- L2GatewayConnectionUtils.deleteL2GatewayConnection(input);
+ l2GatewayConnectionUtils.deleteL2GatewayConnection(input);
}
@Override
private static final Logger LOG = LoggerFactory.getLogger(ElanL2GatewayMulticastUtils.class);
/** The broker. */
- private static DataBroker broker;
+ private final DataBroker broker;
/** The elan instance manager. */
- private static ElanInstanceManager elanInstanceManager;
+ private final ElanInstanceManager elanInstanceManager;
/** The elan interface manager. */
- private static ElanInterfaceManager elanInterfaceManager;
+ private final ElanInterfaceManager elanInterfaceManager;
- static DataStoreJobCoordinator dataStoreJobCoordinator;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
- dataStoreJobCoordinator = ds;
- }
-
- /**
- * Sets the broker.
- *
- * @param broker
- * the new broker
- */
- public static void setBroker(DataBroker broker) {
- ElanL2GatewayMulticastUtils.broker = broker;
- }
-
- /**
- * Sets the elan instance manager.
- *
- * @param elanMgr
- * the new elan instance manager
- */
- public static void setElanInstanceManager(ElanInstanceManager elanMgr) {
- ElanL2GatewayMulticastUtils.elanInstanceManager = elanMgr;
- }
+ private final ElanUtils elanUtils;
- /**
- * Sets the elan interface manager.
- *
- * @param interfaceMgr
- * the new elan interface manager
- */
- public static void setElanInterfaceManager(ElanInterfaceManager interfaceMgr) {
- elanInterfaceManager = interfaceMgr;
+ public ElanL2GatewayMulticastUtils(DataBroker broker, ElanInstanceManager elanInstanceManager,
+ ElanInterfaceManager elanInterfaceManager, ElanL2GatewayUtils elanL2GatewayUtils,
+ ElanUtils elanUtils) {
+ this.broker = broker;
+ this.elanInstanceManager = elanInstanceManager;
+ this.elanInterfaceManager = elanInterfaceManager;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.elanUtils = elanUtils;
}
/**
* the device
* @return the listenable future
*/
- public static ListenableFuture<Void> handleMcastForElanL2GwDeviceAdd(String elanName, L2GatewayDevice device) {
+ public ListenableFuture<Void> handleMcastForElanL2GwDeviceAdd(String elanName, L2GatewayDevice device) {
return updateMcastMacsForAllElanDevices(elanName, device, true/* updateThisDevice */);
}
* the elan to be updated
* @return the listenable future
*/
- public static ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevices(String elanName) {
+ public ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevices(String elanName) {
SettableFuture<Void> future = SettableFuture.create();
future.set(null);
try {
return future;
}
- public static void scheduleMcastMacUpdateJob(String elanName, L2GatewayDevice device) {
- HwvtepDeviceMcastMacUpdateJob job = new HwvtepDeviceMcastMacUpdateJob(elanName,device);
- dataStoreJobCoordinator.enqueueJob(job.getJobKey(), job);
+ public void scheduleMcastMacUpdateJob(String elanName, L2GatewayDevice device) {
+ HwvtepDeviceMcastMacUpdateJob job = new HwvtepDeviceMcastMacUpdateJob(this, elanName,device);
+ DataStoreJobCoordinator.getInstance().enqueueJob(job.getJobKey(), job);
}
/**
* the device
* @return the listenable future
*/
- public static ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevice(String elanName, L2GatewayDevice device) {
+ public ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevice(String elanName, L2GatewayDevice device) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
prepareRemoteMcastMacUpdateOnDevice(transaction, elanName, device);
return transaction.submit();
}
- public static void prepareRemoteMcastMacUpdateOnDevice(WriteTransaction transaction,String elanName,
+ public void prepareRemoteMcastMacUpdateOnDevice(WriteTransaction transaction,String elanName,
L2GatewayDevice device) {
ConcurrentMap<String, L2GatewayDevice> elanL2gwDevices = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elanName);
- List<DpnInterfaces> dpns = ElanUtils.getInvolvedDpnsInElan(elanName);
+ List<DpnInterfaces> dpns = elanUtils.getInvolvedDpnsInElan(elanName);
List<IpAddress> dpnsTepIps = getAllTepIpsOfDpns(device, dpns);
List<IpAddress> l2GwDevicesTepIps = getAllTepIpsOfL2GwDevices(elanL2gwDevices);
preapareRemoteMcastMacEntry(transaction, elanName, device, dpnsTepIps, l2GwDevicesTepIps);
* the update this device
* @return the listenable future
*/
- public static ListenableFuture<Void> updateMcastMacsForAllElanDevices(String elanName, L2GatewayDevice device,
+ public ListenableFuture<Void> updateMcastMacsForAllElanDevices(String elanName, L2GatewayDevice device,
boolean updateThisDevice) {
SettableFuture<Void> ft = SettableFuture.create();
ElanInstance elanInstance = elanInstanceManager.getElanInstanceByName(elanName);
elanInterfaceManager.updateRemoteBroadcastGroupForAllElanDpns(elanInstance);
- List<DpnInterfaces> dpns = ElanUtils.getInvolvedDpnsInElan(elanName);
+ List<DpnInterfaces> dpns = elanUtils.getInvolvedDpnsInElan(elanName);
ConcurrentMap<String, L2GatewayDevice> devices = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elanName);
* the l2 gw devices tep ips
* @return the write transaction
*/
- private static void preapareRemoteMcastMacEntry(WriteTransaction transaction, String elanName,
+ private void preapareRemoteMcastMacEntry(WriteTransaction transaction, String elanName,
L2GatewayDevice device, List<IpAddress> dpnsTepIps,
List<IpAddress> l2GwDevicesTepIps) {
NodeId nodeId = new NodeId(device.getHwvtepNodeId());
* the dpns
* @return the all tep ips of dpns and devices
*/
- private static List<IpAddress> getAllTepIpsOfDpns(L2GatewayDevice l2GwDevice, List<DpnInterfaces> dpns) {
+ private List<IpAddress> getAllTepIpsOfDpns(L2GatewayDevice l2GwDevice, List<DpnInterfaces> dpns) {
List<IpAddress> tepIps = new ArrayList<>();
for (DpnInterfaces dpn : dpns) {
- IpAddress internalTunnelIp = ElanL2GatewayUtils.getSourceDpnTepIp(dpn.getDpId(),
+ IpAddress internalTunnelIp = elanL2GatewayUtils.getSourceDpnTepIp(dpn.getDpId(),
new NodeId(l2GwDevice.getHwvtepNodeId()));
if (internalTunnelIp != null) {
tepIps.add(internalTunnelIp);
* the l2 gateway device
* @return the listenable future
*/
- public static List<ListenableFuture<Void>> handleMcastForElanL2GwDeviceDelete(ElanInstance elanInstance,
+ public List<ListenableFuture<Void>> handleMcastForElanL2GwDeviceDelete(ElanInstance elanInstance,
L2GatewayDevice l2GatewayDevice) {
ListenableFuture<Void> updateMcastMacsFuture = updateMcastMacsForAllElanDevices(elanInstance.getElanInstanceName(),
l2GatewayDevice, false/* updateThisDevice */);
* the logical switch name
* @return the listenable future
*/
- private static ListenableFuture<Void> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
+ private ListenableFuture<Void> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
InstanceIdentifier<LogicalSwitches> logicalSwitch = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
RemoteMcastMacsKey remoteMcastMacsKey = new RemoteMcastMacsKey(new HwvtepLogicalSwitchRef(logicalSwitch),
* the elan instance name
* @return the tep ip of designated switch for external tunnel
*/
- public static IpAddress getTepIpOfDesignatedSwitchForExternalTunnel(L2GatewayDevice l2GwDevice,
+ public IpAddress getTepIpOfDesignatedSwitchForExternalTunnel(L2GatewayDevice l2GwDevice,
String elanInstanceName) {
IpAddress tepIp = null;
if (l2GwDevice.getTunnelIp() == null) {
DesignatedSwitchForTunnel desgSwitch = getDesignatedSwitchForExternalTunnel(l2GwDevice.getTunnelIp(),
elanInstanceName);
if (desgSwitch != null) {
- tepIp = ElanL2GatewayUtils.getSourceDpnTepIp(BigInteger.valueOf(desgSwitch.getDpId()),
+ tepIp = elanL2GatewayUtils.getSourceDpnTepIp(BigInteger.valueOf(desgSwitch.getDpId()),
new NodeId(l2GwDevice.getHwvtepNodeId()));
}
return tepIp;
* the elan instance name
* @return the designated switch for external tunnel
*/
- public static DesignatedSwitchForTunnel getDesignatedSwitchForExternalTunnel(IpAddress tunnelIp,
+ public DesignatedSwitchForTunnel getDesignatedSwitchForExternalTunnel(IpAddress tunnelIp,
String elanInstanceName) {
InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier
.builder(DesignatedSwitchesForExternalTunnels.class)
import org.apache.commons.lang3.tuple.Pair;
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.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.interfacemanager.IfmUtil;
*
*/
public class ElanL2GatewayUtils {
- private static DataBroker broker;
- private static ItmRpcService itmRpcService;
- private static DataStoreJobCoordinator dataStoreJobCoordinator;
- private static Timer LogicalSwitchDeleteJobTimer = new Timer();
- private static final int LOGICAL_SWITCH_DELETE_DELAY = 120000;
- private static ConcurrentMap<Pair<NodeId, String>, TimerTask> LogicalSwitchDeletedTasks = new ConcurrentHashMap<>();
-
private static final Logger LOG = LoggerFactory.getLogger(ElanL2GatewayUtils.class);
- /**
- * Sets the data broker.
- *
- * @param dataBroker
- * the new data broker
- */
- public static void setDataBroker(DataBroker dataBroker) {
- broker = dataBroker;
- }
+ private final DataBroker broker;
+ private final ItmRpcService itmRpcService;
+ private final ElanUtils elanUtils;
+ private final EntityOwnershipService entityOwnershipService;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
- /**
- * Sets the itm rpc service.
- *
- * @param itmRpc
- * the new itm rpc service
- */
- public static void setItmRpcService(ItmRpcService itmRpc) {
- itmRpcService = itmRpc;
- }
-
- /**
- * Sets DataStoreJobCoordinator
- *
- * @param dsJobCoordinator
- * the new dataStoreJobCoordinator
- */
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator dsJobCoordinator) {
- dataStoreJobCoordinator = dsJobCoordinator;
+ private final DataStoreJobCoordinator dataStoreJobCoordinator = DataStoreJobCoordinator.getInstance();
+ private static Timer LogicalSwitchDeleteJobTimer = new Timer();
+ private static final int LOGICAL_SWITCH_DELETE_DELAY = 120000;
+ private final ConcurrentMap<Pair<NodeId, String>, TimerTask> logicalSwitchDeletedTasks = new ConcurrentHashMap<>();
+
+ public ElanL2GatewayUtils(DataBroker broker, ItmRpcService itmRpcService, ElanUtils elanUtils,
+ EntityOwnershipService entityOwnershipService,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils) {
+ this.broker = broker;
+ this.itmRpcService = itmRpcService;
+ this.elanUtils = elanUtils;
+ this.entityOwnershipService = entityOwnershipService;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
}
/**
* @param externalNodeId
* the external node id
*/
- public static void installDpnMacsInL2gwDevice(String elanName, Set<String> lstElanInterfaceNames, BigInteger dpnId,
+ public void installDpnMacsInL2gwDevice(String elanName, Set<String> lstElanInterfaceNames, BigInteger dpnId,
NodeId externalNodeId) {
L2GatewayDevice elanL2GwDevice = ElanL2GwCacheUtils.getL2GatewayDeviceFromCache(elanName,
externalNodeId.getValue());
scheduleAddDpnMacsInExtDevice(elanName, dpnId, staticMacs, elanL2GwDevice);
return;
}
- ElanL2GatewayMulticastUtils.scheduleMcastMacUpdateJob(elanName, elanL2GwDevice);
+ elanL2GatewayMulticastUtils.scheduleMcastMacUpdateJob(elanName, elanL2GwDevice);
scheduleAddDpnMacsInExtDevice(elanName, dpnId, staticMacs, elanL2GwDevice);
}
* the lst elan interface names
* @return the list
*/
- private
static List<PhysAddress> getElanDpnMacsFromInterfaces(Set<String> lstElanInterfaceNames) {
+ private List<PhysAddress> getElanDpnMacsFromInterfaces(Set<String> lstElanInterfaceNames) {
List<PhysAddress> result = new ArrayList<>();
for (String interfaceName : lstElanInterfaceNames) {
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
+ ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
for (MacEntry macEntry : elanInterfaceMac.getMacEntry()) {
result.add(macEntry.getMacAddress());
* the datastore type
* @return the remote mcast mac
*/
- public static RemoteMcastMacs readRemoteMcastMac(NodeId nodeId, String logicalSwitchName,
+ public RemoteMcastMacs readRemoteMcastMac(NodeId nodeId, String logicalSwitchName,
LogicalDatastoreType datastoreType) {
InstanceIdentifier<LogicalSwitches> logicalSwitch = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
* @param macAddresses
* the mac addresses
*/
- public
static void removeMacsFromElanExternalDevices(ElanInstance elanInstance, List<PhysAddress> macAddresses) {
+ public void removeMacsFromElanExternalDevices(ElanInstance elanInstance, List<PhysAddress> macAddresses) {
ConcurrentMap<String, L2GatewayDevice> elanL2GwDevices = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elanInstance.getElanInstanceName());
for (L2GatewayDevice l2GatewayDevice : elanL2GwDevices.values()) {
* the mac addresses
* @return the listenable future
*/
- private static ListenableFuture<Void> removeRemoteUcastMacsFromExternalDevice(String deviceNodeId,
+ private ListenableFuture<Void> removeRemoteUcastMacsFromExternalDevice(String deviceNodeId,
String logicalSwitchName, List<PhysAddress> macAddresses) {
NodeId nodeId = new NodeId(deviceNodeId);
return HwvtepUtils.deleteRemoteUcastMacs(broker, nodeId, logicalSwitchName, lstMac);
}
- public static ElanInstance getElanInstanceForUcastLocalMac(LocalUcastMacs localUcastMac) {
- Optional<LogicalSwitches> lsOpc = ElanUtils.read(broker, LogicalDatastoreType.OPERATIONAL,
+ public ElanInstance getElanInstanceForUcastLocalMac(LocalUcastMacs localUcastMac) {
+ Optional<LogicalSwitches> lsOpc = elanUtils.read(broker, LogicalDatastoreType.OPERATIONAL,
(InstanceIdentifier<LogicalSwitches>) localUcastMac.getLogicalSwitchRef().getValue());
if (lsOpc.isPresent()) {
LogicalSwitches ls = lsOpc.get();
if (ls != null) {
// Logical switch name is Elan name
String elanName = getElanFromLogicalSwitch(ls.getHwvtepNodeName().getValue());
- return ElanUtils.getElanInstanceByName(elanName);
+ return elanUtils.getElanInstanceByName(elanName);
} else {
String macAddress = localUcastMac.getMacEntryKey().getValue();
LOG.error("Could not find logical_switch for {} being added/deleted", macAddress);
* the elan
* @param interfaceName
*/
- public static void installL2gwDeviceMacsInDpn(BigInteger dpnId, NodeId l2gwDeviceNodeId, ElanInstance elan,
+ public void installL2gwDeviceMacsInDpn(BigInteger dpnId, NodeId l2gwDeviceNodeId, ElanInstance elan,
String interfaceName) {
L2GatewayDevice l2gwDevice = ElanL2GwCacheUtils.getL2GatewayDeviceFromCache(elan.getElanInstanceName(),
l2gwDeviceNodeId.getValue());
* the elan
* @param interfaceName
*/
- public static void installDmacFlowsOnDpn(BigInteger dpnId, L2GatewayDevice l2gwDevice, ElanInstance elan,
+ public void installDmacFlowsOnDpn(BigInteger dpnId, L2GatewayDevice l2gwDevice, ElanInstance elan,
String interfaceName) {
String elanName = elan.getElanInstanceName();
if (l2gwDeviceLocalMacs != null && !l2gwDeviceLocalMacs.isEmpty()) {
for (LocalUcastMacs localUcastMac : l2gwDeviceLocalMacs) {
// TODO batch these ops
- ElanUtils.installDmacFlowsToExternalRemoteMac(dpnId, l2gwDevice.getHwvtepNodeId(), elan.getElanTag(),
+ elanUtils.installDmacFlowsToExternalRemoteMac(dpnId, l2gwDevice.getHwvtepNodeId(), elan.getElanTag(),
elan.getSegmentationId(), localUcastMac.getMacEntryKey().getValue(), elanName, interfaceName);
}
LOG.debug("Installing L2gw device [{}] local macs [size: {}] in dpn [{}] for elan [{}]",
* the elan
* @param interfaceName
*/
- public static void installElanL2gwDevicesLocalMacsInDpn(BigInteger dpnId, ElanInstance elan, String interfaceName) {
+ public void installElanL2gwDevicesLocalMacsInDpn(BigInteger dpnId, ElanInstance elan, String interfaceName) {
ConcurrentMap<String, L2GatewayDevice> elanL2GwDevicesFromCache = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elan.getElanInstanceName());
if (elanL2GwDevicesFromCache != null) {
}
}
- public static void installL2GwUcastMacInElan(final ElanInstance elan, final L2GatewayDevice extL2GwDevice,
+ public void installL2GwUcastMacInElan(final ElanInstance elan, final L2GatewayDevice extL2GwDevice,
final String macToBeAdded, String interfaceName) {
final String extDeviceNodeId = extL2GwDevice.getHwvtepNodeId();
final String elanInstanceName = elan.getElanInstanceName();
// DMAC table.
// Looping through all DPNs in order to add/remove mac flows in their
// DMAC table
- final List<DpnInterfaces> elanDpns = ElanUtils.getInvolvedDpnsInElan(elanInstanceName);
+ final List<DpnInterfaces> elanDpns = elanUtils.getInvolvedDpnsInElan(elanInstanceName);
if (elanDpns != null && elanDpns.size() > 0) {
String jobKey = elan.getElanInstanceName() + ":" + macToBeAdded;
- ElanClusterUtils.runOnlyInLeaderNode(jobKey, "install l2gw macs in dmac table",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, jobKey, "install l2gw macs in dmac table",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
if (doesLocalUcastMacExistsInCache(extL2GwDevice, macToBeAdded)) {
for (DpnInterfaces elanDpn : elanDpns) {
// TODO batch the below call
- fts.addAll(ElanUtils.installDmacFlowsToExternalRemoteMac(elanDpn.getDpId(),
+ fts.addAll(elanUtils.installDmacFlowsToExternalRemoteMac(elanDpn.getDpId(),
extDeviceNodeId, elan.getElanTag(), elan.getSegmentationId(), macToBeAdded,
elanInstanceName, interfaceName));
}
macList.add(new PhysAddress(macToBeAdded));
String jobKey = "hwvtep:" + elan.getElanInstanceName() + ":" + macToBeAdded;
- ElanClusterUtils.runOnlyInLeaderNode(jobKey, "install remote ucast macs in l2gw device",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, jobKey, "install remote ucast macs in l2gw device",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
* @param macAddresses
* the mac addresses
*/
- public static void unInstallL2GwUcastMacFromElan(final ElanInstance elan, final L2GatewayDevice l2GwDevice,
+ public void unInstallL2GwUcastMacFromElan(final ElanInstance elan, final L2GatewayDevice l2GwDevice,
final List<MacAddress> macAddresses) {
if (macAddresses == null || macAddresses.isEmpty()) {
return;
// DMAC table. Looping through all DPNs in order to add/remove mac flows
// in their DMAC table
for (final MacAddress mac : macAddresses) {
- final List<DpnInterfaces> elanDpns = ElanUtils.getInvolvedDpnsInElan(elanName);
+ final List<DpnInterfaces> elanDpns = elanUtils.getInvolvedDpnsInElan(elanName);
if (elanDpns != null && !elanDpns.isEmpty()) {
String jobKey = elanName + ":" + mac.getValue();
- ElanClusterUtils.runOnlyInLeaderNode(jobKey, "delete l2gw macs from dmac table",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, jobKey, "delete l2gw macs from dmac table",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() {
for (DpnInterfaces elanDpn : elanDpns) {
BigInteger dpnId = elanDpn.getDpId();
// never batch deletes
- fts.addAll(ElanUtils.deleteDmacFlowsToExternalMac(elan.getElanTag(), dpnId,
+ fts.addAll(elanUtils.deleteDmacFlowsToExternalMac(elan.getElanTag(), dpnId,
l2GwDevice.getHwvtepNodeId(), mac.getValue()));
}
return fts;
DeleteL2GwDeviceMacsFromElanJob job = new DeleteL2GwDeviceMacsFromElanJob(broker, elanName, l2GwDevice,
macAddresses);
- ElanClusterUtils.runOnlyInLeaderNode(job.getJobKey(), "delete remote ucast macs in l2gw devices", job);
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, job.getJobKey(), "delete remote ucast macs in l2gw devices", job);
}
/**
* @param dpnId
* the dpn id
*/
- public static void deleteElanL2GwDevicesUcastLocalMacsFromDpn(final String elanName, final BigInteger dpnId) {
+ public void deleteElanL2GwDevicesUcastLocalMacsFromDpn(final String elanName, final BigInteger dpnId) {
ConcurrentMap<String, L2GatewayDevice> elanL2GwDevices = ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanName);
if (elanL2GwDevices == null || elanL2GwDevices.isEmpty()) {
LOG.trace("No L2 gateway devices in Elan [{}] cache.", elanName);
return;
}
- final ElanInstance elan = ElanUtils.getElanInstanceByName(elanName);
+ final ElanInstance elan = elanUtils.getElanInstanceByName(elanName);
if (elan == null) {
LOG.error("Could not find Elan by name: {}", elanName);
return;
if (localMacs != null && !localMacs.isEmpty()) {
for (final MacAddress mac : localMacs) {
String jobKey = elanName + ":" + mac.getValue();
- ElanClusterUtils.runOnlyInLeaderNode(jobKey, "delete l2gw macs from dmac table",
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, jobKey, "delete l2gw macs from dmac table",
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() {
List<ListenableFuture<Void>> futures = Lists.newArrayList();
- futures.addAll(ElanUtils.deleteDmacFlowsToExternalMac(elanTag, dpnId,
+ futures.addAll(elanUtils.deleteDmacFlowsToExternalMac(elanTag, dpnId,
l2GwDevice.getHwvtepNodeId(), mac.getValue()));
return futures;
}
* the elan name
* @return the listenable future
*/
- public static ListenableFuture<Void> deleteElanMacsFromL2GatewayDevice(L2GatewayDevice l2GatewayDevice,
+ public ListenableFuture<Void> deleteElanMacsFromL2GatewayDevice(L2GatewayDevice l2GatewayDevice,
String elanName) {
String hwvtepNodeId = l2GatewayDevice.getHwvtepNodeId();
String logicalSwitch = getLogicalSwitchFromElan(elanName);
* the datastore type
* @return the remote ucast macs
*/
- public static List<MacAddress> getRemoteUcastMacs(NodeId hwvtepNodeId, String logicalSwitch,
+ public List<MacAddress> getRemoteUcastMacs(NodeId hwvtepNodeId, String logicalSwitch,
LogicalDatastoreType datastoreType) {
List<MacAddress> lstMacs = Collections.emptyList();
Node hwvtepNode = HwvtepUtils.getHwVtepNode(broker, datastoreType, hwvtepNodeId);
* the l2 gateway device which has to be configured
* @return the listenable future
*/
- public static ListenableFuture<Void> installElanMacsInL2GatewayDevice(String elanName,
+ public ListenableFuture<Void> installElanMacsInL2GatewayDevice(String elanName,
L2GatewayDevice l2GatewayDevice) {
String logicalSwitchName = getLogicalSwitchFromElan(elanName);
NodeId hwVtepNodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
* the logical switch name
* @return the elan mac table entries as remote ucast macs
*/
- public static List<RemoteUcastMacs> getElanMacTableEntriesMacs(String elanName,
+ public List<RemoteUcastMacs> getElanMacTableEntriesMacs(String elanName,
L2GatewayDevice l2GatewayDeviceToBeConfigured, NodeId hwVtepNodeId, String logicalSwitchName) {
List<RemoteUcastMacs> lstRemoteUcastMacs = new ArrayList<>();
- MacTable macTable = ElanUtils.getElanMacTable(elanName);
+ MacTable macTable = elanUtils.getElanMacTable(elanName);
if (macTable == null || macTable.getMacEntry() == null || macTable.getMacEntry().isEmpty()) {
LOG.trace("MacTable is empty for elan: {}", elanName);
return lstRemoteUcastMacs;
}
for (MacEntry macEntry : macTable.getMacEntry()) {
- BigInteger dpnId = ElanUtils.getDpidFromInterface(macEntry.getInterface());
+ BigInteger dpnId = elanUtils.getDpidFromInterface(macEntry.getInterface());
if (dpnId == null) {
LOG.error("DPN ID not found for interface {}", macEntry.getInterface());
continue;
* the dst node
* @return the external tunnel interface name
*/
- public static String getExternalTunnelInterfaceName(String sourceNode, String dstNode) {
+ public String getExternalTunnelInterfaceName(String sourceNode, String dstNode) {
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
String tunnelInterfaceName = null;
try {
* the dst hw vtep node id
* @return the dpn tep ip
*/
- public static IpAddress getSourceDpnTepIp(BigInteger srcDpnId, NodeId dstHwVtepNodeId) {
+ public IpAddress getSourceDpnTepIp(BigInteger srcDpnId, NodeId dstHwVtepNodeId) {
IpAddress dpnTepIp = null;
String tunnelInterfaceName = getExternalTunnelInterfaceName(String.valueOf(srcDpnId),
dstHwVtepNodeId.getValue());
* the default vlan id
* @return the listenable future
*/
- public static ListenableFuture<Void> updateVlanBindingsInL2GatewayDevice(NodeId nodeId, String logicalSwitchName,
+ public ListenableFuture<Void> updateVlanBindingsInL2GatewayDevice(NodeId nodeId, String logicalSwitchName,
Devices hwVtepDevice, Integer defaultVlanId) {
if (hwVtepDevice == null || hwVtepDevice.getInterfaces() == null || hwVtepDevice.getInterfaces().isEmpty()) {
String errMsg = "HwVtepDevice is null or interfaces are empty.";
* the vlan bindings to be configured
* @return the listenable future
*/
- public static ListenableFuture<Void> updateVlanBindingsInL2GatewayDevice(NodeId nodeId, String psName,
+ public ListenableFuture<Void> updateVlanBindingsInL2GatewayDevice(NodeId nodeId, String psName,
String interfaceName, List<VlanBindings> vlanBindings) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
HwvtepUtils.mergeVlanBindings(transaction, nodeId, psName, interfaceName, vlanBindings);
* the default vlan id
* @return the listenable future
*/
- public static ListenableFuture<Void> deleteVlanBindingsFromL2GatewayDevice(NodeId nodeId, Devices hwVtepDevice,
+ public ListenableFuture<Void> deleteVlanBindingsFromL2GatewayDevice(NodeId nodeId, Devices hwVtepDevice,
Integer defaultVlanId) {
if (hwVtepDevice == null || hwVtepDevice.getInterfaces() == null || hwVtepDevice.getInterfaces().isEmpty()) {
String errMsg = "HwVtepDevice is null or interfaces are empty.";
* the elan name
* @return the listenable future
*/
- public static List<ListenableFuture<Void>> deleteL2GwDeviceUcastLocalMacsFromElan(L2GatewayDevice l2GatewayDevice,
+ public List<ListenableFuture<Void>> deleteL2GwDeviceUcastLocalMacsFromElan(L2GatewayDevice l2GatewayDevice,
String elanName) {
LOG.info("Deleting L2GatewayDevice [{}] UcastLocalMacs from elan [{}]", l2GatewayDevice.getHwvtepNodeId(),
elanName);
List<ListenableFuture<Void>> futures = new ArrayList<>();
- ElanInstance elan = ElanUtils.getElanInstanceByName(elanName);
+ ElanInstance elan = elanUtils.getElanInstanceByName(elanName);
if (elan == null) {
LOG.error("Could not find Elan by name: {}", elanName);
return futures;
return MDSALUtil.NODE_PREFIX + MDSALUtil.SEPARATOR + dpnId.toString();
}
- public static void scheduleAddDpnMacInExtDevices(String elanName, BigInteger dpId,
+ public void scheduleAddDpnMacInExtDevices(String elanName, BigInteger dpId,
List<PhysAddress> staticMacAddresses) {
ConcurrentMap<String, L2GatewayDevice> elanDevices = ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanName);
for (final L2GatewayDevice externalDevice : elanDevices.values()) {
}
}
- public static void scheduleAddDpnMacsInExtDevice(final String elanName, BigInteger dpId,
+ public void scheduleAddDpnMacsInExtDevice(final String elanName, BigInteger dpId,
final List<PhysAddress> staticMacAddresses, final L2GatewayDevice externalDevice) {
NodeId nodeId = new NodeId(externalDevice.getHwvtepNodeId());
- final IpAddress dpnTepIp = ElanL2GatewayUtils.getSourceDpnTepIp(dpId, nodeId);
+ final IpAddress dpnTepIp = getSourceDpnTepIp(dpId, nodeId);
LOG.trace("Dpn Tep IP: {} for dpnId: {} and nodeId: {}", dpnTepIp, dpId, nodeId);
if (dpnTepIp == null) {
LOG.error("could not install dpn mac in l2gw TEP IP not found for dpnId {} and nodeId {}", dpId, nodeId);
});
}
- public static void scheduleDeleteLogicalSwitch(final NodeId hwvtepNodeId, final String lsName) {
+ public void scheduleDeleteLogicalSwitch(final NodeId hwvtepNodeId, final String lsName) {
TimerTask logicalSwitchDeleteTask = new TimerTask() {
@Override
public void run() {
Pair<NodeId, String> nodeIdLogicalSwitchNamePair = new ImmutablePair<NodeId, String>(hwvtepNodeId,
lsName);
- LogicalSwitchDeletedTasks.remove(nodeIdLogicalSwitchNamePair);
+ logicalSwitchDeletedTasks.remove(nodeIdLogicalSwitchNamePair);
DeleteLogicalSwitchJob deleteLsJob = new DeleteLogicalSwitchJob(broker, hwvtepNodeId, lsName);
- ElanL2GatewayUtils.dataStoreJobCoordinator.enqueueJob(deleteLsJob.getJobKey(), deleteLsJob,
+ dataStoreJobCoordinator.enqueueJob(deleteLsJob.getJobKey(), deleteLsJob,
SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
};
Pair<NodeId, String> nodeIdLogicalSwitchNamePair = new ImmutablePair<>(hwvtepNodeId, lsName);
- LogicalSwitchDeletedTasks.put(nodeIdLogicalSwitchNamePair, logicalSwitchDeleteTask);
+ logicalSwitchDeletedTasks.put(nodeIdLogicalSwitchNamePair, logicalSwitchDeleteTask);
LogicalSwitchDeleteJobTimer.schedule(logicalSwitchDeleteTask, LOGICAL_SWITCH_DELETE_DELAY);
}
- public static void cancelDeleteLogicalSwitch(final NodeId hwvtepNodeId, final String lsName) {
+ public void cancelDeleteLogicalSwitch(final NodeId hwvtepNodeId, final String lsName) {
Pair<NodeId, String> nodeIdLogicalSwitchNamePair = new ImmutablePair<>(hwvtepNodeId, lsName);
- TimerTask logicalSwitchDeleteTask = LogicalSwitchDeletedTasks.get(nodeIdLogicalSwitchNamePair);
+ TimerTask logicalSwitchDeleteTask = logicalSwitchDeletedTasks.get(nodeIdLogicalSwitchNamePair);
if (logicalSwitchDeleteTask != null) {
LOG.debug("Delete logical switch {} action on node {} cancelled", lsName, hwvtepNodeId);
logicalSwitchDeleteTask.cancel();
- LogicalSwitchDeletedTasks.remove(nodeIdLogicalSwitchNamePair);
+ logicalSwitchDeletedTasks.remove(nodeIdLogicalSwitchNamePair);
}
}
}
import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepLogicalSwitchListener;
import org.opendaylight.netvirt.elan.l2gw.jobs.AssociateHwvtepToElanJob;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.utils.L2GatewayCacheUtils;
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
public class L2GatewayConnectionUtils {
private static final Logger LOG = LoggerFactory.getLogger(L2GatewayConnectionUtils.class);
- private static DataBroker broker;
- private static ElanInstanceManager elanInstanceManager;
-
- static DataStoreJobCoordinator dataStoreJobCoordinator;
-
- public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
- dataStoreJobCoordinator = ds;
- }
-
- public static void setBroker(DataBroker broker) {
- L2GatewayConnectionUtils.broker = broker;
- }
-
- public static void setElanInstanceManager(ElanInstanceManager elanInstanceManager) {
- L2GatewayConnectionUtils.elanInstanceManager = elanInstanceManager;
+ private final DataBroker broker;
+ private final ElanInstanceManager elanInstanceManager;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final EntityOwnershipService entityOwnershipService;
+ private final ElanUtils elanUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+
+ public L2GatewayConnectionUtils(DataBroker dataBroker, ElanInstanceManager elanInstanceManager,
+ ElanL2GatewayUtils elanL2GatewayUtils,
+ EntityOwnershipService entityOwnershipService, ElanUtils elanUtils,
+ ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils) {
+ this.broker = dataBroker;
+ this.elanInstanceManager = elanInstanceManager;
+ this.elanL2GatewayUtils = elanL2GatewayUtils;
+ this.entityOwnershipService = entityOwnershipService;
+ this.elanUtils = elanUtils;
+ this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
}
public static boolean isGatewayAssociatedToL2Device(L2GatewayDevice l2GwDevice) {
return l2GwConnections;
}
- public static void addL2GatewayConnection(L2gatewayConnection input) {
+ public void addL2GatewayConnection(L2gatewayConnection input) {
addL2GatewayConnection(input, null/*deviceName*/);
}
- public static void addL2GatewayConnection(L2gatewayConnection input, String l2GwDeviceName) {
+ public void addL2GatewayConnection(L2gatewayConnection input, String l2GwDeviceName) {
LOG.info("Adding L2gateway Connection with ID: {}", input.getKey().getUuid());
Uuid networkUuid = input.getNetworkId();
}
}
- public static void deleteL2GatewayConnection(L2gatewayConnection input) {
+ public void deleteL2GatewayConnection(L2gatewayConnection input) {
LOG.info("Deleting L2gateway Connection with ID: {}", input.getKey().getUuid());
Uuid networkUuid = input.getNetworkId();
}
}
- private static void disAssociateHwvtepsFromElan(ElanInstance elanInstance, L2gateway l2Gateway,
+ private void disAssociateHwvtepsFromElan(ElanInstance elanInstance, L2gateway l2Gateway,
L2gatewayConnection input) {
String elanName = elanInstance.getElanInstanceName();
Integer defaultVlan = input.getSegmentId();
elanL2GwDevice.removeL2GatewayId(l2GwConnId);
}
- DisAssociateHwvtepFromElanJob disAssociateHwvtepToElanJob = new DisAssociateHwvtepFromElanJob(broker,
- elanL2GwDevice, elanInstance, l2Device, defaultVlan, isLastL2GwConnDeleted);
- ElanClusterUtils.runOnlyInLeaderNode(disAssociateHwvtepToElanJob.getJobKey(), "remove l2gw connection job ",
+ DisAssociateHwvtepFromElanJob disAssociateHwvtepToElanJob =
+ new DisAssociateHwvtepFromElanJob(broker, elanL2GatewayUtils, elanL2GatewayMulticastUtils,
+ elanL2GwDevice, elanInstance,
+ l2Device, defaultVlan, isLastL2GwConnDeleted);
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, disAssociateHwvtepToElanJob.getJobKey(), "remove l2gw connection job ",
disAssociateHwvtepToElanJob);
}
}
- private static void associateHwvtepsToElan(ElanInstance elanInstance,
+ private void associateHwvtepsToElan(ElanInstance elanInstance,
L2gateway l2Gateway, L2gatewayConnection input, String l2GwDeviceName) {
String elanName = elanInstance.getElanInstanceName();
Integer defaultVlan = input.getSegmentId();
NodeId hwvtepNodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
// Delete pending delete logical switch task if scheduled
- ElanL2GatewayUtils.cancelDeleteLogicalSwitch(hwvtepNodeId,
+ elanL2GatewayUtils.cancelDeleteLogicalSwitch(hwvtepNodeId,
ElanL2GatewayUtils.getLogicalSwitchFromElan(elanName));
// Add L2 Gateway device to 'ElanL2GwDevice' cache
LogicalSwitches logicalSwitch = HwvtepUtils.getLogicalSwitch(broker, LogicalDatastoreType.OPERATIONAL,
hwvtepNodeId, elanName);
if (logicalSwitch == null) {
- HwvtepLogicalSwitchListener hwVTEPLogicalSwitchListener = new HwvtepLogicalSwitchListener(
- l2GatewayDevice, elanName, l2Device, defaultVlan, l2GwConnId);
+ HwvtepLogicalSwitchListener hwVTEPLogicalSwitchListener =
+ new HwvtepLogicalSwitchListener(broker, elanL2GatewayUtils,
+ entityOwnershipService, elanUtils, elanL2GatewayMulticastUtils, l2GatewayDevice, elanName, l2Device, defaultVlan, l2GwConnId);
hwVTEPLogicalSwitchListener.registerListener(LogicalDatastoreType.OPERATIONAL, broker);
createLogicalSwitch = true;
} else {
addL2DeviceToElanL2GwCache(elanName, l2GatewayDevice, l2GwConnId);
createLogicalSwitch = false;
}
- AssociateHwvtepToElanJob associateHwvtepToElanJob = new AssociateHwvtepToElanJob(broker,
- l2GatewayDevice, elanInstance, l2Device, defaultVlan, createLogicalSwitch);
+ AssociateHwvtepToElanJob associateHwvtepToElanJob =
+ new AssociateHwvtepToElanJob(broker, elanL2GatewayUtils, elanUtils,
+ elanL2GatewayMulticastUtils, l2GatewayDevice, elanInstance, l2Device, defaultVlan, createLogicalSwitch);
- ElanClusterUtils.runOnlyInLeaderNode( associateHwvtepToElanJob.getJobKey() ,
+ ElanClusterUtils.runOnlyInLeaderNode(entityOwnershipService, associateHwvtepToElanJob.getJobKey() ,
"create logical switch in hwvtep topo",
associateHwvtepToElanJob);
package org.opendaylight.netvirt.elan.statisitcs;
import com.google.common.util.concurrent.Futures;
-
+import java.math.BigInteger;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.genius.mdsalutil.NwConstants;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
-import org.opendaylight.netvirt.elan.utils.ElanConstants;
-import org.opendaylight.netvirt.elan.utils.ElanUtils;
-//import org.opendaylight.genius.ericsson.mdsalutil.statistics.StatValue;
-//import org.opendaylight.genius.ericsson.mdsalutil.statistics.StatisticsInfo;
-import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.globals.VlanInterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MatchInfo;
+import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.ServiceIndex;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.genius._interface.service.rev150602._interface.service.info.ServiceInfo;
+import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius._interface.statistics.rev150824.ResultCode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.Future;
-
public class ElanStatisticsImpl implements ElanStatisticsService {
- private ElanServiceProvider elanServiceProvider;
private static final Logger logger = LoggerFactory.getLogger(ElanStatisticsImpl.class);
- private static volatile ElanStatisticsImpl elanStatisticsImpl;
+ private final DataBroker dataBroker;
+ private final IInterfaceManager interfaceManager;
+ private final IMdsalApiManager mdsalMgr;
+ private final ElanUtils elanUtils;
- private ElanStatisticsImpl(ElanServiceProvider elanServiceProvider) {
- super();
- this.elanServiceProvider = elanServiceProvider;
-
-
- }
-
- public static ElanStatisticsImpl getElanStatisticsService(ElanServiceProvider elanServiceProvider) {
- if (elanStatisticsImpl == null)
- synchronized (ElanStatisticsImpl.class) {
- if (elanStatisticsImpl == null) {
- elanStatisticsImpl = new ElanStatisticsImpl(elanServiceProvider);
- }
- }
- return elanStatisticsImpl;
+ public ElanStatisticsImpl(DataBroker dataBroker, IInterfaceManager interfaceManager, IMdsalApiManager mdsalMgr,
+ ElanUtils elanUtils) {
+ this.dataBroker = dataBroker;
+ this.interfaceManager = interfaceManager;
+ this.mdsalMgr = mdsalMgr;
+ this.elanUtils = elanUtils;
}
@Override
rpcResultBuilder = RpcResultBuilder.failed();
return getFutureWithAppErrorMessage(rpcResultBuilder, "Interface name is not provided");
}
- ElanInterface elanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
+ ElanInterface elanInterface = elanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
if (elanInterface == null) {
rpcResultBuilder = RpcResultBuilder.failed();
return getFutureWithAppErrorMessage(rpcResultBuilder, String.format("Interface %s is not a ELAN interface", interfaceName));
}
String elanInstanceName = elanInterface.getElanInstanceName();
- ElanInstance elanInfo = ElanUtils.getElanInstanceByName(elanInstanceName);
+ ElanInstance elanInfo = elanUtils.getElanInstanceByName(elanInstanceName);
long elanTag = elanInfo.getElanTag();
- InterfaceInfo interfaceInfo = elanServiceProvider.getInterfaceManager().getInterfaceInfo(interfaceName);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
ServicesInfo serviceInfo = ElanUtils.getServiceInfo(elanInstanceName, elanTag, interfaceName);
//FIXME [ELANBE] Get this API Later
short tableId = 0;
if (tableId == NwConstants.VLAN_INTERFACE_INGRESS_TABLE) {
VlanInterfaceInfo vlanInterfaceInfo = (VlanInterfaceInfo)interfaceInfo;
matches = InterfaceServiceUtil.getMatchInfoForVlanLPort(dpId, interfaceInfo.getPortNo(),
- InterfaceServiceUtil.getVlanId(interfaceName, elanServiceProvider.getBroker()), vlanInterfaceInfo.isVlanTransparent());
+ InterfaceServiceUtil.getVlanId(interfaceName, dataBroker), vlanInterfaceInfo.isVlanTransparent());
} else {
matches = InterfaceServiceUtil.getLPortDispatcherMatches(ServiceIndex.getIndex(NwConstants.ELAN_SERVICE_NAME, NwConstants.ELAN_SERVICE_INDEX),
interfaceInfo.getInterfaceTag());
public class ElanStatusMonitor implements ElanStatusMonitorMBean{
private String serviceStatus;
- private static ElanStatusMonitor elanStatusMonitor = new ElanStatusMonitor();
private static final String JMX_ELAN_OBJ_NAME = "com.ericsson.sdncp.services.status:type=SvcElanService";
private static final Logger log = LoggerFactory.getLogger(ElanStatusMonitor.class);
- private ElanStatusMonitor () {
+ public void init() {
+ registerMbean();
}
public void registerMbean() {
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
try {
ObjectName objName = new ObjectName(JMX_ELAN_OBJ_NAME);
- mbs.registerMBean(elanStatusMonitor, objName);
+ mbs.registerMBean(this, objName);
log.info("MXBean registration SUCCESSFUL!!! {}", JMX_ELAN_OBJ_NAME);
} catch (InstanceAlreadyExistsException iaeEx) {
log.error("MXBean registration FAILED with InstanceAlreadyExistsException", iaeEx);
}
}
- public static ElanStatusMonitor getInstance() {
- return elanStatusMonitor;
- }
-
@Override
public String acquireServiceStatus() {
return serviceStatus;
import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
public class CacheElanInstanceListener implements ClusteredDataTreeChangeListener<ElanInstance> {
- private ElanServiceProvider elanServiceProvider;
- private ListenerRegistration<CacheElanInstanceListener> registration;
private static final Logger logger = LoggerFactory.getLogger(CacheElanInstanceListener.class);
- public CacheElanInstanceListener(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
+ private final DataBroker broker;
+
+ private ListenerRegistration<CacheElanInstanceListener> registration;
+
+ public CacheElanInstanceListener(DataBroker dataBroker) {
+ this.broker = dataBroker;
+ }
+
+ public void init() {
registerListener();
}
new DataTreeIdentifier<ElanInstance>(LogicalDatastoreType.CONFIGURATION, getWildcardPath());
try {
logger.trace("Registering on path: {}", treeId);
- registration = elanServiceProvider.getBroker().registerDataTreeChangeListener(treeId, CacheElanInstanceListener.this);
+ registration = broker.registerDataTreeChangeListener(treeId, CacheElanInstanceListener.this);
} catch (final Exception e) {
logger.warn("CacheInterfaceConfigListener registration failed", e);
}
}
+
protected InstanceIdentifier<ElanInstance> getWildcardPath() {
return InstanceIdentifier.create(ElanInstances.class).child(ElanInstance.class);
}
import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
public class CacheElanInterfaceListener implements ClusteredDataTreeChangeListener<ElanInterface> {
- private ElanServiceProvider elanServiceProvider;
private ListenerRegistration<CacheElanInterfaceListener> registration;
private static final Logger logger = LoggerFactory.getLogger(CacheElanInterfaceListener.class);
+ private final DataBroker broker;
- public CacheElanInterfaceListener(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
+ public CacheElanInterfaceListener(DataBroker dataBroker) {
+ this.broker = dataBroker;
+ }
+
+ public void init() {
registerListener();
}
new DataTreeIdentifier<ElanInterface>(LogicalDatastoreType.CONFIGURATION, getWildcardPath());
try {
logger.trace("Registering on path: {}", treeId);
- registration = elanServiceProvider.getBroker().registerDataTreeChangeListener(treeId, CacheElanInterfaceListener.this);
+ registration = broker.registerDataTreeChangeListener(treeId, CacheElanInterfaceListener.this);
} catch (final Exception e) {
logger.warn("CacheInterfaceConfigListener registration failed", e);
}
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.genius.utils.clustering.ClusteringUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ElanClusterUtils {
private static final Logger logger = LoggerFactory.getLogger(ElanClusterUtils.class);
- private static ElanServiceProvider elanServiceProvider = null;
- public static void setElanServiceProvider(ElanServiceProvider elanServiceProvider) {
- ElanClusterUtils.elanServiceProvider = elanServiceProvider;
+ public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, Runnable job) {
+ runOnlyInLeaderNode(entityOwnershipService, job, "");
}
- public static void runOnlyInLeaderNode(Runnable job) {
- runOnlyInLeaderNode(job, "");
- }
-
- public static void runOnlyInLeaderNode(final Runnable job, final String jobDescription) {
+ public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, final Runnable job,
+ final String jobDescription) {
ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- elanServiceProvider.getEntityOwnershipService(), HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
+ entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
@Override
});
}
- public static void runOnlyInLeaderNode(String jobKey, Callable<List<ListenableFuture<Void>>> dataStoreJob) {
- runOnlyInLeaderNode(jobKey, "", dataStoreJob);
+ public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, String jobKey,
+ Callable<List<ListenableFuture<Void>>> dataStoreJob) {
+ runOnlyInLeaderNode(entityOwnershipService, jobKey, "", dataStoreJob);
}
- public static void runOnlyInLeaderNode(final String jobKey, final String jobDescription,
+ public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, final String jobKey,
+ final String jobDescription,
final Callable<List<ListenableFuture<Void>>> dataStoreJob) {
ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- elanServiceProvider.getEntityOwnershipService(), HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
+ entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
@Override
public void onSuccess(Boolean isOwner) {
if (isOwner) {
logger.trace("scheduling job {} ", jobDescription);
- elanServiceProvider.getDataStoreJobCoordinator().enqueueJob(jobKey, dataStoreJob,
+ DataStoreJobCoordinator.getInstance().enqueueJob(jobKey, dataStoreJob,
SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
} else {
logger.trace("job is not run as i m not cluster owner desc :{} ", jobDescription);
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
-import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
-import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntryKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ElanForwardingEntriesHandler {
private static final Logger logger = LoggerFactory.getLogger(ElanForwardingEntriesHandler.class);
- private ElanServiceProvider elanServiceProvider = null;
- private static volatile ElanForwardingEntriesHandler elanForwardingEntriesHandler = null;
- public ElanServiceProvider getElanServiceProvider() {
- return elanServiceProvider;
- }
- public void setElanServiceProvider(ElanServiceProvider elanServiceProvider) {
- this.elanServiceProvider = elanServiceProvider;
- }
+ private final DataBroker broker;
+ private final ElanUtils elanUtils;
- public ElanForwardingEntriesHandler(ElanServiceProvider elanServiceProvider){
- super();
- this.elanServiceProvider = elanServiceProvider;
- }
- public static ElanForwardingEntriesHandler getElanForwardingEntriesHandler(
- ElanServiceProvider elanServiceProvider) {
- if (elanForwardingEntriesHandler == null) {
- synchronized (ElanForwardingEntriesHandler.class) {
- if (elanForwardingEntriesHandler == null) {
- elanForwardingEntriesHandler = new ElanForwardingEntriesHandler(elanServiceProvider);
- }
- }
- }
- return elanForwardingEntriesHandler;
+ public ElanForwardingEntriesHandler(DataBroker dataBroker, ElanUtils elanUtils){
+ this.broker = dataBroker;
+ this.elanUtils = elanUtils;
}
+
public void updateElanInterfaceForwardingTablesList(String elanInstanceName, String interfaceName, String existingInterfaceName, MacEntry mac, WriteTransaction tx) {
if (existingInterfaceName.equals(interfaceName)) {
logger.error(String.format("Static MAC address %s has already been added for the same ElanInstance %s on the same Logical Interface Port %s."
public void deleteElanInterfaceForwardingTablesList(String interfaceName, MacEntry mac, WriteTransaction tx) {
InstanceIdentifier<MacEntry> existingMacEntryId = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, mac.getMacAddress());
- MacEntry existingInterfaceMacEntry = ElanUtils.getInterfaceMacEntriesOperationalDataPathFromId(existingMacEntryId);
+ MacEntry existingInterfaceMacEntry = elanUtils.getInterfaceMacEntriesOperationalDataPathFromId(existingMacEntryId);
if (existingInterfaceMacEntry != null) {
tx.delete(LogicalDatastoreType.OPERATIONAL, existingMacEntryId);
}
public void createElanInterfaceForwardingTablesList(String interfaceName, MacEntry mac, WriteTransaction tx) {
InstanceIdentifier<MacEntry> existingMacEntryId = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, mac.getMacAddress());
- MacEntry existingInterfaceMacEntry = ElanUtils.getInterfaceMacEntriesOperationalDataPathFromId(existingMacEntryId);
+ MacEntry existingInterfaceMacEntry = elanUtils.getInterfaceMacEntriesOperationalDataPathFromId(existingMacEntryId);
if (existingInterfaceMacEntry == null) {
MacEntry macEntry = new MacEntryBuilder().setMacAddress(mac.getMacAddress()).setInterface(interfaceName).setIsStaticAddress(true).setKey(new MacEntryKey(mac.getMacAddress())).build();
tx.put(LogicalDatastoreType.OPERATIONAL, existingMacEntryId, macEntry);
public void updateElanForwardingTablesList(String elanName, String interfaceName, MacEntry mac, WriteTransaction tx) {
InstanceIdentifier<MacEntry> macEntryId = ElanUtils.getMacEntryOperationalDataPath(elanName, mac.getMacAddress());
- MacEntry existingMacEntry = ElanUtils.getMacEntryFromElanMacId(macEntryId);
+ MacEntry existingMacEntry = elanUtils.getMacEntryFromElanMacId(macEntryId);
if (existingMacEntry != null) {
// Fix for TR HU71400.
// ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, macEntryId);
private void createElanForwardingTablesList(String elanName, MacEntry macEntry, WriteTransaction tx) {
InstanceIdentifier<MacEntry> macEntryId = ElanUtils.getMacEntryOperationalDataPath(elanName, macEntry.getMacAddress());
- Optional<MacEntry> existingMacEntry = ElanUtils.read(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, macEntryId);
+ Optional<MacEntry> existingMacEntry = elanUtils.read(broker, LogicalDatastoreType.OPERATIONAL, macEntryId);
if (!existingMacEntry.isPresent()) {
tx.put(LogicalDatastoreType.OPERATIONAL, macEntryId, macEntry);
}
InstanceIdentifier<MacEntry> macEntryId = ElanUtils.getMacEntryOperationalDataPath(elanInfo.getElanInstanceName(), macEntry.getMacAddress());
tx.delete(LogicalDatastoreType.OPERATIONAL, macEntryId);
deleteElanInterfaceForwardingTablesList(interfaceInfo.getInterfaceName(), macEntry, tx);
- WriteTransaction deleteFlowtx = elanServiceProvider.getBroker().newWriteOnlyTransaction();
- ElanUtils.deleteMacFlows(elanInfo, interfaceInfo, macEntry, deleteFlowtx);
+ WriteTransaction deleteFlowtx = broker.newWriteOnlyTransaction();
+ elanUtils.deleteMacFlows(elanInfo, interfaceInfo, macEntry, deleteFlowtx);
deleteFlowtx.submit();
}
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.netvirt.elan.internal.ElanInstanceManager;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
public class ElanUtils {
- private static ElanServiceProvider elanServiceProvider;
private static final Logger LOG = LoggerFactory.getLogger(ElanUtils.class);
+
private static Map<String, ElanInstance> elanInstanceLocalCache = new ConcurrentHashMap<>();
private static Map<String, ElanInterface> elanInterfaceLocalCache = new ConcurrentHashMap<>();
- public static void setElanServiceProvider(ElanServiceProvider serviceProvider) {
- elanServiceProvider = serviceProvider;
- }
-
- public static ElanServiceProvider getElanServiceProvider() {
- return elanServiceProvider;
- }
+ private final DataBroker broker;
+ private final IMdsalApiManager mdsalManager;
+ private final ElanInstanceManager elanInstanceManager;
+ private final OdlInterfaceRpcService interfaceManagerRpcService;
+ private final ItmRpcService itmRpcService;
public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
@Override
LOG.error("Error in Datastore operation", error);
}
};
-
+
+ public ElanUtils(DataBroker dataBroker, IMdsalApiManager mdsalManager, ElanInstanceManager elanInstanceManager,
+ OdlInterfaceRpcService interfaceManagerRpcService, ItmRpcService itmRpcService) {
+ this.broker = dataBroker;
+ this.mdsalManager = mdsalManager;
+ this.elanInstanceManager = elanInstanceManager;
+ this.interfaceManagerRpcService = interfaceManagerRpcService;
+ this.itmRpcService = itmRpcService;
+ }
+
public static void addElanInstanceIntoCache(String elanInstanceName, ElanInstance elanInstance) {
elanInstanceLocalCache.put(elanInstanceName, elanInstance);
Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
}
- public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
+ public <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
ReadOnlyTransaction tx = (broker != null) ? broker.newReadOnlyTransaction()
- : elanServiceProvider.getBroker().newReadOnlyTransaction();
+ : this.broker.newReadOnlyTransaction();
Optional<T> result = Optional.absent();
try {
CheckedFuture<Optional<T>, ReadFailedException> checkedFuture = tx.read(datastoreType, path);
}
// elan-instances config container
- public static ElanInstance getElanInstanceByName(String elanInstanceName) {
+ public ElanInstance getElanInstanceByName(String elanInstanceName) {
ElanInstance elanObj = getElanInstanceFromCache(elanInstanceName);
if (elanObj != null) {
return elanObj;
}
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
- Optional<ElanInstance> elanInstance = read(elanServiceProvider.getBroker(), LogicalDatastoreType.CONFIGURATION,
+ Optional<ElanInstance> elanInstance = read(broker, LogicalDatastoreType.CONFIGURATION,
elanIdentifierId);
if (elanInstance.isPresent()) {
return elanInstance.get();
}
// elan-interfaces Config Container
- public static ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
+ public ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
ElanInterface elanInterfaceObj = getElanInterfaceFromCache(elanInterfaceName);
if (elanInterfaceObj != null) {
return elanInterfaceObj;
}
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- Optional<ElanInterface> existingElanInterface = read(elanServiceProvider.getBroker(),
+ Optional<ElanInterface> existingElanInterface = read(broker,
LogicalDatastoreType.CONFIGURATION, elanInterfaceId);
if (existingElanInterface.isPresent()) {
return existingElanInterface.get();
return null;
}
- public static EtreeInterface getEtreeInterfaceByElanInterfaceName(String elanInterfaceName) {
- ElanInterface elanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(elanInterfaceName);
+ public EtreeInterface getEtreeInterfaceByElanInterfaceName(String elanInterfaceName) {
+ ElanInterface elanInterface = getElanInterfaceByElanInterfaceName(elanInterfaceName);
return elanInterface.getAugmentation(EtreeInterface.class);
}
}
// elan-state Operational container
- public static Elan getElanByName(String elanInstanceName) {
+ public Elan getElanByName(String elanInstanceName) {
InstanceIdentifier<Elan> elanIdentifier = getElanInstanceOperationalDataPath(elanInstanceName);
- Optional<Elan> elanInstance = read(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL,
+ Optional<Elan> elanInstance = read(broker, LogicalDatastoreType.OPERATIONAL,
elanIdentifier);
if (elanInstance.isPresent()) {
return elanInstance.get();
}
// grouping of forwarding-entries
- public static MacEntry getInterfaceMacEntriesOperationalDataPath(String interfaceName, PhysAddress physAddress) {
+ public MacEntry getInterfaceMacEntriesOperationalDataPath(String interfaceName, PhysAddress physAddress) {
InstanceIdentifier<MacEntry> existingMacEntryId = getInterfaceMacEntriesIdentifierOperationalDataPath(
interfaceName, physAddress);
- Optional<MacEntry> existingInterfaceMacEntry = read(elanServiceProvider.getBroker(),
+ Optional<MacEntry> existingInterfaceMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, existingMacEntryId);
if (existingInterfaceMacEntry.isPresent()) {
return existingInterfaceMacEntry.get();
return null;
}
- public static MacEntry getInterfaceMacEntriesOperationalDataPathFromId(InstanceIdentifier identifier) {
- Optional<MacEntry> existingInterfaceMacEntry = read(elanServiceProvider.getBroker(),
+ public MacEntry getInterfaceMacEntriesOperationalDataPathFromId(InstanceIdentifier identifier) {
+ Optional<MacEntry> existingInterfaceMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, identifier);
if (existingInterfaceMacEntry.isPresent()) {
return existingInterfaceMacEntry.get();
}
// elan-forwarding-tables Operational container
- public static MacEntry getMacTableByElanName(String elanName, PhysAddress physAddress) {
+ public MacEntry getMacTableByElanName(String elanName, PhysAddress physAddress) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanName, physAddress);
- Optional<MacEntry> existingElanMacEntry = read(elanServiceProvider.getBroker(),
+ Optional<MacEntry> existingElanMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, macId);
if (existingElanMacEntry.isPresent()) {
return existingElanMacEntry.get();
return null;
}
- public static MacEntry getMacEntryFromElanMacId(InstanceIdentifier identifier) {
- Optional<MacEntry> existingInterfaceMacEntry = read(elanServiceProvider.getBroker(),
+ public MacEntry getMacEntryFromElanMacId(InstanceIdentifier identifier) {
+ Optional<MacEntry> existingInterfaceMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, identifier);
if (existingInterfaceMacEntry.isPresent()) {
return existingInterfaceMacEntry.get();
}
// elan-interface-forwarding-entries Operational container
- public static ElanInterfaceMac getElanInterfaceMacByInterfaceName(String interfaceName) {
+ public ElanInterfaceMac getElanInterfaceMacByInterfaceName(String interfaceName) {
InstanceIdentifier<ElanInterfaceMac> elanInterfaceId = getElanInterfaceMacEntriesOperationalDataPath(
interfaceName);
- Optional<ElanInterfaceMac> existingElanInterface = read(elanServiceProvider.getBroker(),
+ Optional<ElanInterfaceMac> existingElanInterface = read(broker,
LogicalDatastoreType.OPERATIONAL, elanInterfaceId);
if (existingElanInterface.isPresent()) {
return existingElanInterface.get();
* the interface name
* @return the elan interface mac addresses
*/
- public
static List<PhysAddress> getElanInterfaceMacAddresses(String interfaceName) {
+ public List<PhysAddress> getElanInterfaceMacAddresses(String interfaceName) {
List<PhysAddress> macAddresses = new ArrayList<PhysAddress>();
- ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
+ ElanInterfaceMac elanInterfaceMac = getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
for (MacEntry macEntry : macEntries) {
* Id of the DPN where the interfaces are located
* @return the elan interface Info
*/
- public static DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
+ public DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
- Optional<DpnInterfaces> elanDpnInterfaces = read(elanServiceProvider.getBroker(),
+ Optional<DpnInterfaces> elanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId);
if (elanDpnInterfaces.isPresent()) {
return elanDpnInterfaces.get();
}
// elan-tag-name-map Operational Container
- public static ElanTagName getElanInfoByElanTag(long elanTag) {
+ public ElanTagName getElanInfoByElanTag(long elanTag) {
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
- Optional<ElanTagName> existingElanInfo = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanTagName> existingElanInfo = read(broker,
LogicalDatastoreType.OPERATIONAL, elanId);
if (existingElanInfo.isPresent()) {
return existingElanInfo.get();
return null;
}
- public static EtreeLeafTagName getEtreeLeafTagByElanTag(long elanTag) {
+ public EtreeLeafTagName getEtreeLeafTagByElanTag(long elanTag) {
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
- Optional<ElanTagName> existingElanInfo = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanTagName> existingElanInfo = read(broker,
LogicalDatastoreType.OPERATIONAL, elanId);
if (existingElanInfo.isPresent()) {
ElanTagName elanTagName = existingElanInfo.get();
}
// interface-index-tag operational container
- public static Optional<IfIndexInterface> getInterfaceInfoByInterfaceTag(long interfaceTag) {
+ public Optional<IfIndexInterface> getInterfaceInfoByInterfaceTag(long interfaceTag) {
InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
- return ElanUtils.read(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, interfaceId);
+ return read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
}
public static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName)).build();
}
- public static ElanDpnInterfacesList getElanDpnInterfacesList(String elanName) {
+ public ElanDpnInterfacesList getElanDpnInterfacesList(String elanName) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanName);
- Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (existingElanDpnInterfaces.isPresent()) {
return existingElanDpnInterfaces.get();
* the elan instance name
* @return list of dpIds
*/
- public static List<BigInteger> getParticipatingDPNsInElanInstance(String elanInstanceName) {
+ public List<BigInteger> getParticipatingDPNsInElanInstance(String elanInstanceName) {
List<BigInteger> dpIds = new ArrayList<BigInteger>();
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanInstanceName);
- Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (!existingElanDpnInterfaces.isPresent()) {
return dpIds;
* the elan instance name
* @return true if dpId is already present, otherwise return false
*/
- public static boolean isDpnAlreadyPresentInElanInstance(BigInteger dpId, String elanInstanceName) {
+ public boolean isDpnAlreadyPresentInElanInstance(BigInteger dpId, String elanInstanceName) {
boolean isDpIdPresent = false;
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanInstanceName);
- Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (!existingElanDpnInterfaces.isPresent()) {
return isDpIdPresent;
return isDpIdPresent;
}
- public static ElanDpnInterfaces getElanDpnInterfacesList() {
+ public ElanDpnInterfaces getElanDpnInterfacesList() {
InstanceIdentifier<ElanDpnInterfaces> elanDpnInterfaceId = InstanceIdentifier.builder(ElanDpnInterfaces.class)
.build();
- Optional<ElanDpnInterfaces> existingElanDpnInterfaces = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanDpnInterfaces> existingElanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (existingElanDpnInterfaces.isPresent()) {
return existingElanDpnInterfaces.get();
return null;
}
- public static ElanForwardingTables getElanForwardingList() {
+ public ElanForwardingTables getElanForwardingList() {
InstanceIdentifier<ElanForwardingTables> elanForwardingTableId = InstanceIdentifier
.builder(ElanForwardingTables.class).build();
- Optional<ElanForwardingTables> existingElanForwardingList = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<ElanForwardingTables> existingElanForwardingList = read(broker,
LogicalDatastoreType.OPERATIONAL, elanForwardingTableId);
if (existingElanForwardingList.isPresent()) {
return existingElanForwardingList.get();
* the elan name
* @return the elan mac table
*/
- public static MacTable getElanMacTable(String elanName) {
+ public MacTable getElanMacTable(String elanName) {
InstanceIdentifier<MacTable> elanMacTableId = getElanMacTableOperationalDataPath(elanName);
- Optional<MacTable> existingElanMacTable = ElanUtils.read(elanServiceProvider.getBroker(),
+ Optional<MacTable> existingElanMacTable = read(broker,
LogicalDatastoreType.OPERATIONAL, elanMacTableId);
if (existingElanMacTable.isPresent()) {
return existingElanMacTable.get();
* @param writeFlowGroupTx
* the flow group tx
*/
- public static void setupMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
+ public void setupMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
String macAddress, WriteTransaction writeFlowGroupTx) {
synchronized (macAddress) {
LOG.info("Acquired lock for mac : " + macAddress + ". Proceeding with install operation.");
- setupKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress, elanServiceProvider.getMdsalManager(),
+ setupKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress, mdsalManager,
writeFlowGroupTx);
- setupOrigDmacFlows(elanInfo, interfaceInfo, macAddress, elanServiceProvider.getMdsalManager(),
- elanServiceProvider.getBroker(), writeFlowGroupTx);
+ setupOrigDmacFlows(elanInfo, interfaceInfo, macAddress, mdsalManager,
+ broker, writeFlowGroupTx);
}
}
- public static void setupDMacFlowonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo, BigInteger dstDpId,
+ public void setupDMacFlowonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo, BigInteger dstDpId,
String macAddress, WriteTransaction writeFlowTx) {
synchronized (macAddress) {
LOG.info("Acquired lock for mac : " + macAddress + "Proceeding with install operation.");
* @param macAddress
* @param mdsalApiManager
*/
- private static void setupKnownSmacFlow(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
+ private void setupKnownSmacFlow(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
String macAddress, IMdsalApiManager mdsalApiManager, WriteTransaction writeFlowGroupTx) {
FlowEntity flowEntity = buildKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress);
mdsalApiManager.addFlowToTx(flowEntity, writeFlowGroupTx);
}
}
- public static FlowEntity buildKnownSmacFlow(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
+ public FlowEntity buildKnownSmacFlow(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
String macAddress) {
BigInteger dpId = interfaceInfo.getDpId();
int lportTag = interfaceInfo.getInterfaceTag();
// Matching metadata and eth_src fields
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
- ElanUtils.getElanMetadataLabel(elanInfo.getElanTag(), lportTag), ElanUtils.getElanMetadataMask() }));
+ getElanMetadataLabel(elanInfo.getElanTag(), lportTag), getElanMetadataMask() }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_src, new String[] { macAddress }));
List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] { NwConstants.ELAN_DMAC_TABLE }));
return flowEntity;
}
- private static Long getElanTag(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
- EtreeInterface etreeInterface = ElanUtils
- .getEtreeInterfaceByElanInterfaceName(interfaceInfo.getInterfaceName());
+ private Long getElanTag(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
+ EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(interfaceInfo.getInterfaceName());
if (etreeInterface == null || etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
return elanInfo.getElanTag();
} else { // Leaf
* @param writeFlowGroupTx
* the writeFLowGroup tx
*/
- public static void setupTermDmacFlows(InterfaceInfo interfaceInfo, IMdsalApiManager mdsalApiManager,
+ public void setupTermDmacFlows(InterfaceInfo interfaceInfo, IMdsalApiManager mdsalApiManager,
WriteTransaction writeFlowGroupTx) {
BigInteger dpId = interfaceInfo.getDpId();
int lportTag = interfaceInfo.getInterfaceTag();
* external)
* @return the Instruction
*/
- public static List<Instruction> getInstructionsInPortForOutGroup(String ifName) {
+ public List<Instruction> getInstructionsInPortForOutGroup(String ifName) {
List<Instruction> mkInstructions = new ArrayList<Instruction>();
- List<Action> actions = ElanUtils.getEgressActionsForInterface(ifName, /* tunnelKey */ null);
+ List<Action> actions = getEgressActionsForInterface(ifName, /* tunnelKey */ null);
mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
return mkInstructions;
* the tunnel key
* @return the egress actions for interface
*/
- public
static List<Action> getEgressActionsForInterface(String ifName, Long tunnelKey) {
+ public List<Action> getEgressActionsForInterface(String ifName, Long tunnelKey) {
List<Action> listAction = new ArrayList<Action>();
try {
GetEgressActionsForInterfaceInput getEgressActionInput = new GetEgressActionsForInterfaceInputBuilder()
.setIntfName(ifName).setTunnelKey(tunnelKey).build();
- Future<RpcResult<GetEgressActionsForInterfaceOutput>> result = elanServiceProvider
- .getInterfaceManagerRpcService().getEgressActionsForInterface(getEgressActionInput);
+ Future<RpcResult<GetEgressActionsForInterfaceOutput>> result = interfaceManagerRpcService
+ .getEgressActionsForInterface(getEgressActionInput);
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", ifName,
return listAction;
}
- private static void setupOrigDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
+ private void setupOrigDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
IMdsalApiManager mdsalApiManager, DataBroker broker, WriteTransaction writeFlowGroupTx) {
BigInteger dpId = interfaceInfo.getDpId();
String ifName = interfaceInfo.getInterfaceName();
}
}
- private static void setupOrigDmacFlowsonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
+ private void setupOrigDmacFlowsonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
BigInteger dstDpId, String macAddress, WriteTransaction writeFlowTx) {
BigInteger dpId = interfaceInfo.getDpId();
String elanInstanceName = elanInfo.getElanInstanceName();
}
@SuppressWarnings("unchecked")
- public static List<DpnInterfaces> getInvolvedDpnsInElan(String elanName) {
- List<DpnInterfaces> dpns = ElanInstanceManager.getElanInstanceManager(elanServiceProvider)
- .getElanDPNByName(elanName);
+ public List<DpnInterfaces> getInvolvedDpnsInElan(String elanName) {
+ List<DpnInterfaces> dpns = elanInstanceManager.getElanDPNByName(elanName);
if (dpns == null) {
return Collections.emptyList();
}
return dpns;
}
- private static void setupLocalDmacFlow(long elanTag, BigInteger dpId, String ifName, String macAddress,
+ private void setupLocalDmacFlow(long elanTag, BigInteger dpId, String ifName, String macAddress,
String displayName, IMdsalApiManager mdsalApiManager, long ifTag, WriteTransaction writeFlowGroupTx) {
Flow flowEntity = buildLocalDmacFlowEntry(elanTag, dpId, ifName, macAddress, displayName, ifTag);
mdsalApiManager.addFlowToTx(dpId, flowEntity, writeFlowGroupTx);
writeFlowGroupTx);
}
- private static void installEtreeLocalDmacFlow(long elanTag, BigInteger dpId, String ifName, String macAddress,
+ private void installEtreeLocalDmacFlow(long elanTag, BigInteger dpId, String ifName, String macAddress,
String displayName, IMdsalApiManager mdsalApiManager, long ifTag, WriteTransaction writeFlowGroupTx) {
- EtreeInterface etreeInterface = ElanUtils.getEtreeInterfaceByElanInterfaceName(ifName);
+ EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(ifName);
if (etreeInterface != null) {
if (etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
- EtreeLeafTagName etreeTagName = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeTagName = getEtreeLeafTagByElanTag(elanTag);
if (etreeTagName == null) {
LOG.warn("Interface " + ifName + " seems like it belongs to Etree but etreeTagName from elanTag "
+ elanTag + " is null.");
* the if tag
* @return the flow
*/
- public static Flow buildLocalDmacFlowEntry(long elanTag, BigInteger dpId, String ifName, String macAddress,
+ public Flow buildLocalDmacFlowEntry(long elanTag, BigInteger dpId, String ifName, String macAddress,
String displayName, long ifTag) {
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata,
- new BigInteger[] { ElanUtils.getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
+ new BigInteger[] { getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { macAddress }));
List<Instruction> mkInstructions = new ArrayList<Instruction>();
return flow;
}
- public static void setupRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
+ public void setupRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
String macAddress, String displayName, WriteTransaction writeFlowGroupTx, String interfaceName) {
Flow flowEntity = buildRemoteDmacFlowEntry(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName);
- elanServiceProvider.getMdsalManager().addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
setupEtreeRemoteDmacFlow(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName, interfaceName,
writeFlowGroupTx);
}
- private static void setupEtreeRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
+ private void setupEtreeRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
String macAddress, String displayName, String interfaceName, WriteTransaction writeFlowGroupTx) {
Flow flowEntity;
- EtreeInterface etreeInterface = ElanUtils.getEtreeInterfaceByElanInterfaceName(interfaceName);
+ EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(interfaceName);
if (etreeInterface != null) {
if (etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
- EtreeLeafTagName etreeTagName = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeTagName = getEtreeLeafTagByElanTag(elanTag);
if (etreeTagName == null) {
LOG.warn("Interface " + interfaceName
+ " seems like it belongs to Etree but etreeTagName from elanTag " + elanTag + " is null.");
} else {
flowEntity = buildRemoteDmacFlowEntry(srcDpId, destDpId, lportTag,
etreeTagName.getEtreeLeafTag().getValue(), macAddress, displayName);
- elanServiceProvider.getMdsalManager().addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
+ mdsalManager.addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
}
}
}
* display Name
* @return the flow remote Dmac
*/
- public static Flow buildRemoteDmacFlowEntry(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
+ public Flow buildRemoteDmacFlowEntry(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
String macAddress, String displayName) {
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata,
- new BigInteger[] { ElanUtils.getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
+ new BigInteger[] { getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { macAddress }));
List<Instruction> mkInstructions = new ArrayList<Instruction>();
}
- public static void deleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, MacEntry macEntry,
+ public void deleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, MacEntry macEntry,
WriteTransaction deleteFlowGroupTx) {
if (elanInfo == null || interfaceInfo == null) {
return;
}
}
- public static void deleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
+ public void deleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
boolean deleteSmac, WriteTransaction deleteFlowGroupTx) {
String elanInstanceName = elanInfo.getElanInstanceName();
List<DpnInterfaces> remoteFEs = getInvolvedDpnsInElan(elanInstanceName);
}
}
- private static void executeEtreeDeleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress, boolean deleteSmac,
+ private void executeEtreeDeleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress, boolean deleteSmac,
String elanInstanceName, BigInteger srcdpId, Long elanTag, BigInteger dstDpId,
WriteTransaction deleteFlowGroupTx) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeLeafTag = getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
executeDeleteMacFlows(elanInfo, interfaceInfo, macAddress, deleteSmac, elanInstanceName, srcdpId,
etreeLeafTag.getEtreeLeafTag().getValue(), dstDpId, deleteFlowGroupTx);
}
}
- private static boolean executeDeleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress, boolean deleteSmac,
+ private boolean executeDeleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress, boolean deleteSmac,
String elanInstanceName, BigInteger srcdpId, Long elanTag, BigInteger dstDpId,
WriteTransaction deleteFlowGroupTx) {
boolean isFlowsRemovedInSrcDpn = false;
isFlowsRemovedInSrcDpn = true;
deleteSmacAndDmacFlows(elanInfo, interfaceInfo, macAddress, deleteSmac, deleteFlowGroupTx);
} else if (isDpnPresent(dstDpId)) {
- elanServiceProvider.getMdsalManager()
+ mdsalManager
.removeFlowToTx(dstDpId,
MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE, getKnownDynamicmacFlowRef(
NwConstants.ELAN_DMAC_TABLE, dstDpId, srcdpId, macAddress, elanTag)),
return isFlowsRemovedInSrcDpn;
}
- private static void deleteSmacAndDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
+ private void deleteSmacAndDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
boolean deleteSmac, WriteTransaction deleteFlowGroupTx) {
String elanInstanceName = elanInfo.getElanInstanceName();
long ifTag = interfaceInfo.getInterfaceTag();
BigInteger srcdpId = interfaceInfo.getDpId();
Long elanTag = elanInfo.getElanTag();
if (deleteSmac) {
- elanServiceProvider.getMdsalManager()
+ mdsalManager
.removeFlowToTx(srcdpId,
MDSALUtil.buildFlow(NwConstants.ELAN_SMAC_TABLE, getKnownDynamicmacFlowRef(
NwConstants.ELAN_SMAC_TABLE, srcdpId, ifTag, macAddress, elanTag)),
deleteFlowGroupTx);
}
- elanServiceProvider.getMdsalManager().removeFlowToTx(srcdpId,
+ mdsalManager.removeFlowToTx(srcdpId,
MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE,
getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, srcdpId, ifTag, macAddress, elanTag)),
deleteFlowGroupTx);
String elanInstanceName = elanInstanceAdded.getElanInstanceName();
Long elanTag = elanInstanceAdded.getElanTag();
if (elanTag == null || elanTag == 0L) {
- elanTag = ElanUtils.retrieveNewElanTag(idManager, elanInstanceName);
+ elanTag = retrieveNewElanTag(idManager, elanInstanceName);
}
Elan elanInfo = new ElanBuilder().setName(elanInstanceName).setElanInterfaces(elanInterfaces)
.setKey(new ElanKey(elanInstanceName)).build();
// Add the ElanState in the elan-state operational data-store
- tx.put(LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanInstanceOperationalDataPath(elanInstanceName),
+ tx.put(LogicalDatastoreType.OPERATIONAL, getElanInstanceOperationalDataPath(elanInstanceName),
elanInfo, true);
// Add the ElanMacTable in the elan-mac-table operational data-store
MacTable elanMacTable = new MacTableBuilder().setKey(new MacTableKey(elanInstanceName)).build();
- tx.put(LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanMacTableOperationalDataPath(elanInstanceName),
+ tx.put(LogicalDatastoreType.OPERATIONAL, getElanMacTableOperationalDataPath(elanInstanceName),
elanMacTable, true);
ElanTagNameBuilder elanTagNameBuilder = new ElanTagNameBuilder().setElanTag(elanTag)
.setKey(new ElanTagNameKey(elanTag)).setName(elanInstanceName);
long etreeLeafTag = -1;
if (isEtreeInstance(elanInstanceAdded)) {
- etreeLeafTag = ElanUtils.retrieveNewElanTag(idManager, elanInstanceName + ElanConstants.LEAVES_POSTFIX);
+ etreeLeafTag = retrieveNewElanTag(idManager, elanInstanceName + ElanConstants.LEAVES_POSTFIX);
EtreeLeafTagName etreeLeafTagName = new EtreeLeafTagNameBuilder()
.setEtreeLeafTag(new EtreeLeafTag(etreeLeafTag)).build();
elanTagNameBuilder.addAugmentation(EtreeLeafTagName.class, etreeLeafTagName);
// Add the ElanTag to ElanName in the elan-tag-name Operational
// data-store
tx.put(LogicalDatastoreType.OPERATIONAL,
- ElanUtils.getElanInfoEntriesOperationalDataPath(elanTag), elanTagName);
+ getElanInfoEntriesOperationalDataPath(elanTag), elanTagName);
// Updates the ElanInstance Config DS by setting the just acquired
// elanTag
ElanTagName etreeTagAsElanTag = new ElanTagNameBuilder().setElanTag(etreeLeafTag)
.setKey(new ElanTagNameKey(etreeLeafTag)).setName(elanInstanceName).build();
tx.put(LogicalDatastoreType.OPERATIONAL,
- ElanUtils.getElanInfoEntriesOperationalDataPath(etreeLeafTag), etreeTagAsElanTag);
+ getElanInfoEntriesOperationalDataPath(etreeLeafTag), etreeTagAsElanTag);
}
private static boolean isEtreeInstance(ElanInstance elanInstanceAdded) {
return elanInstanceAdded.getAugmentation(EtreeInstance.class) != null;
}
- public static boolean isDpnPresent(BigInteger dpnId) {
+ public boolean isDpnPresent(BigInteger dpnId) {
String dpn = String.format("%s:%s", "openflow", dpnId);
NodeId nodeId = new NodeId(dpn);
InstanceIdentifier<Node> node = InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(nodeId))
.build();
- Optional<Node> nodePresent = read(elanServiceProvider.getBroker(), LogicalDatastoreType.OPERATIONAL, node);
+ Optional<Node> nodePresent = read(broker, LogicalDatastoreType.OPERATIONAL, node);
return (nodePresent.isPresent());
}
int priority = ElanConstants.ELAN_SERVICE_PRIORITY;
int instructionKey = 0;
List<Instruction> instructions = new ArrayList<>();
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(ElanUtils.getElanMetadataLabel(elanTag),
+ instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(getElanMetadataLabel(elanTag),
MetaDataUtil.METADATA_MASK_SERVICE, ++instructionKey));
instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.ELAN_SMAC_TABLE, ++instructionKey));
* the tunnel key
* @return the list
*/
- public
static List<Action> buildTunnelItmEgressActions(String tunnelIfaceName, Long tunnelKey) {
+ public List<Action> buildTunnelItmEgressActions(String tunnelIfaceName, Long tunnelKey) {
if (tunnelIfaceName != null && !tunnelIfaceName.isEmpty()) {
return buildItmEgressActions(tunnelIfaceName, tunnelKey);
}
* tunnels, etc.
* @return the list
*/
- public
static List<Action> buildItmEgressActions(String interfaceName, Long tunnelKey) {
+ public List<Action> buildItmEgressActions(String interfaceName, Long tunnelKey) {
List<Action> result = Collections.emptyList();
GetEgressActionsForInterfaceInput getEgressActInput = new GetEgressActionsForInterfaceInputBuilder()
.setIntfName(interfaceName).setTunnelKey(tunnelKey).build();
- Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture = elanServiceProvider
- .getInterfaceManagerRpcService().getEgressActionsForInterface(getEgressActInput);
+ Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture = interfaceManagerRpcService
+ .getEgressActionsForInterface(getEgressActInput);
try {
if (egressActionsOutputFuture.get().isSuccessful()) {
GetEgressActionsForInterfaceOutput egressActionsOutput = egressActionsOutputFuture.get().getResult();
* Vni to be stamped on the VxLAN Header.
* @return the external itm egress action
*/
- public
static List<Action> getExternalTunnelItmEgressAction(BigInteger srcDpnId, NodeId torNode, long vni) {
+ public List<Action> getExternalTunnelItmEgressAction(BigInteger srcDpnId, NodeId torNode, long vni) {
List<Action> result = Collections.emptyList();
GetExternalTunnelInterfaceNameInput input = new GetExternalTunnelInterfaceNameInputBuilder()
.setDestinationNode(torNode.getValue()).setSourceNode(srcDpnId.toString())
.setTunnelType(TunnelTypeVxlan.class).build();
- Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> output = elanServiceProvider.getItmRpcService()
+ Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> output = itmRpcService
.getExternalTunnelInterfaceName(input);
try {
if (output.get().isSuccessful()) {
* serviceId to be sent on the VxLAN header.
* @return the internal itm egress action
*/
- public
static List<Action> getInternalTunnelItmEgressAction(BigInteger sourceDpnId, BigInteger destinationDpnId,
+ public List<Action> getInternalTunnelItmEgressAction(BigInteger sourceDpnId, BigInteger destinationDpnId,
long serviceTag) {
List<Action> result = Collections.emptyList();
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
GetTunnelInterfaceNameInput input = new GetTunnelInterfaceNameInputBuilder()
.setDestinationDpid(destinationDpnId).setSourceDpid(sourceDpnId).setTunnelType(tunType).build();
- Future<RpcResult<GetTunnelInterfaceNameOutput>> output = elanServiceProvider.getItmRpcService()
+ Future<RpcResult<GetTunnelInterfaceNameOutput>> output = itmRpcService
.getTunnelInterfaceName(input);
try {
if (output.get().isSuccessful()) {
* Interface name
* @return the external port itm egress actions
*/
- public
static List<Action> getExternalPortItmEgressAction(String interfaceName) {
+ public List<Action> getExternalPortItmEgressAction(String interfaceName) {
return buildItmEgressActions(interfaceName, null);
}
return mkMatches;
}
- public static void removeTerminatingServiceAction(BigInteger destDpId, int serviceId) {
+ public void removeTerminatingServiceAction(BigInteger destDpId, int serviceId) {
RemoveTerminatingServiceActionsInput input = new RemoveTerminatingServiceActionsInputBuilder()
.setDpnId(destDpId).setServiceId(serviceId).build();
- Future<RpcResult<Void>> futureObject = elanServiceProvider.getItmRpcService()
+ Future<RpcResult<Void>> futureObject = itmRpcService
.removeTerminatingServiceActions(input);
try {
RpcResult<Void> result = futureObject.get();
}
}
- public
static void createTerminatingServiceActions(BigInteger destDpId, int serviceId, List<Action> actions) {
+ public void createTerminatingServiceActions(BigInteger destDpId, int serviceId, List<Action> actions) {
List<Instruction> mkInstructions = new ArrayList<Instruction>();
mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
CreateTerminatingServiceActionsInput input = new CreateTerminatingServiceActionsInputBuilder()
.setDpnId(destDpId).setServiceId(serviceId).setInstruction(mkInstructions).build();
- elanServiceProvider.getItmRpcService().createTerminatingServiceActions(input);
+ itmRpcService.createTerminatingServiceActions(input);
}
- public static TunnelList buildInternalTunnel(DataBroker broker) {
+ public TunnelList buildInternalTunnel(DataBroker broker) {
InstanceIdentifier<TunnelList> tunnelListInstanceIdentifier = InstanceIdentifier.builder(TunnelList.class)
.build();
Optional<TunnelList> tunnelList = read(broker, LogicalDatastoreType.CONFIGURATION,
* the datastore type
* @return the external tunnel
*/
- public static ExternalTunnel getExternalTunnel(String sourceDevice, String destinationDevice,
+ public ExternalTunnel getExternalTunnel(String sourceDevice, String destinationDevice,
LogicalDatastoreType datastoreType) {
ExternalTunnel externalTunnel = null;
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
InstanceIdentifier<ExternalTunnel> iid = InstanceIdentifier.builder(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(destinationDevice, sourceDevice, tunType)).build();
- Optional<ExternalTunnel> tunnelList = read(elanServiceProvider.getBroker(), datastoreType, iid);
+ Optional<ExternalTunnel> tunnelList = read(broker, datastoreType, iid);
if (tunnelList.isPresent()) {
externalTunnel = tunnelList.get();
}
* the datastore type
* @return the external tunnel
*/
- public static ExternalTunnel getExternalTunnel(String interfaceName, LogicalDatastoreType datastoreType) {
+ public ExternalTunnel getExternalTunnel(String interfaceName, LogicalDatastoreType datastoreType) {
ExternalTunnel externalTunnel = null;
List<ExternalTunnel> externalTunnels = getAllExternalTunnels(datastoreType);
for (ExternalTunnel tunnel : externalTunnels) {
* the data store type
* @return the all external tunnels
*/
- public static List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
+ public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
List<ExternalTunnel> result = null;
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
- Optional<ExternalTunnelList> tunnelList = read(elanServiceProvider.getBroker(), datastoreType, iid);
+ Optional<ExternalTunnelList> tunnelList = read(broker, datastoreType, iid);
if (tunnelList.isPresent()) {
result = tunnelList.get().getExternalTunnel();
}
* @param displayName
* the display name
*/
- public static void installDmacFlowsToInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
+ public void installDmacFlowsToInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
long elanTag, String macAddress, String displayName) {
Flow flow = buildDmacFlowForInternalRemoteMac(localDpId, remoteDpId, lportTag, elanTag, macAddress,
displayName);
- elanServiceProvider.getMdsalManager().installFlow(remoteDpId, flow);
+ mdsalManager.installFlow(remoteDpId, flow);
}
/**
*
* @return the dmac flows
*/
- public static List<ListenableFuture<Void>> installDmacFlowsToExternalRemoteMac(BigInteger dpnId,
+ public List<ListenableFuture<Void>> installDmacFlowsToExternalRemoteMac(BigInteger dpnId,
String extDeviceNodeId, Long elanTag, Long vni, String macAddress, String displayName,
String interfaceName) {
List<ListenableFuture<Void>> futures = new ArrayList<>();
synchronized (macAddress) {
Flow flow = buildDmacFlowForExternalRemoteMac(dpnId, extDeviceNodeId, elanTag, vni, macAddress,
displayName);
- futures.add(elanServiceProvider.getMdsalManager().installFlow(dpnId, flow));
+ futures.add(mdsalManager.installFlow(dpnId, flow));
Flow dropFlow = buildDmacFlowDropIfPacketComingFromTunnel(dpnId, extDeviceNodeId, elanTag, macAddress);
- futures.add(elanServiceProvider.getMdsalManager().installFlow(dpnId, dropFlow));
+ futures.add(mdsalManager.installFlow(dpnId, dropFlow));
installEtreeDmacFlowsToExternalRemoteMac(dpnId, extDeviceNodeId, elanTag, vni, macAddress, displayName,
interfaceName, futures);
}
return futures;
}
- private static void installEtreeDmacFlowsToExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long elanTag,
+ private void installEtreeDmacFlowsToExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long elanTag,
Long vni, String macAddress, String displayName, String interfaceName,
List<ListenableFuture<Void>> futures) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeLeafTag = getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
buildEtreeDmacFlowDropIfPacketComingFromTunnel(dpnId, extDeviceNodeId, elanTag, macAddress, futures,
etreeLeafTag);
}
}
- private static void buildEtreeDmacFlowForExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long vni,
+ private void buildEtreeDmacFlowForExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long vni,
String macAddress, String displayName, String interfaceName, List<ListenableFuture<Void>> futures,
EtreeLeafTagName etreeLeafTag) {
boolean isRoot = false;
if (interfaceName == null) {
isRoot = true;
} else {
- EtreeInterface etreeInterface = ElanUtils.getEtreeInterfaceByElanInterfaceName(interfaceName);
+ EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(interfaceName);
if (etreeInterface != null) {
if (etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
isRoot = true;
if (isRoot) {
Flow flow = buildDmacFlowForExternalRemoteMac(dpnId, extDeviceNodeId,
etreeLeafTag.getEtreeLeafTag().getValue(), vni, macAddress, displayName);
- futures.add(elanServiceProvider.getMdsalManager().installFlow(dpnId, flow));
+ futures.add(mdsalManager.installFlow(dpnId, flow));
}
}
- private static void buildEtreeDmacFlowDropIfPacketComingFromTunnel(BigInteger dpnId, String extDeviceNodeId,
+ private void buildEtreeDmacFlowDropIfPacketComingFromTunnel(BigInteger dpnId, String extDeviceNodeId,
Long elanTag, String macAddress, List<ListenableFuture<Void>> futures, EtreeLeafTagName etreeLeafTag) {
if (etreeLeafTag != null) {
Flow dropFlow = buildDmacFlowDropIfPacketComingFromTunnel(dpnId, extDeviceNodeId,
etreeLeafTag.getEtreeLeafTag().getValue(), macAddress);
- futures.add(elanServiceProvider.getMdsalManager().installFlow(dpnId, dropFlow));
+ futures.add(mdsalManager.installFlow(dpnId, dropFlow));
}
}
public static List<MatchInfo> buildMatchesForElanTagShFlagAndDstMac(long elanTag, boolean shFlag, String macAddr) {
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
- ElanUtils.getElanMetadataLabel(elanTag, shFlag), MetaDataUtil.METADATA_MASK_SERVICE_SH_FLAG }));
+ getElanMetadataLabel(elanTag, shFlag), MetaDataUtil.METADATA_MASK_SERVICE_SH_FLAG }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { macAddr }));
return mkMatches;
* the display name
* @return the flow
*/
- public static Flow buildDmacFlowForExternalRemoteMac(BigInteger dpId, String extDeviceNodeId, long elanTag,
+ public Flow buildDmacFlowForExternalRemoteMac(BigInteger dpId, String extDeviceNodeId, long elanTag,
Long vni, String dstMacAddress, String displayName) {
List<MatchInfo> mkMatches = buildMatchesForElanTagShFlagAndDstMac(elanTag, /* shFlag */ false, dstMacAddress);
List<Instruction> mkInstructions = new ArrayList<>();
* the display name
* @return the flow
*/
- public static Flow buildDmacFlowForInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
+ public Flow buildDmacFlowForInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
long elanTag, String macAddress, String displayName) {
List<MatchInfo> mkMatches = buildMatchesForElanTagShFlagAndDstMac(elanTag, /* shFlag */ false, macAddress);
* Indicates if flows must be installed or removed.
* @see org.opendaylight.genius.mdsalutil.MDSALUtil.MdsalOp
*/
- public static void setupDmacFlowsToExternalRemoteMac(BigInteger dpId, String extNodeId, Long elanTag, Long vni,
+ public void setupDmacFlowsToExternalRemoteMac(BigInteger dpId, String extNodeId, Long elanTag, Long vni,
String macAddress, String elanInstanceName, MdsalOp addOrRemove, String interfaceName) {
if (addOrRemove == MdsalOp.CREATION_OP) {
- ElanUtils.installDmacFlowsToExternalRemoteMac(dpId, extNodeId, elanTag, vni, macAddress, elanInstanceName,
+ installDmacFlowsToExternalRemoteMac(dpId, extNodeId, elanTag, vni, macAddress, elanInstanceName,
interfaceName);
} else if (addOrRemove == MdsalOp.REMOVAL_OP) {
- ElanUtils.deleteDmacFlowsToExternalMac(elanTag, dpId, extNodeId, macAddress);
+ deleteDmacFlowsToExternalMac(elanTag, dpId, extNodeId, macAddress);
}
}
* the mac to remove
* @return dmac flow
*/
- public static List<ListenableFuture<Void>> deleteDmacFlowsToExternalMac(long elanTag, BigInteger dpId,
+ public List<ListenableFuture<Void>> deleteDmacFlowsToExternalMac(long elanTag, BigInteger dpId,
String extDeviceNodeId, String macToRemove) {
List<ListenableFuture<Void>> futures = new ArrayList<>();
synchronized (macToRemove) {
return futures;
}
- private static void deleteEtreeDmacFlowsToExternalMac(long elanTag, BigInteger dpId, String extDeviceNodeId,
+ private void deleteEtreeDmacFlowsToExternalMac(long elanTag, BigInteger dpId, String extDeviceNodeId,
String macToRemove, List<ListenableFuture<Void>> futures) {
- EtreeLeafTagName etreeLeafTag = ElanUtils.getEtreeLeafTagByElanTag(elanTag);
+ EtreeLeafTagName etreeLeafTag = getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
removeFlowThatSendsThePacketOnAnExternalTunnel(etreeLeafTag.getEtreeLeafTag().getValue(), dpId,
extDeviceNodeId, macToRemove, futures);
}
}
- private static void removeTheDropFlow(long elanTag, BigInteger dpId, String extDeviceNodeId, String macToRemove,
+ private void removeTheDropFlow(long elanTag, BigInteger dpId, String extDeviceNodeId, String macToRemove,
List<ListenableFuture<Void>> futures) {
String flowId = getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, extDeviceNodeId, macToRemove,
elanTag, true);
Flow flowToRemove = new FlowBuilder().setId(new FlowId(flowId)).setTableId(NwConstants.ELAN_DMAC_TABLE).build();
- futures.add(elanServiceProvider.getMdsalManager().removeFlow(dpId, flowToRemove));
+ futures.add(mdsalManager.removeFlow(dpId, flowToRemove));
}
- private static void removeFlowThatSendsThePacketOnAnExternalTunnel(long elanTag, BigInteger dpId,
+ private void removeFlowThatSendsThePacketOnAnExternalTunnel(long elanTag, BigInteger dpId,
String extDeviceNodeId, String macToRemove, List<ListenableFuture<Void>> futures) {
String flowId = getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, extDeviceNodeId, macToRemove,
elanTag, false);
Flow flowToRemove = new FlowBuilder().setId(new FlowId(flowId)).setTableId(NwConstants.ELAN_DMAC_TABLE).build();
- futures.add(elanServiceProvider.getMdsalManager().removeFlow(dpId, flowToRemove));
+ futures.add(mdsalManager.removeFlow(dpId, flowToRemove));
}
/**
* the interface name
* @return the dpid from interface
*/
- public static BigInteger getDpidFromInterface(String interfaceName) {
+ public BigInteger getDpidFromInterface(String interfaceName) {
BigInteger dpId = null;
- Future<RpcResult<GetDpidFromInterfaceOutput>> output = elanServiceProvider.getInterfaceManagerRpcService()
+ Future<RpcResult<GetDpidFromInterfaceOutput>> output = interfaceManagerRpcService
.getDpidFromInterface(new GetDpidFromInterfaceInputBuilder().setIntfName(interfaceName).build());
try {
RpcResult<GetDpidFromInterfaceOutput> rpcResult = output.get();
&& elanInstance.getSegmentType().isAssignableFrom(SegmentTypeFlat.class);
}
- public static boolean isExternal(String interfaceName) {
- return isExternal(getInterfaceFromConfigDS(interfaceName, elanServiceProvider.getBroker()));
+ public boolean isExternal(String interfaceName) {
+ return isExternal(getInterfaceFromConfigDS(interfaceName, broker));
}
public static boolean isExternal(
return ifExternal != null && Boolean.TRUE.equals(ifExternal.isExternal());
}
- public static boolean isEtreeRootInterfaceByInterfaceName(String interfaceName) {
+ public boolean isEtreeRootInterfaceByInterfaceName(String interfaceName) {
EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(interfaceName);
if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
return true;
+++ /dev/null
-/*
- * 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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216;
-
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-
-public class ElanServiceImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216.AbstractElanServiceImplModule {
- public ElanServiceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
- super(identifier, dependencyResolver);
- }
-
- public ElanServiceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216.ElanServiceImplModule oldModule, java.lang.AutoCloseable oldInstance) {
- super(identifier, dependencyResolver, oldModule, oldInstance);
- }
-
- @Override
- public void customValidation() {
- // add custom validation form module attributes here.
- }
-
- @Override
- public java.lang.AutoCloseable createInstance() {
- RpcProviderRegistry rpcregistryDependency = getRpcregistryDependency();
- IdManagerService idManager = rpcregistryDependency.getRpcService(IdManagerService.class);
- ElanServiceProvider provider = new ElanServiceProvider(rpcregistryDependency);
- provider.setNotificationService(getNotificationServiceDependency());
- provider.setMdsalManager(getMdsalutilDependency());
- provider.setInterfaceManager(getOdlinterfaceDependency());
- provider.setInterfaceManagerRpcService(rpcregistryDependency.getRpcService(OdlInterfaceRpcService.class));
- provider.setItmRpcService(rpcregistryDependency.getRpcService(ItmRpcService.class));
- provider.setItmManager(getItmmanagerDependency());
- provider.setIdManager(idManager);
- provider.setEntityOwnershipService(getEntityOwnershipServiceDependency());
- provider.setGenerateIntBridgeMac(getIntBridgeGenMac());
- getBrokerDependency().registerProvider(provider);
- return provider;
- }
-
-}
+++ /dev/null
-/*
- * 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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216;
-public class ElanServiceImplModuleFactory extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216.AbstractElanServiceImplModuleFactory {
-
-}
<reference id="interfaceManagerRef"
interface="org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager"
availability="optional" />
+ <reference id="elanUtilsRef" interface="org.opendaylight.netvirt.elan.utils.ElanUtils"
+ availability="optional" />
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<action class="org.opendaylight.netvirt.elan.cli.ElanAdd">
<action class="org.opendaylight.netvirt.elan.cli.etree.EtreeInterfaceGet">
<property name="elanProvider" ref="elanProviderRef" />
<property name="interfaceManager" ref="interfaceManagerRef" />
+ <property name="elanUtils" ref="elanUtilsRef" />
</action>
</command>
<command>
<action class="org.opendaylight.netvirt.elan.cli.etree.EtreeInterfaceDelete">
<property name="elanProvider" ref="elanProviderRef" />
+ <property name="elanUtils" ref="elanUtilsRef" />
</action>
</command>
</command-bundle>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
+ xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
+ odl:use-default-for-reference-types="true">
+
+ <reference id="dataBroker"
+ interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ odl:type="pingpong" />
+ <reference id="notificationService"
+ interface="org.opendaylight.controller.md.sal.binding.api.NotificationService" />
+ <reference id="entityOwnershipService"
+ interface="org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService" />
+ <reference id="mdsalUtils"
+ interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
+ <reference id="interfaceManager"
+ interface="org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager" />
+
+ <odl:rpc-service id="odlInterfaceRpcService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService" />
+ <odl:rpc-service id="itmRpcService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService" />
+ <odl:rpc-service id="salFlowService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService" />
+ <odl:rpc-service id="idManagerService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService" />
+
+ <bean id="elanForwardingEntriesHandler" class="org.opendaylight.netvirt.elan.utils.ElanForwardingEntriesHandler"
+ destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="elanUtils" />
+ </bean>
+
+ <bean id="elanInterfaceManager"
+ class="org.opendaylight.netvirt.elan.internal.ElanInterfaceManager"
+ destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="idManagerService" />
+ <argument ref="mdsalUtils" />
+ <argument ref="interfaceManager" />
+ <argument ref="elanForwardingEntriesHandler" />
+ <argument ref="elanL2GatewayUtils" />
+ <argument ref="elanUtils" />
+ </bean>
+
+ <bean id="elanInstanceManager"
+ class="org.opendaylight.netvirt.elan.internal.ElanInstanceManager"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="idManagerService" />
+ <argument ref="elanInterfaceManager" />
+ <argument ref="interfaceManager" />
+ <argument ref="elanUtils" />
+ </bean>
+
+ <bean id="elanNodeListener"
+ class="org.opendaylight.netvirt.elan.internal.ElanNodeListener"
+ destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="mdsalUtils" />
+ </bean>
+
+ <bean id="elanPacketInHandler"
+ class="org.opendaylight.netvirt.elan.internal.ElanPacketInHandler">
+ <argument ref="dataBroker" />
+ <argument ref="interfaceManager" />
+ <argument ref="elanUtils" />
+ <argument ref="elanL2GatewayUtils" />
+ </bean>
+ <odl:notification-listener ref="elanPacketInHandler" />
+
+ <bean id="elanSmacFlowEventListener"
+ class="org.opendaylight.netvirt.elan.internal.ElanSmacFlowEventListener">
+ <argument ref="dataBroker" />
+ <argument ref="interfaceManager" />
+ </bean>
+ <odl:notification-listener ref="elanSmacFlowEventListener" />
+
+ <bean id="elanUtils" class="org.opendaylight.netvirt.elan.utils.ElanUtils">
+ <argument ref="dataBroker" />
+ <argument ref="mdsalUtils" />
+ <argument ref="elanInstanceManager" />
+ <argument ref="odlInterfaceRpcService" />
+ <argument ref="itmRpcService" />
+ </bean>
+
+ <bean id="elanStatisticsImpl" class="org.opendaylight.netvirt.elan.statisitcs.ElanStatisticsImpl">
+ <argument ref="dataBroker" />
+ <argument ref="interfaceManager" />
+ <argument ref="mdsalUtils" />
+ <argument ref="elanUtils" />
+ </bean>
+ <odl:rpc-implementation ref="elanStatisticsImpl" />
+
+ <bean id="elanInterfaceStateChangeListener"
+ class="org.opendaylight.netvirt.elan.internal.ElanInterfaceStateChangeListener">
+ <argument ref="dataBroker" />
+ <argument ref="elanInterfaceManager" />
+ <argument ref="interfaceManager" />
+ <argument ref="elanUtils" />
+ </bean>
+
+ <bean id="elanInterfaceStateClusterListener"
+ class="org.opendaylight.netvirt.elan.internal.ElanInterfaceStateClusteredListener"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="elanInterfaceManager" />
+ <argument ref="elanUtils" />
+ <argument ref="entityOwnershipService" />
+ </bean>
+
+ <bean id="elanInterfaceClusterListener"
+ class="org.opendaylight.netvirt.elan.internal.ElanDpnInterfaceClusteredListener">
+ <argument ref="dataBroker" />
+ <argument ref="entityOwnershipService" />
+ <argument ref="elanL2GatewayUtils" />
+ </bean>
+
+ <bean id="elanService" class="org.opendaylight.netvirt.elan.internal.ElanServiceProvider"
+ init-method="init">
+ <argument ref="idManagerService" />
+ <argument ref="interfaceManager" />
+ <argument ref="elanInstanceManager" />
+ <argument ref="elanBridgeManager" />
+ <argument ref="dataBroker" />
+ <argument ref="elanStatusMonitor" />
+ <argument ref="elanUtils" />
+ </bean>
+ <service ref="elanService" odl:type="default" interface="org.opendaylight.netvirt.elanmanager.api.IElanService" />
+
+ <bean id="elanL2GatewayUtils" class="org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils">
+ <argument ref="dataBroker" />
+ <argument ref="itmRpcService" />
+ <argument ref="elanUtils" />
+ <argument ref="entityOwnershipService" />
+ </bean>
+
+ <bean id="cacheElanInterfaceListener" class="org.opendaylight.netvirt.elan.utils.CacheElanInterfaceListener"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ </bean>
+
+ <bean id="hwvtepLocalUcastMacListener" class="org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepLocalUcastMacListener"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="elanL2GatewayUtils" />
+ </bean>
+
+ <bean id="elanStatusMonitor" class="org.opendaylight.netvirt.elan.statusanddiag.ElanStatusMonitor"
+ init-method="init" />
+
+ <bean id="l2GatewayConnectionListener"
+ class="org.opendaylight.netvirt.elan.l2gw.listeners.L2GatewayConnectionListener"
+ destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="elanInstanceManager" />
+ <argument ref="l2GatewayConnectionUtils" />
+ </bean>
+
+ <bean id="hwvtepPhysicalSwitchListener"
+ class="org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepPhysicalSwitchListener"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="itmRpcService" />
+ <argument ref="entityOwnershipService" />
+ <argument ref="l2GatewayConnectionUtils" />
+ </bean>
+
+ <bean id="hwvtepTerminationPointListener"
+ class="org.opendaylight.netvirt.elan.l2gw.listeners.HwvtepTerminationPointListener"
+ destroy-method="close">
+ <argument ref="broker" />
+ <argument ref="elanL2GatewayUtils" />
+ <argument ref="entityOwnershipService" />
+ </bean>
+</blueprint>
\ No newline at end of file
+++ /dev/null
-module elanservice-impl {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:elanservice:impl";
- prefix "elanservice-impl";
-
- import config { prefix config; revision-date 2013-04-05; }
- import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
- import opendaylight-sal-binding-broker-impl { prefix md-sal-binding-impl; revision-date 2013-10-28;}
- import opendaylight-entity-ownership-service { prefix eos; revision-date 2015-08-10;}
- import elanmanager-api { prefix elanmgr-api; revision-date 2015-07-07;}
- import odl-mdsalutil { prefix odl-mdsal; revision-date 2016-04-06;}
- import odl-interface {prefix odlif; revision-date 2016-04-06;}
- import itm {prefix itm; revision-date 2016-04-06;}
-
- description
- "Service definition for elanservice project";
-
- revision "2015-02-16" {
- description
- "Initial revision";
- }
-
- identity elanservice-impl {
- base config:module-type;
- config:provided-service elanmgr-api:elanmanager-api;
- config:java-name-prefix elanServiceImpl;
- }
-
- augment "/config:modules/config:module/config:configuration" {
- case elanservice-impl {
- when "/config:modules/config:module/config:type = 'elanservice-impl'";
- container broker {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-broker-osgi-registry;
- }
- }
- }
- container rpcregistry {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-rpc-registry;
- }
- }
- }
- container mdsalutil {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity odl-mdsal:odl-mdsalutil;
- }
- }
- }
- container odlinterface {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity odlif:odl-interface;
- }
- }
- }
- container itmmanager {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity itm:itm;
- }
- }
- }
- container notification-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding-impl:binding-new-notification-service;
- }
- }
- }
- container entity-ownership-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity eos:entity-ownership-service;
- }
- }
- }
- leaf int-bridge-gen-mac {
- type boolean;
- }
- }
- }
-}
\ No newline at end of file
<artifactId>elanmanager-impl</artifactId>
<version>${elanmgr.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>elanmanager-impl</artifactId>
- <version>${elanmgr.version}</version>
- <classifier>config</classifier>
- <type>xml</type>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>elanmanager-api</artifactId>
<bundle>mvn:org.opendaylight.ovsdb/utils.mdsal-utils/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.ovsdb/utils.southbound-utils/{{VERSION}}</bundle>
<bundle>wrap:mvn:org.apache.thrift/libthrift/0.9.1$overwrite=merge&Bundle-Version=0.9.1&Export-Package=*;-noimport:=true;version="0.9.1"</bundle>
- <configfile finalname="${configfile.directory}/elanmanager-impl-default-config.xml">mvn:org.opendaylight.netvirt/elanmanager-impl/{{VERSION}}/xml/config</configfile>
<!--<configfile finalname="${configfile.directory}/cloud-servicechain-impl-default-config.xml">mvn:org.opendaylight.netvirt/cloud-servicechain-impl/{{VERSION}}/xml/config</configfile>-->
</feature>
}
private void initReady() {
- readyMap.put("elanservice-impl", Pair.of("elanservice-default", false));
}
private void getServices() {
Code Review / netvirt.git / commitdiff