fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.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.fibmanager;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.util.concurrent.Futures;
  12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  13 import com.google.common.util.concurrent.FutureCallback;
  14
  15 import org.opendaylight.vpnmanager.api.IVpnManager;
  16 import org.opendaylight.vpnservice.AbstractDataChangeListener;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  19 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  20 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  21 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  22 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
  23 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
  24 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  25 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  26 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  27 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
  28 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  29 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerInputBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerOutput;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.RemoveLocalNextHopInputBuilder;
  40 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  41 import org.opendaylight.yangtools.yang.binding.DataObject;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  44 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  45 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  46 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
  48 import org.opendaylight.yangtools.yang.binding.RpcService;
  49 import org.opendaylight.yangtools.yang.common.RpcResult;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import com.google.common.base.Optional;
  53
  54 import java.math.BigInteger;
  55 import java.net.InetAddress;
  56 import java.net.UnknownHostException;
  57 import java.util.ArrayList;
  58 import java.util.Collection;
  59 import java.util.List;
  60 import java.util.Set;
  61 import java.util.concurrent.ExecutionException;
  62 import java.util.concurrent.Future;
  63
  64 public class FibManager extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable{
  65   private static final Logger LOG = LoggerFactory.getLogger(FibManager.class);
  66   private static final String FLOWID_PREFIX = "L3.";
  67   private ListenerRegistration<DataChangeListener> listenerRegistration;
  68   private final DataBroker broker;
  69   private final L3nexthopService l3nexthopService;
  70   private IMdsalApiManager mdsalManager;
  71   private IVpnManager vpnmanager;
  72
  73   private static final short L3_FIB_TABLE = 20;
  74   private static final short L3_LFIB_TABLE = 21;
  75   private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
  76   private static final BigInteger COOKIE_VM_FIB_TABLE =  new BigInteger("8000003", 16);
  77   private static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
  78
  79
  80   private static final FutureCallback<Void> DEFAULT_CALLBACK =
  81       new FutureCallback<Void>() {
  82         public void onSuccess(Void result) {
  83           LOG.debug("Success in Datastore write operation");
  84         }
  85
  86         public void onFailure(Throwable error) {
  87           LOG.error("Error in Datastore write operation", error);
  88         };
  89       };
  90
  91   public FibManager(final DataBroker db, final RpcService nextHopService) {
  92     super(VrfEntry.class);
  93     broker = db;
  94     l3nexthopService = (L3nexthopService)nextHopService;
  95     registerListener(db);
  96   }
  97
  98   @Override
  99   public void close() throws Exception {
 100     if (listenerRegistration != null) {
 101       try {
 102         listenerRegistration.close();
 103       } catch (final Exception e) {
 104         LOG.error("Error when cleaning up DataChangeListener.", e);
 105       }
 106       listenerRegistration = null;
 107     }
 108     LOG.info("Fib Manager Closed");
 109   }
 110
 111
 112   public void setMdsalManager(IMdsalApiManager mdsalManager) {
 113     this.mdsalManager = mdsalManager;
 114   }
 115
 116   public void setVpnmanager(IVpnManager vpnmanager) {
 117     this.vpnmanager = vpnmanager;
 118   }
 119
 120   private void registerListener(final DataBroker db) {
 121     try {
 122       listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
 123                                                            getWildCardPath(), FibManager.this, DataChangeScope.SUBTREE);
 124     } catch (final Exception e) {
 125       LOG.error("FibManager DataChange listener registration fail!", e);
 126       throw new IllegalStateException("FibManager registration Listener failed.", e);
 127     }
 128   }
 129
 130   private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 131                                                   InstanceIdentifier<T> path) {
 132
 133     ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 134
 135     Optional<T> result = Optional.absent();
 136     try {
 137       result = tx.read(datastoreType, path).get();
 138     } catch (Exception e) {
 139       throw new RuntimeException(e);
 140     }
 141
 142     return result;
 143   }
 144
 145   private InstanceIdentifier<VrfEntry> getWildCardPath() {
 146     return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
 147   }
 148
 149   private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
 150                                                  InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 151     WriteTransaction tx = broker.newWriteOnlyTransaction();
 152     tx.put(datastoreType, path, data, true);
 153     Futures.addCallback(tx.submit(), callback);
 154   }
 155
 156   @Override
 157   protected void add(final InstanceIdentifier<VrfEntry> identifier,
 158                      final VrfEntry vrfEntry) {
 159     LOG.trace("key: " + identifier + ", value=" + vrfEntry );
 160     createFibEntries(identifier, vrfEntry);
 161   }
 162
 163   @Override
 164   protected void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
 165     LOG.trace("key: " + identifier + ", value=" + vrfEntry);
 166     deleteFibEntries(identifier, vrfEntry);
 167   }
 168
 169   @Override
 170   protected void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
 171     LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update );
 172   }
 173
 174   private void createFibEntries(final InstanceIdentifier<VrfEntry> identifier,
 175                                 final VrfEntry vrfEntry) {
 176     final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
 177     Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
 178     Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
 179
 180     Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
 181     Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
 182     Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
 183     for (Long dpId : dpns) {
 184       addRouteInternal(dpId, vpnId, vrfTableKey, vrfEntry);
 185     }
 186   }
 187
 188   private void addRouteInternal(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
 189                                 final VrfEntry vrfEntry) {
 190     String rd = vrfTableKey.getRouteDistinguisher();
 191     LOG.debug("adding route " + vrfEntry.getDestPrefix() + " " + rd);
 192
 193     GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
 194     long groupId = -1;
 195     boolean isLocalRoute = false;
 196     if(adjacency != null) {
 197       groupId = adjacency.getEgressPointer();
 198       isLocalRoute = adjacency.isLocalDestination();
 199     }
 200     if(groupId == -1) {
 201       LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
 202                                    vrfEntry.getNextHopAddress(), rd);
 203       LOG.warn("Failed to add Route: {} in vpn: {}",
 204                              vrfEntry.getDestPrefix(), rd);
 205       return;
 206     }
 207
 208     makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.ADD_FLOW);
 209
 210     if (isLocalRoute) {
 211       makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.ADD_FLOW);
 212     }
 213
 214     LOG.debug(
 215         "Successfully added fib entry for " + vrfEntry.getDestPrefix() + " vpnId " + vpnId);
 216   }
 217
 218   private void deleteFibEntries(final InstanceIdentifier<VrfEntry> identifier,
 219                                 final VrfEntry vrfEntry) {
 220     final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
 221     Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
 222     Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
 223
 224     Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
 225     Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
 226     Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
 227     for (Long dpId : dpns) {
 228       deleteRoute(dpId, vpnId, vrfTableKey, vrfEntry);
 229     }
 230   }
 231
 232   public void deleteRoute(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
 233                           final VrfEntry vrfEntry) {
 234     LOG.debug("deleting route "+ vrfEntry.getDestPrefix() + " "+vpnId);
 235     String rd = vrfTableKey.getRouteDistinguisher();
 236     GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
 237     long groupId = -1;
 238     boolean isLocalRoute = false;
 239     if(adjacency != null) {
 240       groupId = adjacency.getEgressPointer();
 241       isLocalRoute = adjacency.isLocalDestination();
 242     }
 243     if(groupId == -1) {
 244       LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
 245                               vrfEntry.getNextHopAddress(), rd);
 246       LOG.warn("Failed to add Route: {} in vpn: {}",
 247                              vrfEntry.getDestPrefix(), rd);
 248       return;
 249     }
 250
 251     makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.DEL_FLOW);
 252
 253     if (isLocalRoute) {
 254       makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.DEL_FLOW);
 255       deleteLocalAdjacency(dpId, vpnId, vrfEntry);
 256     }
 257
 258     LOG.debug("Successfully delete fib entry for "+ vrfEntry.getDestPrefix() + " vpnId "+vpnId);
 259   }
 260
 261   private long getIpAddress(byte[] rawIpAddress) {
 262     return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
 263             + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
 264   }
 265
 266   private void makeConnectedRoute(long dpId, long vpnId, VrfEntry vrfEntry, String rd,
 267                                   long groupId, int addOrRemove) {
 268     LOG.trace("makeConnectedRoute: vrfEntry {}",vrfEntry);
 269     String values[] = vrfEntry.getDestPrefix().split("/");
 270     String ipAddress = values[0];
 271     int prefixLength = (values.length == 1) ? 32 : Integer.parseInt(values[1]);
 272     LOG.debug("Adding route to DPN. ip {} masklen {}", ipAddress, prefixLength);
 273     InetAddress destPrefix = null;
 274     try {
 275       destPrefix = InetAddress.getByName(ipAddress);
 276     } catch (UnknownHostException e) {
 277       LOG.error("UnknowHostException in addRoute. Failed to add Route for ipPrefix {}", vrfEntry.getDestPrefix());
 278       return;
 279     }
 280
 281     List<MatchInfo> matches = new ArrayList<MatchInfo>();
 282
 283     matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
 284         BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
 285
 286     matches.add(new MatchInfo(MatchFieldType.eth_type,
 287                               new long[] { 0x0800L }));
 288
 289     if(prefixLength != 0) {
 290       matches.add(new MatchInfo(MatchFieldType.ipv4_dst, new long[] {
 291           getIpAddress(destPrefix.getAddress()), prefixLength }));
 292     }
 293
 294     List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
 295     List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 296
 297     if(addOrRemove == NwConstants.ADD_FLOW) {
 298       actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId)}));
 299       actionsInfos.add(new ActionInfo(ActionType.push_mpls, new String[] { null }));
 300       actionsInfos.add(new ActionInfo(ActionType.set_field_mpls_label, new String[] { Long.toString(vrfEntry.getLabel())}));
 301       instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
 302     }
 303
 304     String flowRef = getFlowRef(dpId, L3_FIB_TABLE, rd, destPrefix);
 305
 306     FlowEntity flowEntity;
 307
 308     int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 309     flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_FIB_TABLE, flowRef,
 310                                            priority, flowRef, 0, 0,
 311                                            COOKIE_VM_FIB_TABLE, matches, instructions);
 312
 313     if (addOrRemove == NwConstants.ADD_FLOW) {
 314       mdsalManager.installFlow(flowEntity);
 315     } else {
 316       mdsalManager.removeFlow(flowEntity);
 317     }
 318   }
 319
 320   private void makeLFibTableEntry(long dpId, long label, long groupId,
 321                                   String nextHop, int addOrRemove) {
 322     List<MatchInfo> matches = new ArrayList<MatchInfo>();
 323     matches.add(new MatchInfo(MatchFieldType.eth_type,
 324                               new long[] { 0x8847L }));
 325     matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(label)}));
 326
 327     List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
 328     List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 329     actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
 330     instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
 331
 332     // Install the flow entry in L3_LFIB_TABLE
 333     String flowRef = getFlowRef(dpId, L3_LFIB_TABLE, label, nextHop);
 334
 335     FlowEntity flowEntity;
 336     flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_LFIB_TABLE, flowRef,
 337                                            DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
 338                                            COOKIE_VM_LFIB_TABLE, matches, instructions);
 339
 340     if (addOrRemove == NwConstants.ADD_FLOW) {
 341       mdsalManager.installFlow(flowEntity);
 342     } else {
 343       mdsalManager.removeFlow(flowEntity);
 344     }
 345     LOG.debug("LFIB Entry for dpID {} : label : {} group {} modified successfully {}",dpId, label, groupId );
 346   }
 347
 348   private void deleteLocalAdjacency(final long dpId, final long vpnId, final VrfEntry vrfEntry) {
 349     LOG.trace("deleteLocalAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
 350     try {
 351       Future<RpcResult<Void>> result =
 352           l3nexthopService.removeLocalNextHop(new RemoveLocalNextHopInputBuilder().setDpnId(dpId)
 353                                                   .setIpPrefix(vrfEntry.getDestPrefix())
 354                                                   .setNexthopIp(vrfEntry.getNextHopAddress())
 355                                                   .setVpnId(vpnId)
 356                                                   .build());
 357       RpcResult<Void> rpcResult = result.get();
 358       if (rpcResult.isSuccessful()) {
 359         LOG.debug("Local Next hop for {} on dpn {} successfully deleted", vrfEntry.getDestPrefix(), dpId);
 360       } else {
 361         LOG.error("Local Next hop for {} on dpn {} not deleted", vrfEntry.getDestPrefix(), dpId);
 362       }
 363     } catch (NullPointerException | InterruptedException | ExecutionException e) {
 364       LOG.trace("", e);
 365     }
 366   }
 367
 368   public void populateFibOnNewDpn(long dpnId, long vpnId, String rd) {
 369     LOG.trace("New dpn {} for vpn {} : populateFibOnNewDpn", dpnId, rd);
 370     InstanceIdentifier<VrfTables> id = buildVrfId(rd);
 371     Optional<VrfTables> vrfTable = read(LogicalDatastoreType.OPERATIONAL, id);
 372     if(vrfTable.isPresent()) {
 373       for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
 374         addRouteInternal(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry);
 375       }
 376     }
 377   }
 378
 379   public void cleanUpDpnForVpn(long dpnId, long vpnId, String rd) {
 380     LOG.trace("Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
 381     InstanceIdentifier<VrfTables> id = buildVrfId(rd);
 382     Optional<VrfTables> vrfTable = read(LogicalDatastoreType.OPERATIONAL, id);
 383     if(vrfTable.isPresent()) {
 384       for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
 385         deleteRoute(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry);
 386       }
 387     }
 388   }
 389
 390   public static InstanceIdentifier<VrfTables> buildVrfId(String rd) {
 391     InstanceIdentifierBuilder<VrfTables> idBuilder =
 392         InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
 393     InstanceIdentifier<VrfTables> id = idBuilder.build();
 394     return id;
 395   }
 396
 397   private String getFlowRef(long dpnId, short tableId, long label, String nextHop) {
 398     return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 399         .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 400         .append(label).append(NwConstants.FLOWID_SEPARATOR)
 401         .append(nextHop).toString();
 402   }
 403
 404   private String getFlowRef(long dpnId, short tableId, String rd, InetAddress destPrefix) {
 405     return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 406         .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 407         .append(rd).append(NwConstants.FLOWID_SEPARATOR)
 408         .append(destPrefix.getHostAddress()).toString();
 409   }
 410
 411   private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
 412                         final VrfEntry vrfEntry) {
 413     GetEgressPointerOutput adjacency = null;
 414     LOG.trace("resolveAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
 415     try {
 416       Future<RpcResult<GetEgressPointerOutput>> result =
 417           l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId)
 418                                                 .setIpPrefix(vrfEntry.getDestPrefix())
 419                                                 .setNexthopIp(vrfEntry.getNextHopAddress())
 420                                                 .setVpnId(vpnId)
 421                                                 .build());
 422       RpcResult<GetEgressPointerOutput> rpcResult = result.get();
 423       if (rpcResult.isSuccessful()) {
 424         adjacency = rpcResult.getResult();
 425       } else {
 426         LOG.error("Next hop information not available");
 427       }
 428     } catch (NullPointerException | InterruptedException | ExecutionException e) {
 429       LOG.trace("", e);
 430     }
 431     return adjacency;
 432   }
 433
 434   private Long getVpnId(String rd) {
 435     Long vpnId = null;
 436     InstanceIdentifier<VpnInstances> id = InstanceIdentifier.create(VpnInstances.class);
 437     Optional<VpnInstances> vpnInstances = read(LogicalDatastoreType.OPERATIONAL, id);
 438     if(vpnInstances.isPresent()) {
 439       List<VpnInstance> vpns = vpnInstances.get().getVpnInstance();
 440       for(VpnInstance vpn : vpns) {
 441         if(vpn.getIpv4Family().getRouteDistinguisher().equals(rd)) {
 442           VpnInstance1 vpnInstanceId = vpn.getAugmentation(VpnInstance1.class);
 443           if (vpnInstanceId != null) {
 444             vpnId = vpnInstanceId.getVpnId();
 445             break;
 446           }
 447         }
 448       }
 449     }
 450     return vpnId;
 451   }
 452
 453     public void processNodeAdd(long dpnId) {
 454         LOG.debug("Received notification to install TableMiss entries for dpn {} ", dpnId);
 455         makeTableMissFlow(dpnId, NwConstants.ADD_FLOW);
 456     }
 457
 458     private void makeTableMissFlow(long dpnId, int addOrRemove) {
 459         final BigInteger COOKIE_TABLE_MISS = new BigInteger("1030000", 16);
 460         // Instruction to punt to controller
 461         List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
 462         List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 463         actionsInfos.add(new ActionInfo(ActionType.punt_to_controller, new String[] {}));
 464         instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
 465         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 466         FlowEntity flowEntityLfib = MDSALUtil.buildFlowEntity(dpnId, L3_LFIB_TABLE,
 467                 getFlowRef(dpnId, L3_LFIB_TABLE, NwConstants.TABLE_MISS_FLOW),
 468                 NwConstants.TABLE_MISS_PRIORITY, "Table Miss", 0, 0, COOKIE_TABLE_MISS, matches, instructions);
 469
 470         FlowEntity flowEntityFib = MDSALUtil.buildFlowEntity(dpnId,L3_FIB_TABLE, getFlowRef(dpnId, L3_FIB_TABLE, NwConstants.TABLE_MISS_FLOW),
 471                 NwConstants.TABLE_MISS_PRIORITY, "FIB Table Miss Flow", 0, 0, COOKIE_VM_FIB_TABLE,
 472                 matches, instructions);
 473
 474         if (addOrRemove == NwConstants.ADD_FLOW) {
 475             LOG.debug("Invoking MDSAL to install Table Miss Entries");
 476             mdsalManager.installFlow(flowEntityLfib);
 477             mdsalManager.installFlow(flowEntityFib);
 478         } else {
 479             mdsalManager.removeFlow(flowEntityLfib);
 480             mdsalManager.removeFlow(flowEntityFib);
 481
 482         }
 483     }
 484
 485     private String getFlowRef(long dpnId, short tableId, int tableMiss) {
 486         return new StringBuffer().append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 487                 .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(tableMiss)
 488                 .append(FLOWID_PREFIX).toString();
 489     }
 490 }