elanmanager/elanmanager-impl/src/main/java/org/opendaylight/vpnservice/elan/internal/ElanServiceProvider.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.vpnservice.elan.internal;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.List;
  14 import java.util.concurrent.Future;
  15
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  18 import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
  22 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  23 import org.opendaylight.elanmanager.api.IElanService;
  24 import org.opendaylight.elanmanager.exceptions.MacNotFoundException;
  25 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  26 import org.opendaylight.vpnservice.elan.l2gw.internal.ElanL2GatewayProvider;
  27 import org.opendaylight.vpnservice.elan.statisitcs.ElanStatisticsImpl;
  28 import org.opendaylight.vpnservice.elan.statusanddiag.ElanStatusMonitor;
  29 import org.opendaylight.vpnservice.elan.utils.ElanClusterUtils;
  30 import org.opendaylight.vpnservice.elan.utils.ElanConstants;
  31 import org.opendaylight.vpnservice.elan.utils.ElanUtils;
  32 import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
  33 import org.opendaylight.vpnservice.itm.api.IITMProvider;
  34 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  35 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  36 import org.opendaylight.vpnservice.utils.hwvtep.HwvtepSouthboundUtils;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.ElanInstances;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.ElanInterfaces;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan._interface.forwarding.entries.ElanInterfaceMac;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.instances.ElanInstance;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.instances.ElanInstanceBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.instances.ElanInstanceKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.interfaces.ElanInterface;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.interfaces.ElanInterfaceKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.state.Elan;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntry;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.statistics.rev150824.ElanStatisticsService;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  64 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  65 import org.opendaylight.yangtools.yang.common.RpcResult;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 import com.google.common.base.Optional;
  70
  71 public class ElanServiceProvider implements BindingAwareProvider, IElanService, AutoCloseable {
  72
  73     private IdManagerService idManager;
  74     private IMdsalApiManager mdsalManager;
  75     private IInterfaceManager interfaceManager;
  76     private OdlInterfaceRpcService interfaceManagerRpcService;
  77     private ElanInstanceManager elanInstanceManager;
  78     private ElanForwardingEntriesHandler elanForwardingEntriesHandler;
  79     private ElanInterfaceManager elanInterfaceManager;
  80     private ElanPacketInHandler elanPacketInHandler;
  81     private ElanSmacFlowEventListener elanSmacFlowEventListener;
  82     private ElanInterfaceStateChangeListener elanInterfaceStateChangeListener;
  83     private ElanInterfaceStateClusteredListener infStateChangeClusteredListener;
  84     private ElanDpnInterfaceClusteredListener elanDpnInterfaceClusteredListener;
  85     private ElanNodeListener elanNodeListener;
  86     private NotificationService notificationService;
  87     private RpcProviderRegistry rpcProviderRegistry;
  88     private IITMProvider itmManager;
  89     private ItmRpcService itmRpcService;
  90     private DataBroker broker;
  91     private ElanL2GatewayProvider elanL2GatewayProvider;
  92
  93     private EntityOwnershipService entityOwnershipService;
  94
  95     private static final ElanStatusMonitor elanStatusMonitor = ElanStatusMonitor.getInstance();
  96     static DataStoreJobCoordinator dataStoreJobCoordinator;
  97
  98     public static void setDataStoreJobCoordinator(DataStoreJobCoordinator ds) {
  99         dataStoreJobCoordinator = ds;
 100     }
 101
 102     public static DataStoreJobCoordinator getDataStoreJobCoordinator() {
 103         if (dataStoreJobCoordinator == null) {
 104             dataStoreJobCoordinator = DataStoreJobCoordinator.getInstance();
 105         }
 106         return dataStoreJobCoordinator;
 107     }
 108
 109
 110     public ElanServiceProvider(RpcProviderRegistry rpcRegistry) {
 111         rpcProviderRegistry = rpcRegistry;
 112         elanStatusMonitor.registerMbean();
 113     }
 114
 115     // private ElanInterfaceStateChangeListener elanInterfaceEventListener;
 116     private ElanItmEventListener elanItmEventListener;
 117
 118     private static final Logger logger = LoggerFactory.getLogger(ElanServiceProvider.class);
 119
 120     @Override
 121     public void onSessionInitiated(ProviderContext session) {
 122         elanStatusMonitor.reportStatus("STARTING");
 123         try {
 124             createIdPool();
 125             getDataStoreJobCoordinator();
 126             broker = session.getSALService(DataBroker.class);
 127
 128             ElanUtils.setDataBroker(broker);
 129             ElanUtils.setIfaceMgrRpcService(interfaceManagerRpcService);
 130             ElanUtils.setItmRpcService(itmRpcService);
 131             ElanUtils.setMdsalManager(mdsalManager);
 132
 133             elanForwardingEntriesHandler = new ElanForwardingEntriesHandler(broker);
 134
 135             elanInterfaceManager = ElanInterfaceManager.getElanInterfaceManager();
 136             elanInterfaceManager.setInterfaceManager(interfaceManager);
 137             elanInterfaceManager.setIdManager(idManager);
 138             elanInterfaceManager.setMdSalApiManager(mdsalManager);
 139             elanInterfaceManager.setDataBroker(broker);
 140             elanInterfaceManager.setInterfaceManagerRpcService(interfaceManagerRpcService);
 141             elanInterfaceManager.setElanForwardingEntriesHandler(elanForwardingEntriesHandler);
 142
 143             elanInstanceManager = ElanInstanceManager.getElanInstanceManager();
 144             elanInstanceManager.setDataBroker(broker);
 145             elanInstanceManager.setIdManager(idManager);
 146             elanInstanceManager.setElanInterfaceManager(elanInterfaceManager);
 147             elanInstanceManager.setInterfaceManager(interfaceManager);
 148
 149
 150             elanNodeListener = new ElanNodeListener(broker, mdsalManager);
 151
 152             elanPacketInHandler = new ElanPacketInHandler(broker);
 153             elanPacketInHandler.setInterfaceManager(interfaceManager);
 154
 155
 156             elanSmacFlowEventListener = new ElanSmacFlowEventListener(broker);
 157             elanSmacFlowEventListener.setMdSalApiManager(mdsalManager);
 158             elanSmacFlowEventListener.setInterfaceManager(interfaceManager);
 159             elanSmacFlowEventListener.setSalFlowService(session.getRpcService(SalFlowService.class));
 160
 161
 162             // Initialize statistics rpc provider for elan
 163             ElanStatisticsService interfaceStatsService = new ElanStatisticsImpl(broker, interfaceManager,
 164                     mdsalManager);
 165             rpcProviderRegistry.addRpcImplementation(ElanStatisticsService.class, interfaceStatsService);
 166
 167             elanInterfaceStateChangeListener = new ElanInterfaceStateChangeListener(broker, elanInterfaceManager);
 168             elanInterfaceStateChangeListener.setInterfaceManager(interfaceManager);
 169
 170             infStateChangeClusteredListener = new ElanInterfaceStateClusteredListener(broker, elanInterfaceManager);
 171
 172             elanDpnInterfaceClusteredListener = new ElanDpnInterfaceClusteredListener(broker, elanInterfaceManager);
 173             ElanClusterUtils.setEntityOwnershipService(entityOwnershipService);
 174             ElanClusterUtils.setDataStoreJobCoordinator(dataStoreJobCoordinator);
 175             this.elanL2GatewayProvider = new ElanL2GatewayProvider(this);
 176
 177             elanInterfaceManager.registerListener();
 178             elanInstanceManager.registerListener();
 179             notificationService.registerNotificationListener(elanSmacFlowEventListener);
 180             notificationService.registerNotificationListener(elanPacketInHandler);
 181
 182             elanStatusMonitor.reportStatus("OPERATIONAL");
 183         } catch (Exception e) {
 184             logger.error("Error initializing services", e);
 185             elanStatusMonitor.reportStatus("ERROR");
 186         }
 187     }
 188
 189     public void setIdManager(IdManagerService idManager) {
 190         this.idManager = idManager;
 191     }
 192
 193     public void setMdsalManager(IMdsalApiManager mdsalManager) {
 194         this.mdsalManager = mdsalManager;
 195     }
 196
 197     public void setInterfaceManager(IInterfaceManager interfaceManager) {
 198         this.interfaceManager = interfaceManager;
 199     }
 200
 201     public void setEntityOwnershipService(EntityOwnershipService entityOwnershipService) {
 202         this.entityOwnershipService = entityOwnershipService;
 203     }
 204
 205     public IInterfaceManager getInterfaceManager() {
 206         return this.interfaceManager;
 207     }
 208
 209     public IMdsalApiManager getMdsalManager() {
 210         return mdsalManager;
 211     }
 212
 213     public IITMProvider getItmManager() {
 214         return itmManager;
 215     }
 216
 217     public DataBroker getBroker() {
 218         return broker;
 219     }
 220
 221     public void setNotificationService(NotificationService notificationService) {
 222         this.notificationService = notificationService;
 223     }
 224
 225     public void setInterfaceManagerRpcService(OdlInterfaceRpcService interfaceManager) {
 226         this.interfaceManagerRpcService = interfaceManager;
 227     }
 228
 229     public OdlInterfaceRpcService getInterfaceManagerRpcService() {
 230         return interfaceManagerRpcService;
 231     }
 232
 233     public void setItmManager(IITMProvider itmManager) {
 234         this.itmManager = itmManager;
 235     }
 236
 237     public void setItmRpcService(ItmRpcService itmRpcService) {
 238         this.itmRpcService = itmRpcService;
 239     }
 240
 241     public ItmRpcService getItmRpcService() {
 242         return itmRpcService;
 243     }
 244
 245     public ElanInstanceManager getElanInstanceManager() {
 246         return elanInstanceManager;
 247     }
 248
 249     public ElanInterfaceManager getElanInterfaceManager() {
 250         return elanInterfaceManager;
 251     }
 252
 253     public EntityOwnershipService getEntityOwnershipService() {
 254         return entityOwnershipService;
 255     }
 256
 257     private void createIdPool() {
 258         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(ElanConstants.ELAN_ID_POOL_NAME)
 259                 .setLow(ElanConstants.ELAN_ID_LOW_VALUE).setHigh(ElanConstants.ELAN_ID_HIGH_VALUE).build();
 260         try {
 261             Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
 262             if ((result != null) && (result.get().isSuccessful())) {
 263                 logger.debug("ELAN Id Pool is created successfully");
 264             }
 265         } catch (Exception e) {
 266             logger.error("Failed to create ELAN Id pool {}", e);
 267         }
 268     }
 269
 270     @Override
 271     public boolean createElanInstance(String elanInstanceName, long macTimeout, String description) {
 272         ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
 273         boolean isSuccess = true;
 274         if (existingElanInstance != null) {
 275             if (compareWithExistingElanInstance(existingElanInstance, macTimeout, description)) {
 276                 logger.debug("Elan Instance is already present in the Operational DS {}", existingElanInstance);
 277                 return true;
 278             } else {
 279                 ElanInstance updateElanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
 280                         .setDescription(description).setMacTimeout(macTimeout)
 281                         .setKey(new ElanInstanceKey(elanInstanceName)).build();
 282                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 283                         ElanUtils.getElanInstanceConfigurationDataPath(elanInstanceName), updateElanInstance);
 284                 logger.debug("Updating the Elan Instance {} with MAC TIME-OUT %l and Description %s ",
 285                         updateElanInstance, macTimeout, description);
 286             }
 287         } else {
 288             ElanInstance elanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
 289                     .setMacTimeout(macTimeout).setDescription(description).setKey(new ElanInstanceKey(elanInstanceName))
 290                     .build();
 291             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 292                     ElanUtils.getElanInstanceConfigurationDataPath(elanInstanceName), elanInstance);
 293             logger.debug("Creating the new Elan Instance {}", elanInstance);
 294         }
 295         return isSuccess;
 296     }
 297
 298     public static boolean compareWithExistingElanInstance(ElanInstance existingElanInstance, long macTimeOut,
 299             String description) {
 300         boolean isEqual = false;
 301         if (existingElanInstance.getMacTimeout() == macTimeOut
 302                 && existingElanInstance.getDescription().equals(description)) {
 303             isEqual = true;
 304         }
 305         return isEqual;
 306     }
 307
 308     @Override
 309     public void updateElanInstance(String elanInstanceName, long newMacTimout, String newDescription) {
 310         createElanInstance(elanInstanceName, newMacTimout, newDescription);
 311     }
 312
 313     @Override
 314     public boolean deleteElanInstance(String elanInstanceName) {
 315         boolean isSuccess = false;
 316         ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
 317         if (existingElanInstance == null) {
 318             logger.debug("Elan Instance is not present {}", existingElanInstance);
 319             return isSuccess;
 320         }
 321         logger.debug("Deletion of the existing Elan Instance {}", existingElanInstance);
 322         ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
 323                 ElanUtils.getElanInstanceConfigurationDataPath(elanInstanceName));
 324         isSuccess = true;
 325         return isSuccess;
 326     }
 327
 328     @Override
 329     public void addElanInterface(String elanInstanceName, String interfaceName, List<String> staticMacAddresses,
 330             String description) {
 331         ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
 332         if (existingElanInstance != null) {
 333             ElanInterface elanInterface;
 334             if (staticMacAddresses == null) {
 335                 elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 336                         .setDescription(description).setName(interfaceName).setKey(new ElanInterfaceKey(interfaceName))
 337                         .build();
 338             } else {
 339                 elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 340                         .setDescription(description).setName(interfaceName)
 341                         .setStaticMacEntries(getPhysAddress(staticMacAddresses))
 342                         .setKey(new ElanInterfaceKey(interfaceName)).build();
 343             }
 344             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 345                     ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName), elanInterface);
 346             logger.debug("Creating the new ELan Interface {}", elanInterface);
 347         }
 348
 349     }
 350
 351     @Override
 352     public void updateElanInterface(String elanInstanceName, String interfaceName,
 353             List<String> updatedStaticMacAddresses, String newDescription) {
 354         ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
 355         if (existingElanInterface == null) {
 356             return;
 357         }
 358         List<PhysAddress> existingMacAddress = existingElanInterface.getStaticMacEntries();
 359         List<PhysAddress> updatedMacAddresses = getPhysAddress(updatedStaticMacAddresses);
 360         List<PhysAddress> updatedPhysAddress = getUpdatedPhyAddress(existingMacAddress, updatedMacAddresses);
 361         if (updatedPhysAddress.size() > 0) {
 362             logger.debug("updating the ElanInterface with new Mac Entries {}", updatedStaticMacAddresses);
 363             ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 364                     .setName(interfaceName).setDescription(newDescription).setStaticMacEntries(updatedPhysAddress)
 365                     .setKey(new ElanInterfaceKey(interfaceName)).build();
 366             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 367                     ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName), elanInterface);
 368         }
 369     }
 370
 371     @Override
 372     public void deleteElanInterface(String elanInstanceName, String interfaceName) {
 373         ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
 374         if (existingElanInterface != null) {
 375             ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
 376                     ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName));
 377             logger.debug("deleting the Elan Interface {}", existingElanInterface);
 378         }
 379     }
 380
 381     @Override
 382     public void addStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress) {
 383         ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
 384         PhysAddress updateStaticMacAddress = new PhysAddress(macAddress);
 385         if (existingElanInterface != null) {
 386             List<PhysAddress> existingMacAddress = existingElanInterface.getStaticMacEntries();
 387             if (existingMacAddress.contains(updateStaticMacAddress)) {
 388                 return;
 389             }
 390             existingMacAddress.add(updateStaticMacAddress);
 391             ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 392                     .setName(interfaceName).setStaticMacEntries(existingMacAddress)
 393                     .setDescription(existingElanInterface.getDescription()).setKey(new ElanInterfaceKey(interfaceName))
 394                     .build();
 395             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 396                     ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName), elanInterface);
 397         }
 398     }
 399
 400     @Override
 401     public void deleteStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress)
 402             throws MacNotFoundException {
 403         ElanInterface existingElanInterface = ElanUtils.getElanInterfaceByElanInterfaceName(interfaceName);
 404         PhysAddress physAddress = new PhysAddress(macAddress);
 405         if (existingElanInterface == null) {
 406             return;
 407         }
 408         List<PhysAddress> existingMacAddress = existingElanInterface.getStaticMacEntries();
 409         if (existingMacAddress.contains(physAddress)) {
 410             existingMacAddress.remove(physAddress);
 411             ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 412                     .setName(interfaceName).setStaticMacEntries(existingMacAddress)
 413                     .setDescription(existingElanInterface.getDescription()).setKey(new ElanInterfaceKey(interfaceName))
 414                     .build();
 415             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
 416                     ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName), elanInterface);
 417         } else {
 418             throw new MacNotFoundException("Mac Not Found Exception");
 419         }
 420     }
 421
 422     @Override
 423     public Collection<MacEntry> getElanMacTable(String elanInstanceName) {
 424         Elan elanInfo = ElanUtils.getElanByName(elanInstanceName);
 425         List<MacEntry> macAddress = new ArrayList<>();
 426         if (elanInfo == null) {
 427             return macAddress;
 428         }
 429         List<String> elanInterfaces = elanInfo.getElanInterfaces();
 430         if (elanInterfaces != null && elanInterfaces.size() > 0) {
 431             for (String elanInterface : elanInterfaces) {
 432                 ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
 433                 if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null
 434                         && elanInterfaceMac.getMacEntry().size() > 0) {
 435                     macAddress.addAll(elanInterfaceMac.getMacEntry());
 436                 }
 437             }
 438         }
 439         return macAddress;
 440     }
 441
 442     @Override
 443     public void flushMACTable(String elanInstanceName) {
 444         Elan elanInfo = ElanUtils.getElanByName(elanInstanceName);
 445         if (elanInfo == null) {
 446             return;
 447         }
 448         List<String> elanInterfaces = elanInfo.getElanInterfaces();
 449         if (elanInterfaces == null || elanInterfaces.isEmpty()) {
 450             return;
 451         }
 452         for (String elanInterface : elanInterfaces) {
 453             ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
 454             if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
 455                 List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
 456                 for (MacEntry macEntry : macEntries) {
 457                     try {
 458                         deleteStaticMacAddress(elanInstanceName, elanInterface, macEntry.getMacAddress().getValue());
 459                     } catch (MacNotFoundException e) {
 460                         logger.error("Mac Not Found Exception {}", e);
 461                         e.printStackTrace();
 462                     }
 463                 }
 464             }
 465         }
 466
 467     }
 468
 469     @Override
 470     public void close() throws Exception {
 471         this.elanInstanceManager.close();
 472         this.elanL2GatewayProvider.close();
 473     }
 474
 475     public static List<PhysAddress> getPhysAddress(List<String> macAddress) {
 476         List<PhysAddress> physAddresses = new ArrayList<>();
 477         for (String mac : macAddress) {
 478             physAddresses.add(new PhysAddress(mac));
 479         }
 480         return physAddresses;
 481     }
 482
 483     public List<PhysAddress> getUpdatedPhyAddress(List<PhysAddress> originalAddresses,
 484             List<PhysAddress> updatePhyAddresses) {
 485         if (updatePhyAddresses != null && !updatePhyAddresses.isEmpty()) {
 486             List<PhysAddress> existingClonedPhyAddress = new ArrayList<>();
 487             if (originalAddresses != null && !originalAddresses.isEmpty()) {
 488                 existingClonedPhyAddress.addAll(0, originalAddresses);
 489                 originalAddresses.removeAll(updatePhyAddresses);
 490                 updatePhyAddresses.removeAll(existingClonedPhyAddress);
 491             }
 492         }
 493         return updatePhyAddresses;
 494     }
 495
 496     @Override
 497     public ElanInstance getElanInstance(String elanName) {
 498         return ElanUtils.getElanInstanceByName(elanName);
 499     }
 500
 501     @Override
 502     public List<ElanInstance> getElanInstances() {
 503         List<ElanInstance> elanList = new ArrayList<ElanInstance>();
 504         InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
 505                 .build();
 506         Optional<ElanInstances> elansOptional = ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 507                 elanInstancesIdentifier);
 508         if (elansOptional.isPresent()) {
 509             elanList.addAll(elansOptional.get().getElanInstance());
 510         }
 511         return elanList;
 512     }
 513
 514     @Override
 515     public List<String> getElanInterfaces(String elanInstanceName) {
 516         List<String> elanInterfaces = new ArrayList<>();
 517         InstanceIdentifier<ElanInterfaces> elanInterfacesIdentifier = InstanceIdentifier.builder(ElanInterfaces.class)
 518                 .build();
 519         Optional<ElanInterfaces> elanInterfacesOptional = ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 520                 elanInterfacesIdentifier);
 521         if (!elanInterfacesOptional.isPresent()) {
 522             return elanInterfaces;
 523         }
 524         List<ElanInterface> elanInterfaceList = elanInterfacesOptional.get().getElanInterface();
 525         for (ElanInterface elanInterface : elanInterfaceList) {
 526             if (elanInterface.getElanInstanceName().equals(elanInstanceName)) {
 527                 elanInterfaces.add(elanInterface.getName());
 528             }
 529         }
 530         return elanInterfaces;
 531     }
 532 }