interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/InterfacemgrProvider.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 package org.opendaylight.genius.interfacemanager;
   9
  10
  11 import com.google.common.base.Optional;
  12 import java.math.BigInteger;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.Future;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  19 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  22 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  23 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
  24 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  25 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
  26 import org.opendaylight.genius.interfacemanager.exceptions.InterfaceAlreadyExistsException;
  27 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
  28 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceAdminState;
  29 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  30 import org.opendaylight.genius.interfacemanager.listeners.AlivenessMonitorListener;
  31 import org.opendaylight.genius.interfacemanager.listeners.CacheInterfaceConfigListener;
  32 import org.opendaylight.genius.interfacemanager.listeners.CacheInterfaceStateListener;
  33 import org.opendaylight.genius.interfacemanager.listeners.HwVTEPConfigListener;
  34 import org.opendaylight.genius.interfacemanager.listeners.HwVTEPTunnelsStateListener;
  35 import org.opendaylight.genius.interfacemanager.listeners.InterfaceConfigListener;
  36 import org.opendaylight.genius.interfacemanager.listeners.InterfaceInventoryStateListener;
  37 import org.opendaylight.genius.interfacemanager.listeners.InterfaceTopologyStateListener;
  38 import org.opendaylight.genius.interfacemanager.listeners.TerminationPointStateListener;
  39 import org.opendaylight.genius.interfacemanager.listeners.VlanMemberConfigListener;
  40 import org.opendaylight.genius.interfacemanager.pmcounters.NodeConnectorStatsImpl;
  41 import org.opendaylight.genius.interfacemanager.rpcservice.InterfaceManagerRpcService;
  42 import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.listeners.FlowBasedServicesConfigListener;
  43 import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.listeners.FlowBasedServicesInterfaceStateListener;
  44 import org.opendaylight.genius.interfacemanager.statusanddiag.InterfaceStatusMonitor;
  45 import org.opendaylight.genius.mdsalutil.ActionInfo;
  46 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnInput;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnInputBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnOutput;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesKey;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService;
  83 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  84 import org.opendaylight.yangtools.yang.common.RpcResult;
  85 import org.slf4j.Logger;
  86 import org.slf4j.LoggerFactory;
  87
  88
  89 public class InterfacemgrProvider implements BindingAwareProvider, AutoCloseable, IInterfaceManager {
  90
  91     private static final Logger LOG = LoggerFactory.getLogger(InterfacemgrProvider.class);
  92     private static final InterfaceStatusMonitor interfaceStatusMonitor = InterfaceStatusMonitor.getInstance();
  93
  94     private RpcProviderRegistry rpcProviderRegistry;
  95     private IdManagerService idManager;
  96     private NotificationService notificationService;
  97     private AlivenessMonitorService alivenessManager;
  98     private IMdsalApiManager mdsalManager;
  99     private InterfaceConfigListener interfaceConfigListener;
 100     private InterfaceTopologyStateListener topologyStateListener;
 101     private TerminationPointStateListener terminationPointStateListener;
 102     private HwVTEPTunnelsStateListener hwVTEPTunnelsStateListener;
 103     private InterfaceInventoryStateListener interfaceInventoryStateListener;
 104     private FlowBasedServicesInterfaceStateListener flowBasedServicesInterfaceStateListener;
 105     private FlowBasedServicesConfigListener flowBasedServicesConfigListener;
 106     private VlanMemberConfigListener vlanMemberConfigListener;
 107     private HwVTEPConfigListener hwVTEPConfigListener;
 108     private AlivenessMonitorListener alivenessMonitorListener;
 109     private DataBroker dataBroker;
 110     private InterfaceManagerRpcService interfaceManagerRpcService;
 111     private BindingAwareBroker.RpcRegistration<OdlInterfaceRpcService> rpcRegistration;
 112     private NodeConnectorStatsImpl nodeConnectorStatsManager;
 113     private CacheInterfaceConfigListener cacheInterfaceConfigListener;
 114     private CacheInterfaceStateListener cacheInterfaceStateListener;
 115
 116     public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) {
 117         this.rpcProviderRegistry = rpcProviderRegistry;
 118         interfaceStatusMonitor.registerMbean();
 119     }
 120
 121     public void setMdsalManager(IMdsalApiManager mdsalManager) {
 122         this.mdsalManager = mdsalManager;
 123     }
 124
 125     public void setNotificationService(NotificationService notificationService) {
 126         this.notificationService = notificationService;
 127     }
 128
 129     public DataBroker getDataBroker(){
 130         return this.dataBroker;
 131     }
 132
 133     @Override
 134     public void onSessionInitiated(ProviderContext session) {
 135         LOG.info("InterfacemgrProvider Session Initiated");
 136         interfaceStatusMonitor.reportStatus("STARTING");
 137         try {
 138             dataBroker = session.getSALService(DataBroker.class);
 139             idManager = rpcProviderRegistry.getRpcService(IdManagerService.class);
 140             createIdPool();
 141
 142             alivenessManager = rpcProviderRegistry.getRpcService(AlivenessMonitorService.class);
 143             interfaceManagerRpcService = new InterfaceManagerRpcService(dataBroker, mdsalManager);
 144             rpcRegistration = getRpcProviderRegistry().addRpcImplementation(
 145                     OdlInterfaceRpcService.class, interfaceManagerRpcService);
 146
 147             interfaceConfigListener = new InterfaceConfigListener(dataBroker, idManager, alivenessManager, mdsalManager);
 148             interfaceConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 149
 150             interfaceInventoryStateListener = new InterfaceInventoryStateListener(dataBroker, idManager, mdsalManager, alivenessManager);
 151             interfaceInventoryStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 152
 153             topologyStateListener = new InterfaceTopologyStateListener(dataBroker);
 154             topologyStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 155
 156             hwVTEPTunnelsStateListener = new HwVTEPTunnelsStateListener(dataBroker);
 157             hwVTEPTunnelsStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 158
 159             terminationPointStateListener = new TerminationPointStateListener(dataBroker);
 160             terminationPointStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 161
 162             flowBasedServicesConfigListener = new FlowBasedServicesConfigListener(this);
 163             flowBasedServicesConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 164
 165             flowBasedServicesInterfaceStateListener =
 166                     new FlowBasedServicesInterfaceStateListener(dataBroker);
 167             flowBasedServicesInterfaceStateListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
 168
 169             vlanMemberConfigListener =
 170                     new VlanMemberConfigListener(dataBroker, idManager, alivenessManager, mdsalManager);
 171             vlanMemberConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 172
 173             hwVTEPConfigListener = new HwVTEPConfigListener(dataBroker);
 174             hwVTEPConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
 175
 176             alivenessMonitorListener = new org.opendaylight.genius.interfacemanager.listeners.AlivenessMonitorListener(dataBroker);
 177             notificationService.registerNotificationListener(alivenessMonitorListener);
 178
 179             cacheInterfaceConfigListener = new CacheInterfaceConfigListener(dataBroker);
 180
 181             cacheInterfaceStateListener = new CacheInterfaceStateListener(dataBroker);
 182
 183             //Initialize nodeconnectorstatsimpl
 184             nodeConnectorStatsManager = new NodeConnectorStatsImpl(dataBroker, notificationService,
 185                     session.getRpcService(OpendaylightPortStatisticsService.class), session.getRpcService(OpendaylightFlowTableStatisticsService.class));
 186
 187
 188             interfaceStatusMonitor.reportStatus("OPERATIONAL");
 189         } catch (Exception e) {
 190             LOG.error("Error initializing services", e);
 191             interfaceStatusMonitor.reportStatus("ERROR");
 192         }
 193     }
 194
 195     private void createIdPool() {
 196         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
 197                 .setPoolName(IfmConstants.IFM_IDPOOL_NAME)
 198                 .setLow(IfmConstants.IFM_ID_POOL_START)
 199                 .setHigh(IfmConstants.IFM_ID_POOL_END)
 200                 .build();
 201         //TODO: Error handling
 202         Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
 203         try {
 204             if ((result != null) && (result.get().isSuccessful())) {
 205                 LOG.debug("Created IdPool for InterfaceMgr");
 206             }
 207         } catch (InterruptedException | ExecutionException e) {
 208             LOG.error("Failed to create idPool for InterfaceMgr", e);
 209         }
 210     }
 211
 212     @Override
 213     public void close() throws Exception {
 214         LOG.info("InterfacemgrProvider Closed");
 215         interfaceConfigListener.close();
 216         rpcRegistration.close();
 217         cacheInterfaceConfigListener.close();
 218         cacheInterfaceStateListener.close();
 219     }
 220
 221     public RpcProviderRegistry getRpcProviderRegistry() {
 222         return rpcProviderRegistry;
 223     }
 224
 225     @Override
 226     public Long getPortForInterface(String ifName) {
 227         GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(ifName).build();
 228         Future<RpcResult<GetPortFromInterfaceOutput>> output = interfaceManagerRpcService.getPortFromInterface(input);
 229         try {
 230             RpcResult<GetPortFromInterfaceOutput> port = output.get();
 231             if (port.isSuccessful()) {
 232                 return port.getResult().getPortno();
 233             }
 234         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 235             LOG.warn("Exception when getting port for interface", e);
 236         }
 237         return null;
 238     }
 239
 240     @Override
 241     public Long getPortForInterface(Interface intf) {
 242         GetPortFromInterfaceInput input = new GetPortFromInterfaceInputBuilder().setIntfName(intf.getName()).build();
 243         Future<RpcResult<GetPortFromInterfaceOutput>> output = interfaceManagerRpcService.getPortFromInterface(input);
 244         try {
 245             RpcResult<GetPortFromInterfaceOutput> port = output.get();
 246             if (port.isSuccessful()) {
 247                 return port.getResult().getPortno();
 248             }
 249         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 250             LOG.warn("Exception when getting port for interface", e);
 251         }
 252         return null;
 253     }
 254
 255     @Override
 256     public InterfaceInfo getInterfaceInfo(String interfaceName) {
 257
 258         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface
 259                 ifState = InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName, dataBroker);
 260
 261         if (ifState == null) {
 262             LOG.error("Interface {} is not present", interfaceName);
 263             return null;
 264         }
 265
 266         Integer lportTag = ifState.getIfIndex();
 267         Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker);
 268         if (intf == null) {
 269             LOG.error("Interface {} doesn't exist in config datastore", interfaceName);
 270             return null;
 271         }
 272
 273         NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(intf.getName(), dataBroker);
 274         InterfaceInfo.InterfaceType interfaceType = IfmUtil.getInterfaceType(intf);
 275         InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName);
 276         BigInteger dpId = org.opendaylight.genius.interfacemanager.globals.IfmConstants.INVALID_DPID;
 277         Integer portNo = org.opendaylight.genius.interfacemanager.globals.IfmConstants.INVALID_PORT_NO;
 278         if (ncId != null) {
 279             dpId = new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId));
 280             portNo = Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId));
 281         }
 282         if (interfaceType == InterfaceInfo.InterfaceType.VLAN_INTERFACE) {
 283             interfaceInfo = IfmUtil.getVlanInterfaceInfo(interfaceName, intf, dpId);
 284         } else if (interfaceType == InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE ||
 285                 interfaceType == InterfaceInfo.InterfaceType.GRE_TRUNK_INTERFACE) {
 286             // TODO : since there is no logical grouping for tunnel interfaces, there is no need
 287             // for this code as of now. will be revisited once the support comes
 288
 289         } else {
 290             LOG.error("Type of Interface {} is unknown", interfaceName);
 291             return null;
 292         }
 293         interfaceInfo.setDpId(dpId);
 294         interfaceInfo.setPortNo(portNo);
 295         interfaceInfo.setAdminState((intf.isEnabled() == true) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED);
 296         interfaceInfo.setInterfaceName(interfaceName);
 297         interfaceInfo.setInterfaceTag(lportTag);
 298         interfaceInfo.setInterfaceType(interfaceType);
 299         interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType));
 300         interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN);
 301
 302
 303         return interfaceInfo;
 304
 305     }
 306
 307     @Override
 308     public InterfaceInfo getInterfaceInfoFromOperationalDataStore(String interfaceName, InterfaceInfo.InterfaceType interfaceType) {
 309         InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName);
 310         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = InterfaceManagerCommonUtils
 311                 .getInterfaceStateFromOperDS(interfaceName, dataBroker);
 312         if (ifState == null) {
 313             LOG.error("Interface {} is not present", interfaceName);
 314             return null;
 315         }
 316         Integer lportTag = ifState.getIfIndex();
 317         NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(ifState);
 318         if (ncId != null) {
 319             interfaceInfo.setDpId(new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId)));
 320             interfaceInfo.setPortNo(Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId)));
 321         }
 322         interfaceInfo.setAdminState((ifState.getAdminStatus() == AdminStatus.Up) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED);
 323         interfaceInfo.setInterfaceName(interfaceName);
 324         interfaceInfo.setInterfaceTag(lportTag);
 325         interfaceInfo.setInterfaceType(interfaceType);
 326         interfaceInfo.setGroupId(IfmUtil.getGroupId(lportTag, interfaceType));
 327         interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Up) ? InterfaceInfo.InterfaceOpState.UP : InterfaceInfo.InterfaceOpState.DOWN);
 328
 329
 330         return interfaceInfo;
 331     }
 332
 333     @Override
 334     public InterfaceInfo getInterfaceInfoFromOperationalDataStore(String interfaceName) {
 335         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = InterfaceManagerCommonUtils
 336                 .getInterfaceStateFromOperDS(interfaceName, dataBroker);
 337         if (ifState == null) {
 338             LOG.error("Interface {} is not present", interfaceName);
 339             return null;
 340         }
 341         Integer lportTag = ifState.getIfIndex();
 342         InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName);
 343         NodeConnectorId ncId = IfmUtil.getNodeConnectorIdFromInterface(ifState);
 344         if (ncId != null) {
 345             interfaceInfo.setPortName(IfmUtil.getPortName(dataBroker, ncId));
 346             interfaceInfo.setDpId(new BigInteger(IfmUtil.getDpnFromNodeConnectorId(ncId)));
 347             interfaceInfo.setPortNo(Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId)));
 348         }
 349         interfaceInfo.setAdminState((ifState.getAdminStatus() == AdminStatus.Up) ? InterfaceAdminState.ENABLED : InterfaceAdminState.DISABLED);
 350         interfaceInfo.setInterfaceName(interfaceName);
 351         interfaceInfo.setInterfaceTag(lportTag);
 352         interfaceInfo.setOpState((ifState.getOperStatus() == OperStatus.Down) ? InterfaceInfo.InterfaceOpState.DOWN :
 353                 ifState.getOperStatus() == OperStatus.Unknown ? InterfaceInfo.InterfaceOpState.UNKNOWN : InterfaceInfo.InterfaceOpState.UP);
 354         return interfaceInfo;
 355     }
 356
 357     @Override
 358     public Interface getInterfaceInfoFromConfigDataStore(String interfaceName) {
 359         Interface intf = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker);
 360         return intf;
 361     }
 362
 363     @Override
 364     public void createVLANInterface(String interfaceName, String portName, BigInteger dpId, Integer vlanId,
 365                                     String description, IfL2vlan.L2vlanMode l2vlanMode) throws InterfaceAlreadyExistsException {
 366
 367         LOG.info("Create VLAN interface : {}", interfaceName);
 368         InstanceIdentifier<Interface> interfaceInstanceIdentifier = InterfaceManagerCommonUtils.getInterfaceIdentifier(new InterfaceKey(interfaceName));
 369         Interface interfaceOptional = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName), dataBroker);
 370         if (interfaceOptional != null) {
 371             LOG.debug("VLAN interface is already exist", interfaceOptional.getDescription());
 372             throw new InterfaceAlreadyExistsException(interfaceOptional.getName());
 373         }
 374         IfL2vlanBuilder l2vlanBuilder = new IfL2vlanBuilder().setL2vlanMode(l2vlanMode);
 375         if (vlanId > 0) {
 376             l2vlanBuilder.setVlanId(new VlanId(vlanId));
 377         }
 378         ParentRefs parentRefs = new ParentRefsBuilder().setParentInterface(portName).build();
 379         Interface inf = new InterfaceBuilder().setEnabled(true).setName(interfaceName).setType(L2vlan.class).
 380                 addAugmentation(IfL2vlan.class, l2vlanBuilder.build()).addAugmentation(ParentRefs.class, parentRefs).
 381                 setDescription(description).build();
 382         WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 383         t.put(LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier, inf, true);
 384     }
 385
 386     @Override
 387     public void bindService(String interfaceName, BoundServices serviceInfo) {
 388         LOG.info("Binding Service : {}", interfaceName);
 389         WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 390         InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = InstanceIdentifier.builder(ServiceBindings.class)
 391                 .child(ServicesInfo.class, new ServicesInfoKey(interfaceName, ServiceModeIngress.class))
 392                 .child(BoundServices.class, new BoundServicesKey(serviceInfo.getServicePriority())).build();
 393         t.put(LogicalDatastoreType.CONFIGURATION, boundServicesInstanceIdentifier, serviceInfo, true);
 394         t.submit();
 395     }
 396
 397     @Override
 398     public void unbindService(String interfaceName, BoundServices serviceInfo) {
 399         LOG.info("Unbinding Service  : {}", interfaceName);
 400         WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 401         InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = InstanceIdentifier.builder(ServiceBindings.class)
 402                 .child(ServicesInfo.class, new ServicesInfoKey(interfaceName, ServiceModeIngress.class))
 403                 .child(BoundServices.class, new BoundServicesKey(serviceInfo.getServicePriority())).build();
 404         t.delete(LogicalDatastoreType.CONFIGURATION, boundServicesInstanceIdentifier);
 405         t.submit();
 406     }
 407
 408     @Override
 409     public BigInteger getDpnForInterface(String ifName) {
 410         GetDpidFromInterfaceInput input = new GetDpidFromInterfaceInputBuilder().setIntfName(ifName).build();
 411         Future<RpcResult<GetDpidFromInterfaceOutput>> output = interfaceManagerRpcService.getDpidFromInterface(input);
 412         try {
 413             RpcResult<GetDpidFromInterfaceOutput> dpn = output.get();
 414             if (dpn.isSuccessful()) {
 415                 return dpn.getResult().getDpid();
 416             }
 417         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 418             LOG.warn("Exception when getting port for interface", e);
 419         }
 420         return null;
 421     }
 422
 423     @Override
 424     public String getEndpointIpForDpn(BigInteger dpnId) {
 425         GetEndpointIpForDpnInput input = new GetEndpointIpForDpnInputBuilder().setDpid(dpnId).build();
 426         Future<RpcResult<GetEndpointIpForDpnOutput>> output = interfaceManagerRpcService.getEndpointIpForDpn(input);
 427         try {
 428             RpcResult<GetEndpointIpForDpnOutput> ipForDpnOutputRpcResult = output.get();
 429             if (ipForDpnOutputRpcResult.isSuccessful()) {
 430                 List<IpAddress> localIps = ipForDpnOutputRpcResult.getResult().getLocalIps();
 431                 if (!localIps.isEmpty()) {
 432                     return localIps.get(0).getIpv4Address().getValue();
 433                 }
 434             }
 435         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 436             LOG.warn("Exception when getting port for interface", e);
 437         }
 438         return null;
 439     }
 440
 441     @Override
 442     public List<ActionInfo> getInterfaceEgressActions(String ifName) {
 443         return IfmUtil.getEgressActionInfosForInterface(ifName, 0, dataBroker);
 444     }
 445
 446     @Override
 447     public BigInteger getDpnForInterface(Interface intrf) {
 448         return getDpnForInterface(intrf.getName());
 449     }
 450
 451     @Override
 452     public List<Interface> getVlanInterfaces() {
 453         List<Interface> vlanList = new ArrayList<>();
 454         InstanceIdentifier<Interfaces> interfacesInstanceIdentifier = InstanceIdentifier.builder(Interfaces.class).build();
 455         Optional<Interfaces> interfacesOptional = IfmUtil.read(LogicalDatastoreType.CONFIGURATION, interfacesInstanceIdentifier, dataBroker);
 456         if (!interfacesOptional.isPresent()) {
 457             return vlanList;
 458         }
 459         Interfaces interfaces = interfacesOptional.get();
 460         List<Interface> interfacesList = interfaces.getInterface();
 461         for (Interface iface : interfacesList) {
 462             if (IfmUtil.getInterfaceType(iface) == InterfaceInfo.InterfaceType.VLAN_INTERFACE) {
 463                 vlanList.add(iface);
 464             }
 465         }
 466         return vlanList;
 467     }
 468
 469     @Override
 470     public List<Interface> getVxlanInterfaces() {
 471         return InterfaceManagerCommonUtils.getAllTunnelInterfaces(dataBroker,
 472                 InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE);
 473     }
 474 }