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