interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/rpcservice/InterfaceManagerRpcService.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.genius.interfacemanager.rpcservice;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import com.google.common.util.concurrent.SettableFuture;
  16 import java.math.BigInteger;
  17 import java.util.ArrayList;
  18 import java.util.Collections;
  19 import java.util.List;
  20 import java.util.concurrent.Future;
  21 import java.util.stream.Collectors;
  22 import javax.inject.Inject;
  23 import javax.inject.Singleton;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.genius.interfacemanager.IfmConstants;
  27 import org.opendaylight.genius.interfacemanager.IfmUtil;
  28 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
  29 import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
  30 import org.opendaylight.genius.mdsalutil.InstructionInfo;
  31 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  32 import org.opendaylight.genius.mdsalutil.MatchFieldType;
  33 import org.opendaylight.genius.mdsalutil.MatchInfo;
  34 import org.opendaylight.genius.mdsalutil.NwConstants;
  35 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.DpnToInterfaceList;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterface;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterfaceKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntry;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.CreateTerminatingServiceActionsInput;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutputBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListOutput;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListOutputBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInput;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutputBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceInput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceOutput;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceOutputBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnInput;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnOutput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnOutputBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutputBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeInput;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeOutput;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeOutputBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutputBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInput;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutputBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeInput;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeOutput;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeOutputBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  90 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  91 import org.opendaylight.yangtools.yang.common.RpcError;
  92 import org.opendaylight.yangtools.yang.common.RpcResult;
  93 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  94 import org.slf4j.Logger;
  95 import org.slf4j.LoggerFactory;
  96
  97 @Singleton
  98 public class InterfaceManagerRpcService implements OdlInterfaceRpcService {
  99
 100     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManagerRpcService.class);
 101
 102     private final DataBroker dataBroker;
 103     private final IMdsalApiManager mdsalMgr;
 104
 105     @Inject
 106     public InterfaceManagerRpcService(DataBroker dataBroker, IMdsalApiManager mdsalMgr) {
 107         this.dataBroker = dataBroker;
 108         this.mdsalMgr = mdsalMgr;
 109     }
 110
 111     @Override
 112     public Future<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(GetDpidFromInterfaceInput input) {
 113         String interfaceName = input.getIntfName();
 114         RpcResultBuilder<GetDpidFromInterfaceOutput> rpcResultBuilder;
 115         try {
 116             BigInteger dpId = null;
 117             InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 118             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 119             if (interfaceInfo == null) {
 120                 rpcResultBuilder = getRpcErrorResultForGetDpnIdRpc(interfaceName, "missing Interface in Config DataStore");
 121                 return Futures.immediateFuture(rpcResultBuilder.build());
 122             }
 123             if (Tunnel.class.equals(interfaceInfo.getType())) {
 124                 ParentRefs parentRefs = interfaceInfo.getAugmentation(ParentRefs.class);
 125                 dpId = parentRefs.getDatapathNodeIdentifier();
 126             } else {
 127                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
 128                         InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName, dataBroker);
 129                 if (ifState != null) {
 130                     String lowerLayerIf = ifState.getLowerLayerIf().get(0);
 131                     NodeConnectorId nodeConnectorId = new NodeConnectorId(lowerLayerIf);
 132                     dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
 133                 } else {
 134                      rpcResultBuilder = getRpcErrorResultForGetDpnIdRpc(interfaceName, "missing Interface-state");
 135                      return Futures.immediateFuture(rpcResultBuilder.build());
 136                 }
 137             }
 138             GetDpidFromInterfaceOutputBuilder output = new GetDpidFromInterfaceOutputBuilder().setDpid(
 139                     dpId);
 140             rpcResultBuilder = RpcResultBuilder.success();
 141             rpcResultBuilder.withResult(output.build());
 142         } catch (Exception e) {
 143             rpcResultBuilder = getRpcErrorResultForGetDpnIdRpc(interfaceName, e.getMessage());
 144         }
 145         return Futures.immediateFuture(rpcResultBuilder.build());
 146     }
 147
 148     private RpcResultBuilder<GetDpidFromInterfaceOutput> getRpcErrorResultForGetDpnIdRpc(String interfaceName, String errMsg) {
 149         errMsg = String.format("Retrieval of datapath id for the key {%s} failed due to %s", interfaceName, errMsg);
 150         LOG.error(errMsg);
 151         RpcResultBuilder<GetDpidFromInterfaceOutput> rpcResultBuilder = RpcResultBuilder.<GetDpidFromInterfaceOutput>failed().withError(RpcError.ErrorType.APPLICATION, errMsg);
 152         return rpcResultBuilder;
 153     }
 154
 155     @Override
 156     public Future<RpcResult<Void>> createTerminatingServiceActions(final CreateTerminatingServiceActionsInput input) {
 157         final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
 158         try{
 159             LOG.info("create terminatingServiceAction on DpnId = {} for tunnel-key {}", input.getDpid() , input.getTunnelKey());
 160             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(input.getInterfaceName()),dataBroker);
 161             IfTunnel tunnelInfo = interfaceInfo.getAugmentation(IfTunnel.class);
 162             if(tunnelInfo != null) {
 163                 ListenableFuture<Void> installFlowResult =tunnelInfo.getTunnelInterfaceType().isAssignableFrom(TunnelTypeMplsOverGre.class)?
 164                         makeLFIBFlow(input.getDpid(),input.getTunnelKey(), input.getInstruction(), NwConstants.ADD_FLOW) :
 165                         makeTerminatingServiceFlow(tunnelInfo, input.getDpid(), input.getTunnelKey(), input.getInstruction(), NwConstants.ADD_FLOW);
 166                 Futures.addCallback(installFlowResult, new FutureCallback<Void>(){
 167
 168                     @Override
 169                     public void onSuccess(Void aVoid) {
 170                         result.set(RpcResultBuilder.<Void>success().build());
 171                     }
 172
 173                     @Override
 174                     public void onFailure(Throwable error) {
 175                         String msg = String.format("Unable to install terminating service flow for %s", input.getInterfaceName());
 176                         LOG.error("create terminating service actions failed. {}. {}", msg, error);
 177                         result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error).build());
 178                     }
 179                 });
 180                 result.set(RpcResultBuilder.<Void>success().build());
 181             } else {
 182                 String msg = String.format("Terminating Service Actions cannot be created for a non-tunnel interface %s",input.getInterfaceName());
 183                 LOG.error(msg);
 184                 result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg).build());
 185             }
 186         }catch(Exception e){
 187             String msg = String.format("create Terminating Service Actions for %s failed",input.getInterfaceName());
 188             LOG.error("create Terminating Service Actions for {} failed due to {}" ,input.getDpid(), e);
 189             result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, e.getMessage()).build());
 190         }
 191         return result;
 192     }
 193
 194     @Override
 195     public Future<RpcResult<Void>> removeTerminatingServiceActions(final RemoveTerminatingServiceActionsInput input) {
 196         final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
 197         try{
 198             dataBroker.newWriteOnlyTransaction();
 199             LOG.info("remove terminatingServiceAction on DpnId = {} for tunnel-key {}", input.getDpid() , input.getTunnelKey());
 200
 201             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(input.getInterfaceName()),dataBroker);
 202             IfTunnel tunnelInfo = interfaceInfo.getAugmentation(IfTunnel.class);
 203             if(tunnelInfo != null) {
 204                 ListenableFuture<Void> removeFlowResult = tunnelInfo.getTunnelInterfaceType().isAssignableFrom(TunnelTypeMplsOverGre.class)?
 205                         makeLFIBFlow(input.getDpid(),input.getTunnelKey(), null, NwConstants.DEL_FLOW) :
 206                         makeTerminatingServiceFlow(tunnelInfo, input.getDpid(), input.getTunnelKey(), null, NwConstants.DEL_FLOW);
 207                 Futures.addCallback(removeFlowResult, new FutureCallback<Void>(){
 208
 209                     @Override
 210                     public void onSuccess(Void aVoid) {
 211                         result.set(RpcResultBuilder.<Void>success().build());
 212                     }
 213
 214                     @Override
 215                     public void onFailure(Throwable error) {
 216                         String msg = String.format("Unable to install terminating service flow %s", input.getInterfaceName());
 217                         LOG.error("create terminating service actions failed. {}. {}", msg, error);
 218                         result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error).build());
 219                     }
 220                 });
 221                 result.set(RpcResultBuilder.<Void>success().build());
 222             } else {
 223                 String msg = String.format("Terminating Service Actions cannot be removed for a non-tunnel interface %s",
 224                         input.getInterfaceName());
 225                 LOG.error(msg);
 226                 result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg).build());
 227             }
 228         }catch(Exception e){
 229             LOG.error("Remove Terminating Service Actions for {} failed due to {}" ,input.getDpid(), e);
 230             String msg = String.format("Remove Terminating Service Actions for %d failed.", input.getDpid());
 231             result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, e.getMessage()).build());
 232         }
 233         return result;
 234     }
 235
 236     @Override
 237     public Future<RpcResult<GetEndpointIpForDpnOutput>> getEndpointIpForDpn(GetEndpointIpForDpnInput input) {
 238         RpcResultBuilder<GetEndpointIpForDpnOutput> rpcResultBuilder;
 239         try {
 240             BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(input.getDpid());
 241             InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier =
 242                     InterfaceMetaUtils.getBridgeEntryIdentifier(bridgeEntryKey);
 243             BridgeEntry bridgeEntry =
 244                     InterfaceMetaUtils.getBridgeEntryFromConfigDS(bridgeEntryInstanceIdentifier,
 245                             dataBroker);
 246             // local ip of any of the bridge interface entry will be the dpn end point ip
 247             BridgeInterfaceEntry bridgeInterfaceEntry = bridgeEntry.getBridgeInterfaceEntry().get(0);
 248             InterfaceKey interfaceKey = new InterfaceKey(bridgeInterfaceEntry.getInterfaceName());
 249             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 250             IfTunnel tunnel = interfaceInfo.getAugmentation(IfTunnel.class);
 251             GetEndpointIpForDpnOutputBuilder endpointIpForDpnOutput =
 252                     new GetEndpointIpForDpnOutputBuilder().setLocalIps(
 253                             Collections.singletonList(tunnel.getTunnelSource()));
 254             rpcResultBuilder = RpcResultBuilder.success();
 255             rpcResultBuilder.withResult(endpointIpForDpnOutput.build());
 256         }catch(Exception e){
 257             LOG.error("Retrieval of endpoint of for dpn {} failed due to {}" ,input.getDpid(), e);
 258             rpcResultBuilder = RpcResultBuilder.failed();
 259         }
 260         return Futures.immediateFuture(rpcResultBuilder.build());
 261     }
 262
 263     @Override
 264     public Future<RpcResult<GetEgressInstructionsForInterfaceOutput>> getEgressInstructionsForInterface(GetEgressInstructionsForInterfaceInput input) {
 265         RpcResultBuilder<GetEgressInstructionsForInterfaceOutput> rpcResultBuilder;
 266         try {
 267             List<Instruction> instructions = IfmUtil.getEgressInstructionsForInterface(input.getIntfName(), input.getTunnelKey(), dataBroker, false);
 268             GetEgressInstructionsForInterfaceOutputBuilder output = new GetEgressInstructionsForInterfaceOutputBuilder().
 269                     setInstruction(instructions);
 270             rpcResultBuilder = RpcResultBuilder.success();
 271             rpcResultBuilder.withResult(output.build());
 272         }catch(Exception e){
 273             LOG.error("Retrieval of egress instructions for the key {} failed due to {}",
 274                 input.getIntfName(), e.getMessage());
 275             rpcResultBuilder = RpcResultBuilder.failed();
 276         }
 277         return Futures.immediateFuture(rpcResultBuilder.build());
 278     }
 279
 280     @Override
 281     public Future<RpcResult<GetInterfaceTypeOutput>> getInterfaceType(GetInterfaceTypeInput input) {
 282         String interfaceName = input.getIntfName();
 283         RpcResultBuilder<GetInterfaceTypeOutput> rpcResultBuilder;
 284         try {
 285             InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 286             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 287             if (interfaceInfo == null) {
 288                 String errMsg = String.format("Retrieval of Interface Type for the key {%s} failed due to missing Interface in Config DataStore", interfaceName);
 289                 LOG.error(errMsg);
 290                 rpcResultBuilder = RpcResultBuilder.<GetInterfaceTypeOutput>failed().withError(RpcError.ErrorType.APPLICATION, errMsg);
 291                 return Futures.immediateFuture(rpcResultBuilder.build());
 292             }
 293             GetInterfaceTypeOutputBuilder output = new GetInterfaceTypeOutputBuilder().setInterfaceType(interfaceInfo.getType());
 294             rpcResultBuilder = RpcResultBuilder.success();
 295             rpcResultBuilder.withResult(output.build());
 296         } catch (Exception e) {
 297             LOG.error("Retrieval of interface type for the key {} failed due to {}", interfaceName, e);
 298             rpcResultBuilder = RpcResultBuilder.failed();
 299         }
 300         return Futures.immediateFuture(rpcResultBuilder.build());
 301     }
 302
 303     @Override
 304     public Future<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
 305         String interfaceName = input.getIntfName();
 306         RpcResultBuilder<GetTunnelTypeOutput> rpcResultBuilder;
 307         try {
 308             InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 309             Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 310             if (interfaceInfo == null) {
 311                 String errMsg = String.format("Retrieval of Tunnel Type for the key {%s} failed due to missing Interface in Config DataStore", interfaceName);
 312                 LOG.error(errMsg);
 313                 rpcResultBuilder = RpcResultBuilder.<GetTunnelTypeOutput>failed().withError(RpcError.ErrorType.APPLICATION, errMsg);
 314                 return Futures.immediateFuture(rpcResultBuilder.build());
 315             }
 316             if (Tunnel.class.equals(interfaceInfo.getType())) {
 317                 IfTunnel tnl = interfaceInfo.getAugmentation(IfTunnel.class);
 318                 Class <? extends TunnelTypeBase> tun_type = tnl.getTunnelInterfaceType();
 319                 GetTunnelTypeOutputBuilder output = new GetTunnelTypeOutputBuilder().setTunnelType(tun_type);
 320                 rpcResultBuilder = RpcResultBuilder.success();
 321                 rpcResultBuilder.withResult(output.build());
 322             } else {
 323                 LOG.error("Retrieval of interface type for the key {} failed", interfaceName);
 324                 rpcResultBuilder = RpcResultBuilder.failed();
 325             }
 326         } catch (Exception e) {
 327             LOG.error("Retrieval of interface type for the key {} failed due to {}", interfaceName, e);
 328             rpcResultBuilder = RpcResultBuilder.failed();
 329         }
 330         return Futures.immediateFuture(rpcResultBuilder.build());
 331     }
 332
 333     @Override
 334     public Future<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(GetEgressActionsForInterfaceInput input) {
 335         RpcResultBuilder<GetEgressActionsForInterfaceOutput> rpcResultBuilder;
 336         try {
 337             LOG.debug("Get Egress Action for interface {} with key {}", input.getIntfName(), input.getTunnelKey());
 338             List<Action> actionsList = IfmUtil.getEgressActionsForInterface(input.getIntfName(),
 339                     input.getTunnelKey(), input.getActionKey(),
 340                     dataBroker, false);
 341             GetEgressActionsForInterfaceOutputBuilder output = new GetEgressActionsForInterfaceOutputBuilder().
 342                     setAction(actionsList);
 343             rpcResultBuilder = RpcResultBuilder.success();
 344             rpcResultBuilder.withResult(output.build());
 345         }catch(Exception e){
 346             LOG.error("Retrieval of egress actions for the key {} failed due to {}" ,input.getIntfName(), e.getMessage());
 347             rpcResultBuilder = RpcResultBuilder.failed();
 348         }
 349         return Futures.immediateFuture(rpcResultBuilder.build());
 350     }
 351
 352
 353     @Override
 354     public Future<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(GetPortFromInterfaceInput input) {
 355         RpcResultBuilder<GetPortFromInterfaceOutput> rpcResultBuilder;
 356         String interfaceName = input.getIntfName();
 357         try {
 358             BigInteger dpId = null;
 359             long portNo = 0;
 360             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
 361                     InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName, dataBroker);
 362             if (ifState != null) {
 363                 String lowerLayerIf = ifState.getLowerLayerIf().get(0);
 364                 NodeConnectorId nodeConnectorId = new NodeConnectorId(lowerLayerIf);
 365                 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
 366                 portNo = Long.valueOf(IfmUtil.getPortNoFromNodeConnectorId(nodeConnectorId));
 367                 String phyAddress = ifState.getPhysAddress().getValue();
 368                 // FIXME Assuming portName and interfaceName are same
 369                 GetPortFromInterfaceOutputBuilder output = new GetPortFromInterfaceOutputBuilder().setDpid(dpId).
 370                         setPortname(interfaceName).setPortno(portNo).setPhyAddress(phyAddress);
 371                 rpcResultBuilder = RpcResultBuilder.success();
 372                 rpcResultBuilder.withResult(output.build());
 373             } else {
 374                 rpcResultBuilder = getRpcErrorResultForGetPortRpc(interfaceName, "missing Interface state");
 375             }
 376         }catch(Exception e){
 377             rpcResultBuilder = getRpcErrorResultForGetPortRpc(interfaceName, e.getMessage());
 378         }
 379         return Futures.immediateFuture(rpcResultBuilder.build());
 380     }
 381
 382     private RpcResultBuilder<GetPortFromInterfaceOutput> getRpcErrorResultForGetPortRpc(String interfaceName, String errMsg) {
 383         errMsg = String.format("Retrieval of Port for the key {%s} failed due to %s", interfaceName, errMsg);
 384         LOG.error(errMsg);
 385         RpcResultBuilder<GetPortFromInterfaceOutput> rpcResultBuilder = RpcResultBuilder.<GetPortFromInterfaceOutput>failed().withError(RpcError.ErrorType.APPLICATION, errMsg);
 386         return rpcResultBuilder;
 387     }
 388
 389     @Override
 390     public Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> getNodeconnectorIdFromInterface(GetNodeconnectorIdFromInterfaceInput input) {
 391         String interfaceName = input.getIntfName();
 392         RpcResultBuilder<GetNodeconnectorIdFromInterfaceOutput> rpcResultBuilder;
 393         try {
 394             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
 395                     InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName, dataBroker);
 396             String lowerLayerIf = ifState.getLowerLayerIf().get(0);
 397             NodeConnectorId nodeConnectorId = new NodeConnectorId(lowerLayerIf);
 398
 399             GetNodeconnectorIdFromInterfaceOutputBuilder output = new GetNodeconnectorIdFromInterfaceOutputBuilder().setNodeconnectorId(nodeConnectorId);
 400             rpcResultBuilder = RpcResultBuilder.success();
 401             rpcResultBuilder.withResult(output.build());
 402         } catch (Exception e) {
 403             LOG.error("Retrieval of nodeconnector id for the key {} failed due to {}", interfaceName, e);
 404             rpcResultBuilder = RpcResultBuilder.failed();
 405         }
 406         return Futures.immediateFuture(rpcResultBuilder.build());
 407     }
 408
 409     @Override
 410     public Future<RpcResult<GetInterfaceFromIfIndexOutput>> getInterfaceFromIfIndex(GetInterfaceFromIfIndexInput input) {
 411         Integer ifIndex = input.getIfIndex();
 412         RpcResultBuilder<GetInterfaceFromIfIndexOutput> rpcResultBuilder = null;
 413         try {
 414             InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 415             Optional<IfIndexInterface> ifIndexesInterface = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker);
 416             if(ifIndexesInterface.isPresent()) {
 417                 String interfaceName = ifIndexesInterface.get().getInterfaceName();
 418                 GetInterfaceFromIfIndexOutputBuilder output = new GetInterfaceFromIfIndexOutputBuilder().setInterfaceName(interfaceName);
 419                 rpcResultBuilder = RpcResultBuilder.success();
 420                 rpcResultBuilder.withResult(output.build());
 421             }
 422         } catch (Exception e) {
 423             LOG.error("Retrieval of interfaceName for the key {} failed due to {}", ifIndex, e);
 424             rpcResultBuilder = RpcResultBuilder.failed();
 425         }
 426         return Futures.immediateFuture(rpcResultBuilder.build());
 427     }
 428
 429     @Override
 430     public Future<RpcResult<GetDpnInterfaceListOutput>> getDpnInterfaceList(GetDpnInterfaceListInput input) {
 431         BigInteger dpnid = input.getDpid();
 432         RpcResultBuilder<GetDpnInterfaceListOutput> rpcResultBuilder = null;
 433         try {
 434             InstanceIdentifier<DpnToInterface> id =
 435                     InstanceIdentifier.builder(DpnToInterfaceList.class).child(DpnToInterface.class , new DpnToInterfaceKey(dpnid)).build();
 436             Optional<DpnToInterface> entry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker);
 437             if (entry.isPresent()) {
 438                 List<InterfaceNameEntry> interfaceNameEntries = entry.get().getInterfaceNameEntry();
 439                 if (interfaceNameEntries != null && !interfaceNameEntries.isEmpty()) {
 440                     List<String> interfaceList = interfaceNameEntries.stream().map(InterfaceNameEntry::getInterfaceName).collect(Collectors.toList());
 441                     GetDpnInterfaceListOutputBuilder output = new GetDpnInterfaceListOutputBuilder().setInterfacesList(interfaceList);
 442                     rpcResultBuilder = RpcResultBuilder.success();
 443                     rpcResultBuilder.withResult(output.build());
 444                 }
 445             }
 446         } catch (Exception e) {
 447             LOG.error("Retrieval of interfaceNameList for the dpnId {} failed due to {}", dpnid, e);
 448             rpcResultBuilder = RpcResultBuilder.failed();
 449         }
 450         return Futures.immediateFuture(rpcResultBuilder.build());
 451     }
 452
 453     protected static List<Instruction> buildInstructions(List<InstructionInfo> listInstructionInfo) {
 454         if (listInstructionInfo != null) {
 455             List<Instruction> instructions = new ArrayList<>();
 456             int instructionKey = 0;
 457
 458             for (InstructionInfo instructionInfo : listInstructionInfo) {
 459                 instructions.add(instructionInfo.buildInstruction(instructionKey));
 460                 instructionKey++;
 461             }
 462             return instructions;
 463         }
 464
 465         return null;
 466     }
 467
 468     private ListenableFuture<Void> makeTerminatingServiceFlow(IfTunnel tunnelInfo, BigInteger dpnId, BigInteger tunnelKey, List<Instruction> instruction, int addOrRemove) {
 469         List<MatchInfo> mkMatches = new ArrayList<>();
 470         mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[] {tunnelKey}));
 471         short tableId = tunnelInfo.isInternal() ? NwConstants.INTERNAL_TUNNEL_TABLE :
 472                 NwConstants.EXTERNAL_TUNNEL_TABLE;
 473         final String flowRef = getFlowRef(dpnId,tableId, tunnelKey);
 474         Flow terminatingSerFlow = MDSALUtil.buildFlowNew(tableId, flowRef,
 475                 5, "TST Flow Entry", 0, 0,
 476                 IfmConstants.TUNNEL_TABLE_COOKIE.add(tunnelKey), mkMatches, instruction);
 477         if (addOrRemove == NwConstants.ADD_FLOW) {
 478             return mdsalMgr.installFlow(dpnId, terminatingSerFlow);
 479         }
 480
 481         return mdsalMgr.removeFlow(dpnId, terminatingSerFlow);
 482     }
 483
 484     private ListenableFuture<Void> makeLFIBFlow(BigInteger dpnId, BigInteger tunnelKey, List<Instruction> instruction, int addOrRemove) {
 485         List<MatchInfo> mkMatches = new ArrayList<>();
 486         mkMatches.add(new MatchInfo(MatchFieldType.eth_type,
 487                 new long[]{0x8847L}));
 488         mkMatches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(tunnelKey.longValue())}));
 489         // Install the flow entry in L3_LFIB_TABLE
 490         String flowRef = getFlowRef(dpnId, NwConstants.L3_LFIB_TABLE, tunnelKey);
 491
 492         Flow lfibFlow = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
 493                 IfmConstants.DEFAULT_FLOW_PRIORITY, "LFIB Entry", 0, 0,
 494                 IfmConstants.COOKIE_VM_LFIB_TABLE, mkMatches, instruction);
 495         if (addOrRemove == NwConstants.ADD_FLOW) {
 496             return mdsalMgr.installFlow(dpnId, lfibFlow);
 497         }
 498         return mdsalMgr.removeFlow(dpnId, lfibFlow);
 499     }
 500
 501     private String getFlowRef(BigInteger dpnId, short tableId, BigInteger tunnelKey) {
 502         return IfmConstants.TUNNEL_TABLE_FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR +
 503                 tableId + NwConstants.FLOWID_SEPARATOR + tunnelKey;
 504     }
 505 }