vpnservice/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibRpcServiceImpl.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.vpnservice.fibmanager;
   9
  10 import java.math.BigInteger;
  11 import java.net.InetAddress;
  12 import java.net.UnknownHostException;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.concurrent.Future;
  16
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.fibmanager.api.IFibManager;
  21 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  22 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  23 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
  24 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
  25 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  26 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  27 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  28 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
  29 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  30 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstanceOpData;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstanceToVpnId;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddressesBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddressesKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fib.rpc.rev160121.CreateFibEntryInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fib.rpc.rev160121.RemoveFibEntryInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fib.rpc.rev160121.FibRpcService;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces;
  47 import org.opendaylight.yangtools.yang.binding.DataObject;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.opendaylight.yangtools.yang.common.RpcResult;
  50 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 import com.google.common.base.Optional;
  55 import com.google.common.util.concurrent.FutureCallback;
  56 import com.google.common.util.concurrent.Futures;
  57
  58 import static org.opendaylight.vpnservice.fibmanager.FibConstants.*;
  59
  60 public class FibRpcServiceImpl implements FibRpcService {
  61
  62     private static final Logger LOG = LoggerFactory.getLogger(FibRpcServiceImpl.class);
  63     private IMdsalApiManager mdsalManager;
  64     private DataBroker broker;
  65     private IFibManager fibManager;
  66
  67     public FibRpcServiceImpl(DataBroker broker, IMdsalApiManager mdsalManager, IFibManager fibManager) {
  68         this.broker = broker;
  69         this.mdsalManager = mdsalManager;
  70         this.fibManager = fibManager;
  71     }
  72
  73
  74     /**
  75      * to install FIB routes on specified dpn with given instructions
  76      *
  77      */
  78     public Future<RpcResult<Void>> createFibEntry(CreateFibEntryInput input) {
  79
  80         BigInteger dpnId = input.getSourceDpid();
  81         String vpnName = input.getVpnName();
  82         long vpnId = getVpnId(broker, vpnName);
  83         String ipAddress = input.getIpAddress();
  84         LOG.info("Create custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
  85         List<Instruction> instructions = input.getInstruction();
  86
  87         makeLocalFibEntry(vpnId, dpnId, ipAddress, instructions);
  88         updateVpnToDpnAssociation(vpnId, dpnId, ipAddress, vpnName);
  89
  90         return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
  91     }
  92
  93     /**
  94      * to remove FIB/LFIB/TST routes from specified dpn
  95      *
  96      */
  97     public Future<RpcResult<Void>> removeFibEntry(RemoveFibEntryInput input) {
  98
  99         BigInteger dpnId = input.getSourceDpid();
 100         String vpnName = input.getVpnName();
 101         long vpnId = getVpnId(broker, vpnName);
 102         long serviceId = input.getServiceId();
 103         String ipAddress = input.getIpAddress();
 104
 105         LOG.info("Delete custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
 106
 107         removeLocalFibEntry(dpnId, vpnId, ipAddress);
 108         //removeLFibTableEntry(dpnId, serviceId);
 109         //removeTunnelTableEntry(dpnId, serviceId);
 110         removeFromVpnDpnAssociation(vpnId, dpnId, ipAddress, vpnName);
 111
 112         return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
 113     }
 114
 115     private void removeLocalFibEntry(BigInteger dpnId, long vpnId, String ipPrefix) {
 116         String values[] = ipPrefix.split("/");
 117         String ipAddress = values[0];
 118         int prefixLength = (values.length == 1) ? 0 : Integer.parseInt(values[1]);
 119         LOG.debug("Removing route from DPN. ip {} masklen {}", ipAddress, prefixLength);
 120         InetAddress destPrefix = null;
 121         try {
 122           destPrefix = InetAddress.getByName(ipAddress);
 123         } catch (UnknownHostException e) {
 124           LOG.error("UnknowHostException in removeRoute. Failed  to remove Route for ipPrefix {}", ipAddress);
 125           return;
 126         }
 127         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 128
 129         matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
 130             BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
 131
 132         matches.add(new MatchInfo(MatchFieldType.eth_type,
 133                                   new long[] { 0x0800L }));
 134
 135         if(prefixLength != 0) {
 136             matches.add(new MatchInfo(MatchFieldType.ipv4_destination, new String[] {
 137                     destPrefix.getHostAddress(), Integer.toString(prefixLength) }));
 138         }
 139
 140         String flowRef = getFlowRef(dpnId, NwConstants.L3_FIB_TABLE, vpnId, ipAddress);
 141
 142
 143         int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 144         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef,
 145                                                priority, flowRef, 0, 0,
 146                                                COOKIE_VM_FIB_TABLE, matches, null);
 147
 148         mdsalManager.removeFlow(dpnId, flowEntity);
 149
 150         LOG.debug("FIB entry for route {} on dpn {} removed successfully", ipAddress, dpnId);
 151     }
 152
 153     private void removeLFibTableEntry(BigInteger dpnId, long serviceId) {
 154         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 155         matches.add(new MatchInfo(MatchFieldType.eth_type,
 156                                   new long[] { 0x8847L }));
 157         matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(serviceId)}));
 158
 159         String flowRef = getFlowRef(dpnId, NwConstants.L3_LFIB_TABLE, serviceId, "");
 160
 161         LOG.debug("removing LFib entry with flow ref {}", flowRef);
 162
 163         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
 164                                                DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
 165                                                COOKIE_VM_LFIB_TABLE, matches, null);
 166
 167         mdsalManager.removeFlow(dpnId, flowEntity);
 168
 169         LOG.debug("LFIB Entry for dpID : {} label : {} removed successfully {}",dpnId, serviceId);
 170     }
 171
 172     private void removeTunnelTableEntry(BigInteger dpnId, long serviceId) {
 173         LOG.info("remove terminatingServiceActions called with DpnId = {} and label = {}", dpnId , serviceId);
 174         List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
 175         // Matching metadata
 176         mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[] {BigInteger.valueOf(serviceId)}));
 177         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
 178                                                getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, serviceId, ""),
 179                                                5, String.format("%s:%d","TST Flow Entry ",serviceId), 0, 0,
 180                                                COOKIE_TUNNEL.add(BigInteger.valueOf(serviceId)), mkMatches, null);
 181         mdsalManager.removeFlow(dpnId, flowEntity);
 182         LOG.debug("Terminating service Entry for dpID {} : label : {} removed successfully {}",dpnId, serviceId);
 183     }
 184
 185     private void makeTunnelTableEntry(BigInteger dpnId, long serviceId, List<Instruction> customInstructions) {
 186         List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
 187
 188         LOG.info("create terminatingServiceAction on DpnId = {} and serviceId = {} and actions = {}", dpnId , serviceId);
 189
 190         mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[] {BigInteger.valueOf(serviceId)}));
 191
 192         Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
 193                         getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, serviceId, ""), 5, String.format("%s:%d","TST Flow Entry ",serviceId),
 194                         0, 0, COOKIE_TUNNEL.add(BigInteger.valueOf(serviceId)),mkMatches, customInstructions);
 195
 196         mdsalManager.installFlow(dpnId, terminatingServiceTableFlowEntity);
 197     }
 198
 199     private long getIpAddress(byte[] rawIpAddress) {
 200         return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
 201                 + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
 202     }
 203
 204     private void makeLocalFibEntry(long vpnId, BigInteger dpnId, String ipPrefix, List<Instruction> customInstructions) {
 205         String values[] = ipPrefix.split("/");
 206         String ipAddress = values[0];
 207         int prefixLength = (values.length == 1) ? 0 : Integer.parseInt(values[1]);
 208         LOG.debug("Adding route to DPN. ip {} masklen {}", ipAddress, prefixLength);
 209         InetAddress destPrefix = null;
 210         try {
 211           destPrefix = InetAddress.getByName(ipAddress);
 212         } catch (UnknownHostException e) {
 213           LOG.error("UnknowHostException in addRoute. Failed  to add Route for ipPrefix {}", ipAddress);
 214           return;
 215         }
 216         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 217
 218         matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
 219             BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
 220
 221         matches.add(new MatchInfo(MatchFieldType.eth_type,
 222                                   new long[] { 0x0800L }));
 223
 224         if(prefixLength != 0) {
 225           matches.add(new MatchInfo(MatchFieldType.ipv4_destination, new String[] {
 226              destPrefix.getHostAddress(), Integer.toString(prefixLength) }));
 227         }
 228
 229         String flowRef = getFlowRef(dpnId, NwConstants.L3_FIB_TABLE, vpnId, ipAddress);
 230
 231
 232         int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 233         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef,
 234                                                priority, flowRef, 0, 0,
 235                                                COOKIE_VM_FIB_TABLE, matches, customInstructions);
 236
 237         mdsalManager.installFlow(dpnId, flowEntity);
 238
 239         LOG.debug("FIB entry for route {} on dpn {} installed successfully", ipAddress, dpnId);
 240     }
 241
 242     private void makeLFibTableEntry(BigInteger dpId, long serviceId, List<Instruction> customInstructions) {
 243         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 244         matches.add(new MatchInfo(MatchFieldType.eth_type,
 245                 new long[] { 0x8847L }));
 246         matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(serviceId)}));
 247
 248         List<Instruction> instructions = new ArrayList<Instruction>();
 249         List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 250         actionsInfos.add(new ActionInfo(ActionType.pop_mpls, new String[]{}));
 251         Instruction writeInstruction = new InstructionInfo(InstructionType.write_actions, actionsInfos).buildInstruction(0);
 252         instructions.add(writeInstruction);
 253         instructions.addAll(customInstructions);
 254
 255         // Install the flow entry in L3_LFIB_TABLE
 256         String flowRef = getFlowRef(dpId, NwConstants.L3_LFIB_TABLE, serviceId, "");
 257
 258         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
 259                 DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
 260                 COOKIE_VM_LFIB_TABLE, matches, instructions);
 261
 262         mdsalManager.installFlow(dpId, flowEntity);
 263
 264         LOG.debug("LFIB Entry for dpID {} : label : {} modified successfully {}",dpId, serviceId );
 265     }
 266
 267     private String getFlowRef(BigInteger dpnId, short tableId, long id, String ipAddress) {
 268         return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 269             .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 270             .append(id).append(NwConstants.FLOWID_SEPARATOR).append(ipAddress).toString();
 271     }
 272
 273     private synchronized void updateVpnToDpnAssociation(long vpnId, BigInteger dpnId, String ipAddr, String vpnName) {
 274         LOG.debug("Updating VPN to DPN list for dpn : {} for VPN: {} with ip: {}",
 275                 dpnId, vpnName, ipAddr);
 276         String routeDistinguisher = getVpnRd(broker, vpnName);
 277         String rd = (routeDistinguisher == null) ? vpnName : routeDistinguisher;
 278         InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(rd, dpnId);
 279         Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
 280         org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses
 281             ipAddress = new IpAddressesBuilder().setIpAddress(ipAddr).build();
 282
 283         if (dpnInVpn.isPresent()) {
 284             MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id.child(
 285                 org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance
 286                     .op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses.class,
 287                     new IpAddressesKey(ipAddr)), ipAddress);
 288         } else {
 289             MDSALUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL,
 290                                     getVpnInstanceOpDataIdentifier(rd),
 291                                     getVpnInstanceOpData(rd, vpnId));
 292             VpnToDpnListBuilder vpnToDpnList = new VpnToDpnListBuilder().setDpnId(dpnId);
 293             List<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data
 294                 .vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses> ipAddresses =  new ArrayList<>();
 295             ipAddresses.add(ipAddress);
 296             MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id,
 297                               vpnToDpnList.setIpAddresses(ipAddresses).build());
 298             LOG.debug("populate FIB on new dpn {} for VPN {}", dpnId, vpnName);
 299             fibManager.populateFibOnNewDpn(dpnId, vpnId, rd);
 300         }
 301     }
 302
 303     private synchronized void removeFromVpnDpnAssociation(long vpnId, BigInteger dpnId, String ipAddr, String vpnName) {
 304         LOG.debug("Removing association of VPN to DPN list for dpn : {} for VPN: {} with ip: {}",
 305                 dpnId, vpnName, ipAddr);
 306         String routeDistinguisher = getVpnRd(broker, vpnName);
 307         String rd = (routeDistinguisher == null) ? vpnName : routeDistinguisher;
 308         InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(rd, dpnId);
 309         Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
 310         if (dpnInVpn.isPresent()) {
 311             List<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data
 312                 .vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses> ipAddresses = dpnInVpn.get().getIpAddresses();
 313             org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses
 314                     ipAddress = new IpAddressesBuilder().setIpAddress(ipAddr).build();
 315
 316             if (ipAddresses != null && ipAddresses.remove(ipAddress)) {
 317                 if (ipAddresses.isEmpty()) {
 318                     List<VpnInterfaces> vpnInterfaces = dpnInVpn.get().getVpnInterfaces();
 319                     if(vpnInterfaces ==null || vpnInterfaces.isEmpty()) {
 320                         //Clean up the dpn
 321                         LOG.debug("Cleaning up dpn {} from VPN {}", dpnId, vpnName);
 322                         MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
 323                         fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd);
 324                     }
 325                 } else {
 326                     delete(broker, LogicalDatastoreType.OPERATIONAL, id.child(
 327                         org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data
 328                             .vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses.class,
 329                             new IpAddressesKey(ipAddr)));
 330                 }
 331             }
 332         }
 333     }
 334
 335     //TODO: Below Util methods to be removed once VpnUtil methods are exposed in api bundle
 336     public static String getVpnRd(DataBroker broker, String vpnName) {
 337
 338         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 339                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 340         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 341                 = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 342
 343         String rd = null;
 344         if(vpnInstance.isPresent()) {
 345             rd = vpnInstance.get().getVrfId();
 346         }
 347         return rd;
 348     }
 349
 350     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
 351                                                                                          getVpnInstanceToVpnIdIdentifier(String vpnName) {
 352         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 353                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
 354                         new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
 355     }
 356
 357
 358     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
 359         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 360             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
 361             .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
 362     }
 363
 364     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 365         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 366             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 367     }
 368
 369     static VpnInstanceOpDataEntry getVpnInstanceOpData(String rd, long vpnId) {
 370         return new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).build();
 371     }
 372
 373     static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 374             InstanceIdentifier<T> path) {
 375         WriteTransaction tx = broker.newWriteOnlyTransaction();
 376         tx.delete(datastoreType, path);
 377         tx.submit();
 378     }
 379
 380     static long getVpnId(DataBroker broker, String vpnName) {
 381
 382         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 383             = getVpnInstanceToVpnIdIdentifier(vpnName);
 384         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 385             = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 386
 387         long vpnId = -1;
 388         if(vpnInstance.isPresent()) {
 389             vpnId = vpnInstance.get().getVpnId();
 390         }
 391         return vpnId;
 392     }
 393
 394 }