nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java

   1 /*
   2  * Copyright (c) 2015 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.vpnservice.nexthopmgr;
   9
  10 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  11 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
  12 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
  13 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  14 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  15 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  16
  17 import java.math.BigInteger;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20 import java.util.concurrent.Future;
  21 import com.google.common.base.Optional;
  22 import com.google.common.util.concurrent.Futures;
  23 import com.google.common.util.concurrent.FutureCallback;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  26 import org.opendaylight.yangtools.yang.binding.DataObject;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  28 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  29 import org.opendaylight.yangtools.yang.common.RpcResult;
  30 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  31 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  32 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  33 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  34 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  35 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.*;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.*;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.tunnelnexthops.*;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.vpnnexthops.*;
  50 import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
  51 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  52 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  53 import org.opendaylight.vpnservice.mdsalutil.BucketInfo;
  54 import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
  55 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  56 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  57 import org.opendaylight.idmanager.IdManager;
  58 import java.util.concurrent.ExecutionException;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 public class NexthopManager implements L3nexthopService, AutoCloseable {
  63     private static final Logger LOG = LoggerFactory.getLogger(NexthopManager.class);
  64     private final DataBroker broker;
  65     private IMdsalApiManager mdsalManager;
  66     private IInterfaceManager interfaceManager;
  67     private IdManager idManager;
  68     private static final short LPORT_INGRESS_TABLE = 0;
  69     private static final short LFIB_TABLE = 20;
  70     private static final short FIB_TABLE = 21;
  71     private static final short DEFAULT_FLOW_PRIORITY = 10;
  72
  73     private static final FutureCallback<Void> DEFAULT_CALLBACK =
  74         new FutureCallback<Void>() {
  75             public void onSuccess(Void result) {
  76                 LOG.debug("Success in Datastore write operation");
  77             }
  78             public void onFailure(Throwable error) {
  79                 LOG.error("Error in Datastore write operation", error);
  80             };
  81         };
  82
  83     /**
  84     * Provides nexthop functions
  85     * Creates group ID pool
  86     *
  87     * @param db - dataBroker reference
  88     */
  89     public NexthopManager(final DataBroker db) {
  90         broker = db;
  91     }
  92
  93     @Override
  94     public void close() throws Exception {
  95         LOG.info("NextHop Manager Closed");
  96     }
  97
  98     public void setInterfaceManager(IInterfaceManager ifManager) {
  99         this.interfaceManager = ifManager;
 100     }
 101
 102     public void setMdsalManager(IMdsalApiManager mdsalManager) {
 103         this.mdsalManager = mdsalManager;
 104     }
 105
 106     public void setIdManager(IdManager idManager) {
 107         this.idManager = idManager;
 108     }
 109
 110     protected void createNexthopPointerPool() {
 111         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
 112                 .setPoolName("nextHopPointerPool")
 113                 .setLow(150000L)
 114                 .setHigh(175000L)
 115                 .build();
 116         //TODO: Error handling
 117         Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
 118         LOG.trace("NextHopPointerPool result : {}", result);
 119     }
 120
 121
 122     protected long getVpnId(String vpnName) {
 123         InstanceIdentifierBuilder<VpnInstance> idBuilder = InstanceIdentifier.builder(VpnInstances.class)
 124                 .child(VpnInstance.class, new VpnInstanceKey(vpnName));
 125
 126         InstanceIdentifier<VpnInstance> id = idBuilder.build();
 127         InstanceIdentifier<VpnInstance1> idx = id.augmentation(VpnInstance1.class);
 128         Optional<VpnInstance1> vpn = read(LogicalDatastoreType.OPERATIONAL, idx);
 129
 130         if (vpn.isPresent()) {
 131             LOG.debug("VPN id returned: {}", vpn.get().getVpnId());
 132             return vpn.get().getVpnId();
 133         } else {
 134             return -1;
 135         }
 136     }
 137
 138     private BigInteger getDpnId(String ofPortId) {
 139         String[] fields = ofPortId.split(":");
 140         BigInteger dpn = new BigInteger(fields[1]);
 141         LOG.debug("DpnId: {}", dpn);
 142         return dpn;
 143     }
 144
 145     protected long createNextHopPointer(String nexthopKey) {
 146         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
 147                 .setPoolName("nextHopPointerPool").setIdKey(nexthopKey)
 148                 .build();
 149         //TODO: Proper error handling once IdManager code is complete
 150         try {
 151             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 152             RpcResult<AllocateIdOutput> rpcResult = result.get();
 153             return rpcResult.getResult().getIdValue();
 154         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 155             LOG.trace("",e);
 156         }
 157         return 0;
 158     }
 159
 160     public void createLocalNextHop(String ifName, String vpnName, String ipAddress, String macAddress) {
 161         String nhKey = new String("nexthop." + vpnName + ipAddress);
 162         long groupId = createNextHopPointer(nhKey);
 163
 164         long vpnId = getVpnId(vpnName);
 165         BigInteger dpnId = interfaceManager.getDpnForInterface(ifName);
 166         VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress, 0);
 167         LOG.trace("nexthop: {}", nexthop);
 168         if (nexthop == null) {
 169             List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
 170             List<ActionInfo> listActionInfo = interfaceManager.getInterfaceEgressActions(ifName);
 171             BucketInfo bucket = new BucketInfo(listActionInfo);
 172             // MAC re-write
 173             if (macAddress != null) {
 174                listActionInfo.add(0, new ActionInfo(ActionType.set_field_eth_dest, new String[]{macAddress}));
 175                listActionInfo.add(0, new ActionInfo(ActionType.pop_mpls, new String[]{}));
 176             } else {
 177                 //FIXME: Log message here.
 178                 LOG.debug("mac address for new local nexthop is null");
 179             }
 180             listBucketInfo.add(bucket);
 181             GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
 182                 dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo);
 183
 184             // install Group
 185             mdsalManager.installGroup(groupEntity);
 186
 187             //update MD-SAL DS
 188             addVpnNexthopToDS(vpnId, ipAddress, groupId);
 189         } else {
 190             //check update
 191         }
 192     }
 193
 194     public void createRemoteNextHop(String ifName, String ipAddress) {
 195         String nhKey = new String("nexthop." + ifName + ipAddress);
 196         long groupId = createNextHopPointer(nhKey);
 197
 198         BigInteger dpnId = interfaceManager.getDpnForInterface(ifName);
 199         TunnelNexthop nexthop = getTunnelNexthop(dpnId, ipAddress);
 200         if (nexthop == null) {
 201             List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
 202             List<ActionInfo> listActionInfo = interfaceManager.getInterfaceEgressActions(ifName);
 203             BucketInfo bucket = new BucketInfo(listActionInfo);
 204             // MAC re-write??
 205             listBucketInfo.add(bucket);
 206             GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
 207                 dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo);
 208             mdsalManager.installGroup(groupEntity);
 209             //makeRemoteFlow(dpnId, ifName, NwConstants.ADD_FLOW);
 210
 211             //update MD-SAL DS
 212             addTunnelNexthopToDS(dpnId, ipAddress, groupId);
 213         } else {
 214             //check update
 215         }
 216     }
 217
 218     private void makeRemoteFlow(BigInteger dpnId, String ifName, int addOrRemoveFlow) {
 219         long portNo = 0;
 220         String flowName = ifName;
 221         String flowRef = getTunnelInterfaceFlowRef(dpnId, LPORT_INGRESS_TABLE, ifName);
 222         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 223         List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
 224         if (NwConstants.ADD_FLOW == addOrRemoveFlow) {
 225             portNo = interfaceManager.getPortForInterface(ifName);
 226             matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {
 227                 dpnId, BigInteger.valueOf(portNo) }));
 228             mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] {LFIB_TABLE}));
 229         }
 230
 231         BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16);
 232         FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId, LPORT_INGRESS_TABLE, flowRef,
 233                                                           DEFAULT_FLOW_PRIORITY, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions);
 234
 235         if (NwConstants.ADD_FLOW == addOrRemoveFlow) {
 236             mdsalManager.installFlow(flowEntity);
 237         } else {
 238             mdsalManager.removeFlow(flowEntity);
 239         }
 240     }
 241
 242     private String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) {
 243                 return new StringBuilder().append(dpnId).append(tableId).append(ifName).toString();
 244             }
 245
 246     protected void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer) {
 247
 248         InstanceIdentifierBuilder<VpnNexthops> idBuilder = InstanceIdentifier.builder(
 249             L3nexthop.class)
 250                 .child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
 251
 252         // Add nexthop to vpn node
 253         VpnNexthop nh = new VpnNexthopBuilder().
 254                 setKey(new VpnNexthopKey(ipPrefix)).
 255                 setIpAddress(ipPrefix).
 256                 setEgressPointer(egressPointer).build();
 257
 258         InstanceIdentifier<VpnNexthop> id1 = idBuilder
 259                 .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix)).build();
 260         LOG.trace("Adding vpnnextHop {} to Operational DS", nh);
 261         syncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK);
 262
 263     }
 264
 265     private void addTunnelNexthopToDS(BigInteger dpnId, String ipPrefix, long egressPointer) {
 266         InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
 267                 .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
 268
 269         // Add nexthop to dpn node
 270         TunnelNexthop nh = new TunnelNexthopBuilder().
 271                 setKey(new TunnelNexthopKey(ipPrefix)).
 272                 setIpAddress(ipPrefix).
 273                 setEgressPointer(egressPointer).build();
 274
 275         InstanceIdentifier<TunnelNexthop> id1 = idBuilder
 276                 .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix)).build();
 277         LOG.trace("Adding tunnelnextHop {} to Operational DS for a dpn node", nh);
 278         asyncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK);
 279
 280     }
 281
 282     protected VpnNexthop getVpnNexthop(long vpnId, String ipAddress, int retryCount) {
 283
 284         // check if vpn node is there
 285         InstanceIdentifierBuilder<VpnNexthops> idBuilder =
 286                         InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
 287         InstanceIdentifier<VpnNexthops> id = idBuilder.build();
 288         try {
 289             for (int retry = 0; retry <= retryCount; retry++) {
 290                 Optional<VpnNexthops> vpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id);
 291                 if (vpnNexthops.isPresent()) {
 292
 293                     // get nexthops list for vpn
 294                     List<VpnNexthop> nexthops = vpnNexthops.get().getVpnNexthop();
 295                     for (VpnNexthop nexthop : nexthops) {
 296                         if (nexthop.getIpAddress().equals(ipAddress)) {
 297                             // return nexthop
 298                             LOG.trace("VpnNextHop : {}", nexthop);
 299                             return nexthop;
 300                         }
 301                     }
 302                 }
 303                 Thread.sleep(100L);
 304             }
 305         } catch (InterruptedException e) {
 306             LOG.trace("", e);
 307         }
 308         // return null if not found
 309         return null;
 310     }
 311
 312     private TunnelNexthop getTunnelNexthop(BigInteger dpnId, String ipAddress) {
 313
 314         InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
 315                 .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
 316
 317         // check if vpn node is there
 318         InstanceIdentifier<TunnelNexthops> id = idBuilder.build();
 319         Optional<TunnelNexthops> dpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id);
 320         if (dpnNexthops.isPresent()) {
 321             List<TunnelNexthop> nexthops = dpnNexthops.get().getTunnelNexthop();
 322             for (TunnelNexthop nexthop : nexthops) {
 323                 if (nexthop.getIpAddress().equals(ipAddress)) {
 324                     LOG.trace("TunnelNextHop : {}",nexthop);
 325                     return nexthop;
 326                 }
 327             }
 328         }
 329         return null;
 330     }
 331
 332     public long getNextHopPointer(BigInteger dpnId, long vpnId, String prefixIp, String nextHopIp) {
 333         String endpointIp = interfaceManager.getEndpointIpForDpn(dpnId);
 334         if (nextHopIp.equals(endpointIp)) {
 335             VpnNexthop vpnNextHop = getVpnNexthop(vpnId, prefixIp, 0);
 336             return vpnNextHop.getEgressPointer();
 337         } else {
 338             TunnelNexthop tunnelNextHop = getTunnelNexthop(dpnId, nextHopIp);
 339             LOG.trace("NExtHopPointer : {}", tunnelNextHop.getEgressPointer());
 340             return tunnelNextHop.getEgressPointer();
 341         }
 342     }
 343
 344     private void removeTunnelNexthopFromDS(BigInteger dpnId, String ipPrefix) {
 345
 346         InstanceIdentifierBuilder<TunnelNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
 347                 .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId))
 348                 .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix));
 349         InstanceIdentifier<TunnelNexthop> id = idBuilder.build();
 350         // remove from DS
 351         LOG.trace("Removing tunnel next hop from datastore : {}", id);
 352         delete(LogicalDatastoreType.OPERATIONAL, id);
 353     }
 354
 355     private void removeVpnNexthopFromDS(long vpnId, String ipPrefix) {
 356
 357         InstanceIdentifierBuilder<VpnNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
 358                 .child(VpnNexthops.class, new VpnNexthopsKey(vpnId))
 359                 .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix));
 360         InstanceIdentifier<VpnNexthop> id = idBuilder.build();
 361         // remove from DS
 362         LOG.trace("Removing vpn next hop from datastore : {}", id);
 363         delete(LogicalDatastoreType.OPERATIONAL, id);
 364     }
 365
 366
 367     public void removeLocalNextHop(BigInteger dpnId, Long vpnId, String ipAddress) {
 368
 369         VpnNexthop nh = getVpnNexthop(vpnId, ipAddress, 0);
 370         if (nh != null) {
 371             // how to inform and remove dependent FIB entries??
 372             // we need to do it before the group is removed
 373             GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
 374                     dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null);
 375             // remove Group ...
 376             mdsalManager.removeGroup(groupEntity);
 377             //update MD-SAL DS
 378             removeVpnNexthopFromDS(vpnId, ipAddress);
 379         } else {
 380             //throw error
 381             LOG.error("removal of local next hop failed");
 382         }
 383
 384     }
 385
 386     public void removeRemoteNextHop(BigInteger dpnId, String ifName, String ipAddress) {
 387
 388         TunnelNexthop nh = getTunnelNexthop(dpnId, ipAddress);
 389         if (nh != null) {
 390             // how to inform and remove dependent FIB entries??
 391             // we need to do it before the group is removed
 392
 393             // remove Group ...
 394             GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
 395                     dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null);
 396             // remove Group ...
 397             mdsalManager.removeGroup(groupEntity);
 398             //makeRemoteFlow(dpnId, ifName, NwConstants.DEL_FLOW);
 399             //update MD-SAL DS
 400             removeTunnelNexthopFromDS(dpnId, ipAddress);
 401         } else {
 402             //throw error
 403             LOG.error("removal of remote next hop failed : dpnid : {}, ipaddress : {}", dpnId, ipAddress);
 404         }
 405
 406     }
 407
 408     @Override
 409     public Future<RpcResult<GetEgressPointerOutput>> getEgressPointer(
 410             GetEgressPointerInput input) {
 411
 412         GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder();
 413
 414         String endpointIp = interfaceManager.getEndpointIpForDpn(input.getDpnId());
 415         LOG.trace("getEgressPointer: input {}, endpointIp {}", input, endpointIp);
 416         if (input.getNexthopIp() == null || input.getNexthopIp().equals(endpointIp)) {
 417             VpnNexthop vpnNextHop = getVpnNexthop(input.getVpnId(), input.getIpPrefix(), 5);
 418             output.setEgressPointer(vpnNextHop.getEgressPointer());
 419             output.setLocalDestination(true);
 420         } else {
 421             TunnelNexthop tunnelNextHop = getTunnelNexthop(input.getDpnId(), input.getNexthopIp());
 422             output.setEgressPointer(tunnelNextHop.getEgressPointer());
 423             output.setLocalDestination(false);
 424         }
 425
 426         RpcResultBuilder<GetEgressPointerOutput> rpcResultBuilder = RpcResultBuilder.success();
 427         rpcResultBuilder.withResult(output.build());
 428
 429         return Futures.immediateFuture(rpcResultBuilder.build());
 430
 431     }
 432
 433     <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 434             InstanceIdentifier<T> path) {
 435
 436         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 437
 438         Optional<T> result = Optional.absent();
 439         try {
 440             result = tx.read(datastoreType, path).get();
 441         } catch (Exception e) {
 442             throw new RuntimeException(e);
 443         }
 444
 445         return result;
 446     }
 447
 448     private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
 449             InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 450         WriteTransaction tx = broker.newWriteOnlyTransaction();
 451         tx.merge(datastoreType, path, data, true);
 452         Futures.addCallback(tx.submit(), callback);
 453     }
 454
 455     private <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType,
 456             InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 457         WriteTransaction tx = broker.newWriteOnlyTransaction();
 458         tx.merge(datastoreType, path, data, true);
 459         tx.submit();
 460     }
 461
 462     private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
 463         WriteTransaction tx = broker.newWriteOnlyTransaction();
 464         tx.delete(datastoreType, path);
 465         Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
 466     }
 467
 468     @Override
 469     public Future<RpcResult<Void>> removeLocalNextHop(RemoveLocalNextHopInput input) {
 470         VpnNexthop vpnNextHop = getVpnNexthop(input.getVpnId(), input.getIpPrefix(), 0);
 471         RpcResultBuilder<Void> rpcResultBuilder;
 472         LOG.debug("vpnnexthop is: {}", vpnNextHop);
 473         try {
 474             removeLocalNextHop(input.getDpnId(),input.getVpnId(), input.getIpPrefix());
 475             rpcResultBuilder = RpcResultBuilder.success();
 476         }
 477         catch(Exception e){
 478             LOG.error("Removal of local next hop for vpnNextHop {} failed {}" ,vpnNextHop, e);
 479             rpcResultBuilder = RpcResultBuilder.failed();
 480         }
 481         return Futures.immediateFuture(rpcResultBuilder.build());
 482     }
 483
 484 }