openstack/net-virt-providers/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/providers/openflow13/OF13Provider.java

   1 /**
   2  * Copyright (C) 2013 Red Hat, Inc.
   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.ovsdb.openstack.netvirt.providers.openflow13;
   9
  10 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  11 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  12 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  13 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  15 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  16 import org.opendaylight.neutron.spi.NeutronNetwork;
  17 import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
  18 import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
  19 import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
  20 import org.opendaylight.ovsdb.openstack.netvirt.api.ClassifierProvider;
  21 import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
  22 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
  23 import org.opendaylight.ovsdb.openstack.netvirt.api.EgressAclProvider;
  24 import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
  25 import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
  26 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
  27 import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
  28 import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
  29 import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
  30 import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
  31 import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
  32 import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
  33 import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupActionBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketKey;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  78 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  79 import org.slf4j.Logger;
  80 import org.slf4j.LoggerFactory;
  81
  82 import com.google.common.base.Optional;
  83 import com.google.common.base.Preconditions;
  84 import com.google.common.collect.Lists;
  85 import com.google.common.collect.Maps;
  86 import com.google.common.util.concurrent.CheckedFuture;
  87 import java.net.InetAddress;
  88 import java.util.List;
  89 import java.util.Map;
  90 import java.util.concurrent.ExecutionException;
  91
  92
  93 /**
  94  * Open vSwitch OpenFlow 1.3 Networking Provider for OpenStack Neutron
  95  *
  96  * @author Madhu Venugopal
  97  * @author Brent Salisbury
  98  * @author Dave Tucker
  99  * @author Sam Hague
 100  */
 101 public class OF13Provider implements NetworkingProvider {
 102     private static final Logger logger = LoggerFactory.getLogger(OF13Provider.class);
 103     private DataBroker dataBroker;
 104     private static final short TABLE_0_DEFAULT_INGRESS = 0;
 105     private static final short TABLE_1_ISOLATE_TENANT = 10;
 106     private static final short TABLE_2_LOCAL_FORWARD = 20;
 107     private static Long groupId = 1L;
 108
 109     private volatile ConfigurationService configurationService;
 110     private volatile BridgeConfigurationManager bridgeConfigurationManager;
 111     private volatile TenantNetworkManager tenantNetworkManager;
 112     private volatile SecurityServicesManager securityServicesManager;
 113     //private volatile OvsdbConnectionService connectionService;
 114     private volatile MdsalConsumer mdsalConsumer;
 115     private volatile ClassifierProvider classifierProvider;
 116     private volatile IngressAclProvider ingressAclProvider;
 117     private volatile EgressAclProvider egressAclProvider;
 118     private volatile NodeCacheManager nodeCacheManager;
 119     private volatile L2ForwardingProvider l2ForwardingProvider;
 120
 121     public static final String NAME = "OF13Provider";
 122
 123     public void init() {
 124         logger.info(">>>>>> init OF13Provider {}", this.getClass());
 125     }
 126
 127     @Override
 128     public String getName() {
 129         return NAME;
 130     }
 131
 132     @Override
 133     public boolean supportsServices() {
 134         return true;
 135     }
 136
 137     @Override
 138     public boolean hasPerTenantTunneling() {
 139         return false;
 140     }
 141
 142     private Status getTunnelReadinessStatus (Node node, String tunnelKey) {
 143         InetAddress srcTunnelEndPoint = configurationService.getTunnelEndPoint(node);
 144         if (srcTunnelEndPoint == null) {
 145             logger.error("Tunnel Endpoint not configured for Node {}", node);
 146             return new Status(StatusCode.NOTFOUND, "Tunnel Endpoint not configured for "+ node);
 147         }
 148
 149         if (!bridgeConfigurationManager.isNodeNeutronReady(node)) {
 150             logger.error(node+" is not Overlay ready");
 151             return new Status(StatusCode.NOTACCEPTABLE, node+" is not Overlay ready");
 152         }
 153
 154         if (!tenantNetworkManager.isTenantNetworkPresentInNode(node, tunnelKey)) {
 155             logger.debug(node + " has no VM corresponding to segment " + tunnelKey);
 156             return new Status(StatusCode.NOTACCEPTABLE, node+" has no VM corresponding to segment "+ tunnelKey);
 157         }
 158         return new Status(StatusCode.SUCCESS);
 159     }
 160
 161     private String getTunnelName(String tunnelType, InetAddress dst) {
 162         return tunnelType+"-"+dst.getHostAddress();
 163     }
 164
 165     private boolean addTunnelPort (Node node, String tunnelType, InetAddress src, InetAddress dst) {
 166         String tunnelBridgeName = configurationService.getIntegrationBridgeName();
 167         String portName = getTunnelName(tunnelType, dst);
 168         if (MdsalUtils.extractTerminationPointAugmentation(node, portName) != null) {
 169             logger.trace("Tunnel {} is present in {} of {}", portName, tunnelBridgeName, node);
 170             return true;
 171         }
 172
 173         Map<String, String> options = Maps.newHashMap();
 174         options.put("key", "flow");
 175         options.put("local_ip", src.getHostAddress());
 176         options.put("remote_ip", dst.getHostAddress());
 177
 178         if (!MdsalUtils.addTunnelTerminationPoint(node, tunnelBridgeName, portName, tunnelType, options)) {
 179             logger.error("Failed to insert Tunnel port {} in {}", portName, tunnelBridgeName);
 180             return false;
 181         }
 182
 183         return true;
 184     }
 185
 186     /* delete port from ovsdb port table */
 187     private boolean deletePort(Node node, String bridgeName, String portName) {
 188         // TODO SB_MIGRATION
 189         // might need to convert from ovsdb node to bridge node
 190         return MdsalUtils.deleteTerminationPoint(node, portName);
 191     }
 192
 193     private boolean deleteTunnelPort(Node node, String tunnelType, InetAddress src, InetAddress dst) {
 194         String tunnelBridgeName = configurationService.getIntegrationBridgeName();
 195         String portName = getTunnelName(tunnelType, dst);
 196         return deletePort(node, tunnelBridgeName, portName);
 197     }
 198
 199     private boolean deletePhysicalPort(Node node, String phyIntfName) {
 200         String intBridgeName = configurationService.getIntegrationBridgeName();
 201         return deletePort(node, intBridgeName, phyIntfName);
 202     }
 203
 204     private void programLocalBridgeRules(Node node, Long dpid, String segmentationId,
 205                                          String attachedMac, long localPort) {
 206         /*
 207          * Table(0) Rule #3
 208          * ----------------
 209          * Match: VM sMac and Local Ingress Port
 210          * Action:Action: Set Tunnel ID and GOTO Local Table (5)
 211          */
 212
 213         handleLocalInPort(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_1_ISOLATE_TENANT,
 214                 segmentationId, localPort, attachedMac, true);
 215
 216         /*
 217          * Table(0) Rule #4
 218          * ----------------
 219          * Match: Drop any remaining Ingress Local VM Packets
 220          * Action: Drop w/ a low priority
 221          */
 222
 223         handleDropSrcIface(dpid, localPort, true);
 224
 225         /*
 226          * Table(2) Rule #1
 227          * ----------------
 228          * Match: Match TunID and Destination DL/dMAC Addr
 229          * Action: Output Port
 230          * table=2,tun_id=0x5,dl_dst=00:00:00:00:00:01 actions=output:2
 231          */
 232
 233         handleLocalUcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, attachedMac, true);
 234
 235         /*
 236          * Table(2) Rule #2
 237          * ----------------
 238          * Match: Tunnel ID and dMAC (::::FF:FF)
 239          * table=2,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 240          * actions=output:2,3,4,5
 241          */
 242
 243         handleLocalBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, true);
 244         handleTunnelFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, true);
 245
 246         /*
 247          * TODO : Optimize the following 2 writes to be restricted only for the very first port known in a segment.
 248          */
 249         /*
 250          * Table(1) Rule #3
 251          * ----------------
 252          * Match:  Any remaining Ingress Local VM Packets
 253          * Action: Drop w/ a low priority
 254          * -------------------------------------------
 255          * table=1,priority=8192,tun_id=0x5 actions=goto_table:2
 256          */
 257
 258         handleTunnelMiss(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, true);
 259
 260         /*
 261          * Table(2) Rule #3
 262          * ----------------
 263          * Match: Any Remaining Flows w/a TunID
 264          * Action: Drop w/ a low priority
 265          * table=2,priority=8192,tun_id=0x5 actions=drop
 266          */
 267
 268         handleLocalTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, true);
 269     }
 270
 271     private void removeLocalBridgeRules(Node node, Long dpid, String segmentationId, String attachedMac, long localPort) {
 272         /*
 273          * Table(0) Rule #3
 274          * ----------------
 275          * Match: VM sMac and Local Ingress Port
 276          * Action:Action: Set Tunnel ID and GOTO Local Table (5)
 277          */
 278
 279         handleLocalInPort(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_1_ISOLATE_TENANT, segmentationId, localPort, attachedMac, false);
 280
 281         /*
 282          * Table(0) Rule #4
 283          * ----------------
 284          * Match: Drop any remaining Ingress Local VM Packets
 285          * Action: Drop w/ a low priority
 286          */
 287
 288         handleDropSrcIface(dpid, localPort, false);
 289
 290         /*
 291          * Table(2) Rule #1
 292          * ----------------
 293          * Match: Match TunID and Destination DL/dMAC Addr
 294          * Action: Output Port
 295          * table=2,tun_id=0x5,dl_dst=00:00:00:00:00:01 actions=output:2
 296          */
 297
 298         handleLocalUcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, attachedMac, false);
 299
 300         /*
 301          * Table(2) Rule #2
 302          * ----------------
 303          * Match: Tunnel ID and dMAC (::::FF:FF)
 304          * table=2,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 305          * actions=output:2,3,4,5
 306          */
 307
 308         handleLocalBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, false);
 309         handleTunnelFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, false);
 310     }
 311
 312     private void programLocalIngressTunnelBridgeRules(Node node, Long dpid, String segmentationId, String attachedMac, long tunnelOFPort, long localPort) {
 313         /*
 314          * Table(0) Rule #2
 315          * ----------------
 316          * Match: Ingress Port, Tunnel ID
 317          * Action: GOTO Local Table (20)
 318          */
 319
 320         handleTunnelIn(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, true);
 321
 322         /*
 323          * Table(1) Rule #2
 324          * ----------------
 325          * Match: Match Tunnel ID and L2 ::::FF:FF Flooding
 326          * Action: Flood to selected destination TEPs
 327          * -------------------------------------------
 328          * table=1,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 329          * actions=output:10,output:11,goto_table:2
 330          */
 331
 332         handleTunnelFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, true);
 333
 334     }
 335
 336     private void programRemoteEgressTunnelBridgeRules(Node node, Long dpid, String segmentationId, String attachedMac, long tunnelOFPort, long localPort) {
 337         /*
 338          * Table(1) Rule #1
 339          * ----------------
 340          * Match: Drop any remaining Ingress Local VM Packets
 341          * Action: Drop w/ a low priority
 342          * -------------------------------------------
 343          * table=1,tun_id=0x5,dl_dst=00:00:00:00:00:08 \
 344          * actions=output:11,goto_table:2
 345          */
 346
 347         handleTunnelOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, attachedMac, true);
 348     }
 349
 350     private void removeRemoteEgressTunnelBridgeRules(Node node, Long dpid, String segmentationId, String attachedMac, long tunnelOFPort, long localPort) {
 351         /*
 352          * Table(1) Rule #1
 353          * ----------------
 354          * Match: Drop any remaining Ingress Local VM Packets
 355          * Action: Drop w/ a low priority
 356          * -------------------------------------------
 357          * table=1,tun_id=0x5,dl_dst=00:00:00:00:00:08 \
 358          * actions=output:11,goto_table:2
 359          */
 360
 361         handleTunnelOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, attachedMac, false);
 362     }
 363
 364     /* Remove tunnel rules if last node in this tenant network */
 365     private void removePerTunnelRules(Node node, Long dpid, String segmentationId, long tunnelOFPort) {
 366         /*
 367          * TODO : Optimize the following 2 writes to be restricted only for the very first port known in a segment.
 368          */
 369         /*
 370          * Table(1) Rule #3
 371          * ----------------
 372          * Match:  Any remaining Ingress Local VM Packets
 373          * Action: Drop w/ a low priority
 374          * -------------------------------------------
 375          * table=1,priority=8192,tun_id=0x5 actions=goto_table:2
 376          */
 377
 378         handleTunnelMiss(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, false);
 379
 380         /*
 381          * Table(2) Rule #3
 382          * ----------------
 383          * Match: Any Remaining Flows w/a TunID
 384          * Action: Drop w/ a low priority
 385          * table=2,priority=8192,tun_id=0x5 actions=drop
 386          */
 387
 388         handleLocalTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, false);
 389
 390         /*
 391          * Table(0) Rule #2
 392          * ----------------
 393          * Match: Ingress Port, Tunnel ID
 394          * Action: GOTO Local Table (10)
 395          */
 396
 397         handleTunnelIn(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, false);
 398
 399         /*
 400          * Table(1) Rule #2
 401          * ----------------
 402          * Match: Match Tunnel ID and L2 ::::FF:FF Flooding
 403          * Action: Flood to selected destination TEPs
 404          * -------------------------------------------
 405          * table=1,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 406          * actions=output:10,output:11,goto_table:2
 407          */
 408
 409         handleTunnelFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort, false);
 410     }
 411
 412     private void programLocalVlanRules(Node node, Long dpid, String segmentationId, String attachedMac, long localPort) {
 413         /*
 414          * Table(0) Rule #1
 415          * ----------------
 416          * Tag traffic coming from the local port and vm srcmac
 417          * Match: VM sMac and Local Ingress Port
 418          * Action: Set VLAN ID and GOTO Local Table 1
 419          */
 420
 421         handleLocalInPortSetVlan(dpid, TABLE_0_DEFAULT_INGRESS,
 422                 TABLE_1_ISOLATE_TENANT, segmentationId, localPort,
 423                 attachedMac, true);
 424
 425         /*
 426          * Table(0) Rule #3
 427          * ----------------
 428          * Drop all other traffic coming from the local port
 429          * Match: Drop any remaining Ingress Local VM Packets
 430          * Action: Drop w/ a low priority
 431          */
 432
 433         handleDropSrcIface(dpid, localPort, true);
 434
 435         /*
 436          * Table(2) Rule #1
 437          * ----------------
 438          * Forward unicast traffic destined to the local port after stripping tag
 439          * Match: Match VLAN ID and Destination DL/dMAC Addr
 440          * Action: strip vlan, output to local port
 441          * Example: table=2,vlan_id=0x5,dl_dst=00:00:00:00:00:01 actions= strip vlan, output:2
 442          */
 443
 444         handleLocalVlanUcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId,
 445                 localPort, attachedMac, true);
 446
 447         /*
 448          * Table(2) Rule #2
 449          * ----------------
 450          * Match: VLAN ID and dMAC (::::FF:FF)
 451          * Action: strip vlan, output to all local ports in this vlan
 452          * Example: table=2,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 453          * actions= strip_vlan, output:2,3,4,5
 454          */
 455
 456         //handleLocalVlanBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId,
 457         //        localPort, ethPort, true);
 458         //handleVlanFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 459         //        segmentationId, localPort, ethport, true);
 460
 461         /*
 462          * Table(2) Rule #3
 463          * ----------------
 464          * Match: Any Remaining Flows w/a VLAN ID
 465          * Action: Drop w/ a low priority
 466          * Example: table=2,priority=8192,vlan_id=0x5 actions=drop
 467          */
 468
 469         //handleLocalVlanTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId,
 470         //        true);
 471     }
 472
 473     private void removeLocalVlanRules(Node node, Long dpid,
 474                                       String segmentationId, String attachedMac, long localPort) {
 475         /*
 476          * Table(0) Rule #1
 477          * ----------------
 478          * Match: VM sMac and Local Ingress Port
 479          * Action: Set VLAN ID and GOTO Local Table 1
 480          */
 481
 482         handleLocalInPortSetVlan(dpid, TABLE_0_DEFAULT_INGRESS,
 483                 TABLE_1_ISOLATE_TENANT, segmentationId, localPort,
 484                 attachedMac, false);
 485
 486         /*
 487          * Table(0) Rule #3
 488          * ----------------
 489          * Match: Drop any remaining Ingress Local VM Packets
 490          * Action: Drop w/ a low priority
 491          */
 492
 493         handleDropSrcIface(dpid, localPort, false);
 494
 495         /*
 496          * Table(2) Rule #1
 497          * ----------------
 498          * Match: Match VLAN ID and Destination DL/dMAC Addr
 499          * Action: strip vlan, output to local port
 500          * Example: table=2,vlan_id=0x5,dl_dst=00:00:00:00:00:01 actions= strip vlan, output:2
 501          */
 502
 503         handleLocalVlanUcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId,
 504                 localPort, attachedMac, false);
 505
 506         /*
 507          * Table(2) Rule #2
 508          * ----------------
 509          * Match: VLAN ID and dMAC (::::FF:FF)
 510          * Action: strip vlan, output to all local ports in this vlan
 511          * Example: table=2,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 512          * actions= strip_vlan, output:2,3,4,5
 513          */
 514
 515         //handleLocalVlanBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId,
 516         //        localPort, ethPort, false);
 517         //handleVlanFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 518         //        segmentationId, localPort, false);
 519
 520     }
 521
 522     private void programLocalIngressVlanRules(Node node, Long dpid, String segmentationId, String attachedMac,
 523                                               long localPort, long ethPort) {
 524         /*
 525          * Table(0) Rule #2
 526          * ----------------
 527          * Match: Ingress port = physical interface, Vlan ID
 528          * Action: GOTO Local Table 2
 529          */
 530
 531         handleVlanIn(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_2_LOCAL_FORWARD,
 532                 segmentationId, ethPort, true);
 533
 534         /*
 535          * Table(1) Rule #2
 536          * ----------------
 537          * Match: Match VLAN ID and L2 ::::FF:FF Flooding
 538          * Action: Flood to local and remote VLAN members
 539          * -------------------------------------------
 540          * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 541          * actions=output:10 (eth port),goto_table:2
 542          * table=110, priority=16384,dl_vlan=2001,dl_dst=01:00:00:00:00:00/01:00:00:00:00:00 actions=output:2,pop_vlan,output:1,output:3,output:4
 543          */
 544
 545         handleLocalVlanBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, ethPort, true);
 546
 547         /*
 548          * Table(1) Rule #2
 549          * ----------------
 550          * Match: Match VLAN ID and L2 ::::FF:FF Flooding
 551          * Action: Flood to local and remote VLAN members
 552          * -------------------------------------------
 553          * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 554          * actions=output:10 (eth port),goto_table:2
 555          */
 556
 557         //handleVlanFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 558         //        segmentationId, ethPort, true);
 559     }
 560
 561     private void programRemoteEgressVlanRules(Node node, Long dpid, String segmentationId,
 562                                               String attachedMac, long ethPort) {
 563         /*
 564          * Table(1) Rule #1
 565          * ----------------
 566          * Match: Destination MAC is local VM MAC and vlan id
 567          * Action: go to table 2
 568          * -------------------------------------------
 569          * Example: table=1,vlan_id=0x5,dl_dst=00:00:00:00:00:08 \
 570          * actions=goto_table:2
 571          */
 572
 573         //handleVlanOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 574         //        segmentationId, ethPort, attachedMac, true);
 575
 576         /*
 577          * Table(1) Rule #3
 578          * ----------------
 579          * Match:  VLAN ID
 580          * Action: Go to table 2
 581          * -------------------------------------------
 582          * Example: table=1,priority=8192,vlan_id=0x5 actions=output:1,goto_table:2
 583          * table=110,priority=8192,dl_vlan=2001 actions=output:2
 584          */
 585
 586         handleVlanMiss(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, ethPort, true);
 587     }
 588
 589     private void removeRemoteEgressVlanRules(Node node, Long dpid, String segmentationId,
 590                                              String attachedMac, long localPort, long ethPort) {
 591         /*
 592          * Table(1) Rule #1
 593          * ----------------
 594          * Match: Destination MAC is local VM MAC and vlan id
 595          * Action: go to table 2
 596          * -------------------------------------------
 597          * Example: table=1,vlan_id=0x5,dl_dst=00:00:00:00:00:08 \
 598          * actions=goto_table:2
 599          */
 600
 601         //handleVlanOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 602         //        segmentationId, ethPort, attachedMac, false);
 603
 604         /*
 605          * Table(1) Rule #2
 606          * ----------------
 607          * Match: Match VLAN ID and L2 ::::FF:FF Flooding
 608          * Action: Flood to local and remote VLAN members
 609          * -------------------------------------------
 610          * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 611          * actions=output:10 (eth port),goto_table:2
 612          * table=110, priority=16384,dl_vlan=2001,dl_dst=01:00:00:00:00:00/01:00:00:00:00:00 actions=output:2,pop_vlan,output:1,output:3,output:4
 613          */
 614
 615         handleLocalVlanBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, ethPort, false);
 616     }
 617
 618     private void removePerVlanRules(Node node, Long dpid, String segmentationId, long localPort, long ethPort) {
 619         /*
 620          * Table(2) Rule #3
 621          * ----------------
 622          * Match: Any Remaining Flows w/a VLAN ID
 623          * Action: Drop w/ a low priority
 624          * Example: table=2,priority=8192,vlan_id=0x5 actions=drop
 625          */
 626
 627         //handleLocalVlanTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, false);
 628
 629         /*
 630          * Table(0) Rule #2
 631          * ----------------
 632          * Match: Ingress port = physical interface, Vlan ID
 633          * Action: GOTO Local Table 2
 634          */
 635
 636         handleVlanIn(dpid, TABLE_0_DEFAULT_INGRESS, TABLE_2_LOCAL_FORWARD, segmentationId, ethPort, false);
 637
 638         /*
 639          * Table(1) Rule #2
 640          * ----------------
 641          * Match: Match VLAN ID and L2 ::::FF:FF Flooding
 642          * Action: Flood to local and remote VLAN members
 643          * -------------------------------------------
 644          * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 645          * actions=output:10 (eth port),goto_table:2
 646          * table=110, priority=16384,dl_vlan=2001,dl_dst=01:00:00:00:00:00/01:00:00:00:00:00 actions=output:2,pop_vlan,output:1,output:3,output:4
 647          */
 648
 649         //handleLocalVlanBcastOut(dpid, TABLE_2_LOCAL_FORWARD, segmentationId, localPort, ethPort, false);
 650
 651         /*
 652          * Table(1) Rule #2
 653          * ----------------
 654          * Match: Match VLAN ID and L2 ::::FF:FF Flooding
 655          * Action: Flood to local and remote VLAN members
 656          * -------------------------------------------
 657          * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
 658          * actions=output:10 (eth port),goto_table:2
 659          */
 660
 661         //handleVlanFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD,
 662         //        segmentationId, ethPort, false);
 663
 664         /*
 665          * Table(1) Rule #3
 666          * ----------------
 667          * Match:  VLAN ID
 668          * Action: Go to table 2
 669          * -------------------------------------------
 670          * Example: table=1,priority=8192,vlan_id=0x5 actions=output:1,goto_table:2
 671          * table=110,priority=8192,dl_vlan=2001 actions=output:2
 672          */
 673
 674         handleVlanMiss(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, ethPort, false);
 675     }
 676
 677     private Long getDpid(Node node) {
 678         Long dpid = 0L;
 679         dpid = MdsalUtils.getDataPathId(node);
 680         if (dpid == 0) {
 681             logger.warn("getDpid: dpid not found: {}", node);
 682         }
 683         return dpid;
 684     }
 685
 686     private Long getIntegrationBridgeOFDPID(Node node) {
 687         Long dpid = 0L;
 688         if (MdsalUtils.getBridgeName(node).equals(configurationService.getIntegrationBridgeName())) {
 689             dpid = getDpid(node);
 690         }
 691         return dpid;
 692     }
 693
 694     private Long getExternalBridgeDpid(Node node) {
 695         Long dpid = 0L;
 696         if (MdsalUtils.getBridgeName(node).equals(configurationService.getExternalBridgeName())) {
 697             dpid = getDpid(node);
 698         }
 699         return dpid;
 700     }
 701
 702     private void programLocalRules (String networkType, String segmentationId, Node node,
 703                                     OvsdbTerminationPointAugmentation intf) {
 704         try {
 705             Long dpid = getIntegrationBridgeOFDPID(node);
 706             if (dpid == 0L) {
 707                 logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 708                 return;
 709             }
 710
 711             long localPort = (Long)intf.getOfport();
 712
 713             String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 714             if (attachedMac == null) {
 715                 logger.warn("No AttachedMac seen in {}", intf);
 716                 return;
 717             }
 718
 719             /* Program local rules based on network type */
 720             if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
 721                 logger.debug("Program local vlan rules for interface {}", intf.getName());
 722                 programLocalVlanRules(node, dpid, segmentationId, attachedMac, localPort);
 723             }
 724             /* If the network type is tunnel based (VXLAN/GRRE/etc) with Neutron Port Security ACLs */
 725             /* TODO SB_MIGRATION */
 726             /*if ((networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) || networkType.equalsIgnoreCase
 727                     (NetworkHandler.NETWORK_TYPE_VXLAN)) && securityServicesManager.isPortSecurityReady(intf)) {
 728                 logger.debug("Neutron port has a Port Security Group");
 729                 // Retrieve the security group UUID from the Neutron Port
 730                 NeutronSecurityGroup securityGroupInPort = securityServicesManager.getSecurityGroupInPort(intf);
 731                 logger.debug("Program Local rules for networkType: {} does contain a Port Security Group: {} " +
 732                         "to be installed on DPID: {}", networkType, securityGroupInPort, dpid);
 733                 ingressAclProvider.programPortSecurityACL(dpid, segmentationId, attachedMac, localPort,
 734                         securityGroupInPort);
 735                 egressAclProvider.programPortSecurityACL(dpid, segmentationId, attachedMac, localPort,
 736                         securityGroupInPort);
 737             }*/
 738             if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) ||
 739                     networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
 740                 logger.debug("Program local bridge rules for interface {}", intf.getName());
 741                 programLocalBridgeRules(node, dpid, segmentationId, attachedMac, localPort);
 742             }
 743         } catch (Exception e) {
 744             logger.error("Exception in programming Local Rules for "+intf+" on "+node, e);
 745         }
 746     }
 747
 748     private void removeLocalRules (String networkType, String segmentationId, Node node,
 749                                    OvsdbTerminationPointAugmentation intf) {
 750         try {
 751             Long dpid = getIntegrationBridgeOFDPID(node);
 752             if (dpid == 0L) {
 753                 logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 754                 return;
 755             }
 756
 757             long localPort = (Long)intf.getOfport();
 758
 759             String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 760             if (attachedMac == null) {
 761                 logger.warn("No AttachedMac seen in {}", intf);
 762                 return;
 763             }
 764
 765             /* Program local rules based on network type */
 766             if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
 767                 logger.debug("Remove local vlan rules for interface {}", intf.getName());
 768                 removeLocalVlanRules(node, dpid, segmentationId, attachedMac, localPort);
 769             } else if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) ||
 770                     networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
 771                 logger.debug("Remove local bridge rules for interface {}", intf.getName());
 772                 removeLocalBridgeRules(node, dpid, segmentationId, attachedMac, localPort);
 773             }
 774         } catch (Exception e) {
 775             logger.error("Exception in removing Local Rules for "+intf+" on "+node, e);
 776         }
 777     }
 778
 779     private void programTunnelRules (String tunnelType, String segmentationId, InetAddress dst, Node node,
 780                                      OvsdbTerminationPointAugmentation intf, boolean local) {
 781         try {
 782             Long dpid = getIntegrationBridgeOFDPID(node);
 783             if (dpid == 0L) {
 784                 logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 785                 return;
 786             }
 787
 788             long localPort = (Long)intf.getOfport();
 789
 790             String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 791             if (attachedMac == null) {
 792                 logger.warn("No AttachedMac seen in {}", intf);
 793                 return;
 794             }
 795
 796             List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
 797             for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
 798                 Long ofPort = 0L;
 799                 if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
 800                     long tunnelOFPort = (Long)intf.getOfport();
 801
 802                     if (tunnelOFPort == -1) {
 803                         logger.error("Could not Identify Tunnel port {} -> OF ({}) on {}",
 804                                 tunIntf.getName(), tunnelOFPort, node);
 805                         return;
 806                     }
 807                     logger.debug("Identified Tunnel port {} -> OF ({}) on {}",
 808                             tunIntf.getName(), tunnelOFPort, node);
 809
 810                     if (!local) {
 811                         programRemoteEgressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
 812                                 tunnelOFPort, localPort);
 813                     }
 814                     logger.trace("program local ingress tunnel rules: node {}, intf {}",
 815                             node.getNodeId().getValue(), intf.getName());
 816                     if (local) {
 817                         programLocalIngressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
 818                                 tunnelOFPort, localPort);
 819                     }
 820                     return;
 821                 }
 822             }
 823         } catch (Exception e) {
 824             logger.error("", e);
 825         }
 826     }
 827
 828     private void removeTunnelRules (String tunnelType, String segmentationId, InetAddress dst, Node node,
 829                                     OvsdbTerminationPointAugmentation intf,
 830                                     boolean local, boolean isLastInstanceOnNode) {
 831         try {
 832             Long dpid = getIntegrationBridgeOFDPID(node);
 833             if (dpid == 0L) {
 834                 logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 835                 return;
 836             }
 837
 838             long localPort = (Long)intf.getOfport();
 839
 840             String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 841             if (attachedMac == null) {
 842                 logger.error("No AttachedMac seen in {}", intf);
 843                 return;
 844             }
 845
 846             List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
 847             for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
 848                 Long ofPort = 0L;
 849                 if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
 850                     long tunnelOFPort = (Long)intf.getOfport();
 851
 852                     if (tunnelOFPort == -1) {
 853                         logger.error("Could not Identify Tunnel port {} -> OF ({}) on {}",
 854                                 tunIntf.getName(), tunnelOFPort, node);
 855                         return;
 856                     }
 857                     logger.debug("Identified Tunnel port {} -> OF ({}) on {}",
 858                             tunIntf.getName(), tunnelOFPort, node);
 859
 860                     if (!local) {
 861                         removeRemoteEgressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
 862                                 tunnelOFPort, localPort);
 863                     }
 864                     if (local && isLastInstanceOnNode) {
 865                         removePerTunnelRules(node, dpid, segmentationId, tunnelOFPort);
 866                     }
 867                     return;
 868                 }
 869             }
 870         } catch (Exception e) {
 871             logger.error("", e);
 872         }
 873     }
 874
 875     private void programVlanRules (NeutronNetwork network, Node node, OvsdbTerminationPointAugmentation intf) {
 876         logger.debug("Program vlan rules for interface {}", intf.getName());
 877         Long dpid = getIntegrationBridgeOFDPID(node);
 878         if (dpid == 0L) {
 879             logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 880             return;
 881         }
 882
 883         long localPort = (Long)intf.getOfport();
 884
 885         String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 886         if (attachedMac == null) {
 887             logger.error("No AttachedMac seen in {}", intf);
 888             return;
 889         }
 890
 891         List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
 892         for (OvsdbTerminationPointAugmentation ethIntf : intfs) {
 893             Long ofPort = 0L;
 894             if (ethIntf.getName().equalsIgnoreCase(bridgeConfigurationManager.getPhysicalInterfaceName(
 895                     node, network.getProviderPhysicalNetwork()))) {
 896                 long ethOFPort = (Long)ethIntf.getOfport();
 897                 logger.debug("Identified eth port {} -> OF ({}) on {}",
 898                         ethIntf.getName(), ethOFPort, node);
 899                 // TODO: add logic to only add rule on remote nodes
 900                 programRemoteEgressVlanRules(node, dpid, network.getProviderSegmentationID(),
 901                         attachedMac, ethOFPort);
 902                 programLocalIngressVlanRules(node, dpid, network.getProviderSegmentationID(),
 903                         attachedMac, localPort, ethOFPort);
 904                 return;
 905             }
 906         }
 907     }
 908
 909     private void removeVlanRules (NeutronNetwork network, Node node, OvsdbTerminationPointAugmentation intf,
 910                                   boolean isLastInstanceOnNode) {
 911         logger.debug("Program vlan rules for interface {}", intf.getName());
 912         Long dpid = getIntegrationBridgeOFDPID(node);
 913         if (dpid == 0L) {
 914             logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
 915             return;
 916         }
 917
 918         long localPort = (Long)intf.getOfport();
 919
 920         String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
 921         if (attachedMac == null) {
 922             logger.error("No AttachedMac seen in {}", intf);
 923             return;
 924         }
 925
 926         List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
 927         for (OvsdbTerminationPointAugmentation ethIntf : intfs) {
 928             Long ofPort = 0L;
 929             if (ethIntf.getName().equalsIgnoreCase(bridgeConfigurationManager.getPhysicalInterfaceName(
 930                     node, network.getProviderPhysicalNetwork()))) {
 931                 long ethOFPort = (Long)ethIntf.getOfport();
 932                 logger.debug("Identified eth port {} -> OF ({}) on {}",
 933                         ethIntf.getName(), ethOFPort, node);
 934                 removeRemoteEgressVlanRules(node, dpid, network.getProviderSegmentationID(),
 935                         attachedMac, localPort, ethOFPort);
 936                 if (isLastInstanceOnNode) {
 937                     removePerVlanRules(node, dpid, network.getProviderSegmentationID(), localPort, ethOFPort);
 938                 }
 939                 return;
 940             }
 941         }
 942     }
 943
 944     @Override
 945     public boolean handleInterfaceUpdate(NeutronNetwork network, Node srcNode,
 946                                          OvsdbTerminationPointAugmentation intf) {
 947         //Preconditions.checkNotNull(connectionService);
 948         //List<Node> nodes = connectionService.getBridgeNodes();
 949         Preconditions.checkNotNull(nodeCacheManager);
 950         List<Node> nodes = nodeCacheManager.getOvsdbNodes();
 951         nodes.remove(srcNode);
 952         String networkType = network.getProviderNetworkType();
 953         String segmentationId = network.getProviderSegmentationID();
 954         programLocalRules(networkType, network.getProviderSegmentationID(), srcNode, intf);
 955
 956         if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
 957             programVlanRules(network, srcNode, intf);
 958         } else if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE)
 959                 || networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)){
 960             for (Node dstNode : nodes) {
 961                 InetAddress src = configurationService.getTunnelEndPoint(srcNode);
 962                 InetAddress dst = configurationService.getTunnelEndPoint(dstNode);
 963                 if ((src != null) && (dst != null)) {
 964                     if (addTunnelPort(srcNode, networkType, src, dst)) {
 965                         programTunnelRules(networkType, segmentationId, dst, srcNode, intf, true);
 966                     }
 967                     if (addTunnelPort(dstNode, networkType, dst, src)) {
 968                         programTunnelRules(networkType, segmentationId, src, dstNode, intf, false);
 969                     }
 970                 } else {
 971                     logger.warn("Tunnel end-point configuration missing. Please configure it in OpenVSwitch Table. "
 972                                     + "Check source {} or destination {}",
 973                             src != null ? src.getHostAddress() : "null",
 974                             dst != null ? dst.getHostAddress() : "null");
 975                 }
 976             }
 977         }
 978
 979         return true;
 980     }
 981
 982     private void triggerInterfaceUpdates(Node node) {
 983         List<TerminationPoint> tps = MdsalUtils.extractTerminationPoints(node);
 984         if (tps != null) {
 985             for (TerminationPoint tp : tps) {
 986                 OvsdbTerminationPointAugmentation port = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
 987                 if (port != null) {
 988                     NeutronNetwork neutronNetwork = tenantNetworkManager.getTenantNetwork(port);
 989                     if (neutronNetwork != null) {
 990                         logger.debug("Trigger Interface update for {}", port);
 991                         handleInterfaceUpdate(neutronNetwork, node, port);
 992                     }
 993                 }
 994             }
 995         } else {
 996             logger.warn("triggerInterfaceUpdates: tps are null");
 997         }
 998     }
 999
1000     @Override
1001     public boolean handleInterfaceDelete(String tunnelType, NeutronNetwork network, Node srcNode,
1002                                          OvsdbTerminationPointAugmentation intf, boolean isLastInstanceOnNode) {
1003         //Preconditions.checkNotNull(connectionService);
1004         //List<Node> nodes = connectionService.getBridgeNodes();
1005         Preconditions.checkNotNull(nodeCacheManager);
1006         List<Node> nodes = nodeCacheManager.getOvsdbNodes();
1007         nodes.remove(srcNode);
1008
1009         logger.info("Delete intf " + intf.getName() + " isLastInstanceOnNode " + isLastInstanceOnNode);
1010         List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(srcNode);
1011         if (MdsalUtils.isTunnel(intf)) {
1012             // Delete tunnel port
1013             try {
1014                 InetAddress src = InetAddress.getByName(
1015                         MdsalUtils.getOptionsValue(intf.getOptions(), "local_ip"));
1016                 InetAddress dst = InetAddress.getByName(
1017                         MdsalUtils.getOptionsValue(intf.getOptions(), "remote_ip"));
1018                 deleteTunnelPort(srcNode,
1019                         MdsalHelper.createOvsdbInterfaceType(intf.getInterfaceType()),
1020                         src, dst);
1021             } catch (Exception e) {
1022                 logger.error(e.getMessage(), e);
1023             }
1024         } else if (phyIfName.contains(intf.getName())) {
1025             deletePhysicalPort(srcNode, intf.getName());
1026         } else {
1027             // delete all other interfaces
1028             removeLocalRules(network.getProviderNetworkType(), network.getProviderSegmentationID(),
1029                     srcNode, intf);
1030
1031             if (network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
1032                 removeVlanRules(network, srcNode, intf, isLastInstanceOnNode);
1033             } else if (network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE)
1034                     || network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
1035
1036                 for (Node dstNode : nodes) {
1037                     InetAddress src = configurationService.getTunnelEndPoint(srcNode);
1038                     InetAddress dst = configurationService.getTunnelEndPoint(dstNode);
1039                     if ((src != null) && (dst != null)) {
1040                         logger.info("Remove tunnel rules for interface "
1041                                 + intf.getName() + " on srcNode " + srcNode.getNodeId().getValue());
1042                         removeTunnelRules(tunnelType, network.getProviderSegmentationID(),
1043                                 dst, srcNode, intf, true, isLastInstanceOnNode);
1044                         logger.info("Remove tunnel rules for interface "
1045                                 + intf.getName() + " on dstNode " + dstNode.getNodeId().getValue());
1046                         removeTunnelRules(tunnelType, network.getProviderSegmentationID(),
1047                                 src, dstNode, intf, false, isLastInstanceOnNode);
1048                     } else {
1049                         logger.warn("Tunnel end-point configuration missing. Please configure it in "
1050                                 + "OpenVSwitch Table. "
1051                                 + "Check source {} or destination {}",
1052                                 src != null ? src.getHostAddress() : "null",
1053                                 dst != null ? dst.getHostAddress() : "null");
1054                     }
1055                 }
1056             }
1057         }
1058         return true;
1059     }
1060
1061     @Override
1062     public void initializeFlowRules(Node node) {
1063         initializeFlowRules(node, configurationService.getIntegrationBridgeName());
1064         initializeFlowRules(node, configurationService.getExternalBridgeName());
1065         triggerInterfaceUpdates(node);
1066     }
1067
1068     private void initializeFlowRules(Node node, String bridgeName) {
1069         Long dpid = MdsalUtils.getDataPathId(node);
1070         String datapathId = MdsalUtils.getDatapathId(node);
1071         logger.info("initializeFlowRules: bridgeName: {}, dpid: {} - {}",
1072                 bridgeName, dpid, datapathId);
1073
1074         if (dpid == 0L) {
1075             logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
1076             return;
1077         }
1078
1079         /*
1080          * Table(0) Rule #1
1081          * ----------------
1082          * Match: LLDP (0x88CCL)
1083          * Action: Packet_In to Controller Reserved Port
1084          */
1085
1086         writeLLDPRule(dpid);
1087
1088         if (bridgeName.equals(configurationService.getExternalBridgeName())) {
1089             writeNormalRule(dpid);
1090         }
1091     }
1092
1093     /*
1094      * Create an LLDP Flow Rule to encapsulate into
1095      * a packet_in that is sent to the controller
1096      * for topology handling.
1097      * Match: Ethertype 0x88CCL
1098      * Action: Punt to Controller in a Packet_In msg
1099      */
1100
1101     private void writeLLDPRule(Long dpidLong) {
1102         classifierProvider.programLLDPPuntRule(dpidLong);
1103     }
1104
1105     /*
1106      * Create a NORMAL Table Miss Flow Rule
1107      * Match: any
1108      * Action: forward to NORMAL pipeline
1109      */
1110
1111     private void writeNormalRule(Long dpidLong) {
1112
1113         String nodeName = Constants.OPENFLOW_NODE_PREFIX + dpidLong;
1114
1115         MatchBuilder matchBuilder = new MatchBuilder();
1116         NodeBuilder nodeBuilder = createNodeBuilder(nodeName);
1117         FlowBuilder flowBuilder = new FlowBuilder();
1118
1119         // Create the OF Actions and Instructions
1120         InstructionBuilder ib = new InstructionBuilder();
1121         InstructionsBuilder isb = new InstructionsBuilder();
1122
1123         // Instructions List Stores Individual Instructions
1124         List<Instruction> instructions = Lists.newArrayList();
1125
1126         // Call the InstructionBuilder Methods Containing Actions
1127         InstructionUtils.createNormalInstructions(nodeName, ib);
1128         ib.setOrder(0);
1129         ib.setKey(new InstructionKey(0));
1130         instructions.add(ib.build());
1131
1132         // Add InstructionBuilder to the Instruction(s)Builder List
1133         isb.setInstruction(instructions);
1134
1135         // Add InstructionsBuilder to FlowBuilder
1136         flowBuilder.setInstructions(isb.build());
1137
1138         String flowId = "NORMAL";
1139         flowBuilder.setId(new FlowId(flowId));
1140         FlowKey key = new FlowKey(new FlowId(flowId));
1141         flowBuilder.setMatch(matchBuilder.build());
1142         flowBuilder.setPriority(0);
1143         flowBuilder.setBarrier(true);
1144         flowBuilder.setTableId((short) 0);
1145         flowBuilder.setKey(key);
1146         flowBuilder.setFlowName(flowId);
1147         flowBuilder.setHardTimeout(0);
1148         flowBuilder.setIdleTimeout(0);
1149         writeFlow(flowBuilder, nodeBuilder);
1150     }
1151
1152     /*
1153      * (Table:0) Ingress Tunnel Traffic
1154      * Match: OpenFlow InPort and Tunnel ID
1155      * Action: GOTO Local Table (10)
1156      * table=0,tun_id=0x5,in_port=10, actions=goto_table:2
1157      */
1158
1159     private void handleTunnelIn(Long dpidLong, Short writeTable,
1160             Short goToTableId, String segmentationId,
1161             Long ofPort, boolean write) {
1162         classifierProvider.programTunnelIn(dpidLong, segmentationId, ofPort, write);
1163     }
1164
1165     /*
1166      * (Table:0) Ingress VLAN Traffic
1167      * Match: OpenFlow InPort and vlan ID
1168      * Action: GOTO Local Table (20)
1169      * table=0,vlan_id=0x5,in_port=10, actions=goto_table:2
1170      */
1171
1172     private void handleVlanIn(Long dpidLong, Short writeTable, Short goToTableId,
1173             String segmentationId,  Long ethPort, boolean write) {
1174         classifierProvider.programVlanIn(dpidLong, segmentationId, ethPort, write);
1175     }
1176
1177     /*
1178      * (Table:0) Egress VM Traffic Towards TEP
1179      * Match: Destination Ethernet Addr and OpenFlow InPort
1180      * Instruction: Set TunnelID and GOTO Table Tunnel Table (n)
1181      * table=0,in_port=2,dl_src=00:00:00:00:00:01 \
1182      * actions=set_field:5->tun_id,goto_table=1"
1183      */
1184
1185     private void handleLocalInPort(Long dpidLong, Short writeTable, Short goToTableId,
1186             String segmentationId, Long inPort, String attachedMac,
1187             boolean write) {
1188         classifierProvider.programLocalInPort(dpidLong, segmentationId, inPort, attachedMac, write);
1189     }
1190
1191     /*
1192      * (Table:0) Egress VM Traffic Towards TEP
1193      * Match: Source Ethernet Addr and OpenFlow InPort
1194      * Instruction: Set VLANID and GOTO Table Egress (n)
1195      * table=0,in_port=2,dl_src=00:00:00:00:00:01 \
1196      * actions=push_vlan, set_field:5->vlan_id,goto_table=1"
1197      */
1198
1199     private void handleLocalInPortSetVlan(Long dpidLong, Short writeTable,
1200             Short goToTableId, String segmentationId,
1201             Long inPort, String attachedMac,
1202             boolean write) {
1203         classifierProvider.programLocalInPortSetVlan(dpidLong, segmentationId, inPort, attachedMac, write);
1204     }
1205
1206     /*
1207      * (Table:0) Drop frames source from a VM that do not
1208      * match the associated MAC address of the local VM.
1209      * Match: Low priority anything not matching the VM SMAC
1210      * Instruction: Drop
1211      * table=0,priority=16384,in_port=1 actions=drop"
1212      */
1213
1214     private void handleDropSrcIface(Long dpidLong, Long inPort, boolean write) {
1215         classifierProvider.programDropSrcIface(dpidLong, inPort, write);
1216     }
1217
1218     /*
1219      * (Table:1) Egress Tunnel Traffic
1220      * Match: Destination Ethernet Addr and Local InPort
1221      * Instruction: Set TunnelID and GOTO Table Tunnel Table (n)
1222      * table=1,tun_id=0x5,dl_dst=00:00:00:00:00:08 \
1223      * actions=output:10,goto_table:2"
1224      */
1225     private void handleTunnelOut(Long dpidLong, Short writeTable,
1226             Short goToTableId, String segmentationId,
1227             Long OFPortOut, String attachedMac,
1228             boolean write) {
1229         l2ForwardingProvider.programTunnelOut(dpidLong, segmentationId, OFPortOut, attachedMac, write);
1230     }
1231
1232     /*
1233      * (Table:1) Egress VLAN Traffic
1234      * Match: Destination Ethernet Addr and VLAN id
1235      * Instruction: GOTO Table Table 2
1236      * table=1,vlan_id=0x5,dl_dst=00:00:00:00:00:08 \
1237      * actions= goto_table:2"
1238      */
1239
1240     private void handleVlanOut(Long dpidLong, Short writeTable,
1241             Short goToTableId, String segmentationId,
1242             Long ethPort, String attachedMac, boolean write) {
1243         l2ForwardingProvider.programVlanOut(dpidLong, segmentationId, ethPort, attachedMac, write);
1244     }
1245
1246     /*
1247      * (Table:1) Egress Tunnel Traffic
1248      * Match: Destination Ethernet Addr and Local InPort
1249      * Instruction: Set TunnelID and GOTO Table Tunnel Table (n)
1250      * table=1,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
1251      * actions=output:10,output:11,goto_table:2
1252      */
1253
1254     private void handleTunnelFloodOut(Long dpidLong, Short writeTable,
1255             Short localTable, String segmentationId,
1256             Long OFPortOut, boolean write) {
1257         l2ForwardingProvider.programTunnelFloodOut(dpidLong, segmentationId, OFPortOut, write);
1258     }
1259
1260     /*
1261      * (Table:1) Egress VLAN Traffic
1262      * Match: Destination Ethernet Addr and VLAN id
1263      * Instruction: GOTO table 2 and Output port eth interface
1264      * Example: table=1,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
1265      * actions=output:eth1,goto_table:2
1266      */
1267
1268     private void handleVlanFloodOut(Long dpidLong, Short writeTable,
1269             Short localTable, String segmentationId,
1270             Long localPort, Long ethPort, boolean write) {
1271         //l2ForwardingProvider.programVlanFloodOut(dpidLong, segmentationId, localPort, ethPort, write);
1272     }
1273
1274     /*
1275      * (Table:1) Table Drain w/ Catch All
1276      * Match: Tunnel ID
1277      * Action: GOTO Local Table (10)
1278      * table=2,priority=8192,tun_id=0x5 actions=drop
1279      */
1280
1281     private void handleTunnelMiss(Long dpidLong, Short writeTable,
1282             Short goToTableId, String segmentationId,
1283             boolean write) {
1284         l2ForwardingProvider.programTunnelMiss(dpidLong, segmentationId, write);
1285     }
1286
1287
1288     /*
1289      * (Table:1) Table Drain w/ Catch All
1290      * Match: Vlan ID
1291      * Action: Output port eth interface
1292      * table=1,priority=8192,vlan_id=0x5 actions= output port:eth1
1293      * table=110,priority=8192,dl_vlan=2001 actions=output:2
1294      */
1295
1296     private void handleVlanMiss(Long dpidLong, Short writeTable,
1297             Short goToTableId, String segmentationId,
1298             Long ethPort, boolean write) {
1299         l2ForwardingProvider.programVlanMiss(dpidLong, segmentationId, ethPort, write);
1300     }
1301
1302     /*
1303      * (Table:1) Local Broadcast Flood
1304      * Match: Tunnel ID and dMAC
1305      * Action: Output Port
1306      * table=2,tun_id=0x5,dl_dst=00:00:00:00:00:01 actions=output:2
1307      */
1308
1309     private void handleLocalUcastOut(Long dpidLong, Short writeTable,
1310             String segmentationId, Long localPort,
1311             String attachedMac, boolean write) {
1312         l2ForwardingProvider.programLocalUcastOut(dpidLong, segmentationId, localPort, attachedMac, write);
1313     }
1314
1315     /*
1316      * (Table:2) Local VLAN unicast
1317      * Match: VLAN ID and dMAC
1318      * Action: Output Port
1319      * table=2,vlan_id=0x5,dl_dst=00:00:00:00:00:01 actions=output:2
1320      */
1321
1322     private void handleLocalVlanUcastOut(Long dpidLong, Short writeTable,
1323             String segmentationId, Long localPort,
1324             String attachedMac, boolean write) {
1325         l2ForwardingProvider.programLocalVlanUcastOut(dpidLong, segmentationId, localPort, attachedMac, write);
1326     }
1327
1328     /*
1329      * (Table:2) Local Broadcast Flood
1330      * Match: Tunnel ID and dMAC (::::FF:FF)
1331      * table=2,priority=16384,tun_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
1332      * actions=output:2,3,4,5
1333      */
1334
1335     private void handleLocalBcastOut(Long dpidLong, Short writeTable,
1336             String segmentationId, Long localPort,
1337             boolean write) {
1338         l2ForwardingProvider.programLocalBcastOut(dpidLong, segmentationId, localPort, write);
1339     }
1340
1341     /*
1342      * (Table:2) Local VLAN Broadcast Flood
1343      * Match: vlan ID and dMAC (::::FF:FF)
1344      * table=2,priority=16384,vlan_id=0x5,dl_dst=ff:ff:ff:ff:ff:ff \
1345      * actions=strip_vlan, output:2,3,4,5
1346      * table=110,dl_vlan=2001,dl_dst=01:00:00:00:00:00/01:00:00:00:00:00 actions=output:2,pop_vlan,output:1,output:3,output:4
1347      */
1348
1349     private void handleLocalVlanBcastOut(Long dpidLong, Short writeTable, String segmentationId,
1350                                          Long localPort, Long ethPort, boolean write) {
1351         l2ForwardingProvider.programLocalVlanBcastOut(dpidLong, segmentationId, localPort, ethPort, write);
1352     }
1353
1354     /*
1355      * (Table:1) Local Table Miss
1356      * Match: Any Remaining Flows w/a TunID
1357      * Action: Drop w/ a low priority
1358      * table=2,priority=8192,tun_id=0x5 actions=drop
1359      */
1360
1361     private void handleLocalTableMiss(Long dpidLong, Short writeTable,
1362             String segmentationId, boolean write) {
1363         l2ForwardingProvider.programLocalTableMiss(dpidLong, segmentationId, write);
1364     }
1365
1366     /*
1367      * (Table:1) Local Table Miss
1368      * Match: Any Remaining Flows w/a VLAN ID
1369      * Action: Drop w/ a low priority
1370      * table=2,priority=8192,vlan_id=0x5 actions=drop
1371      */
1372
1373     private void handleLocalVlanTableMiss(Long dpidLong, Short writeTable,
1374             String segmentationId, boolean write) {
1375         l2ForwardingProvider.programLocalVlanTableMiss(dpidLong, segmentationId, write);
1376     }
1377
1378     private Group getGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
1379         Preconditions.checkNotNull(mdsalConsumer);
1380         if (mdsalConsumer == null) {
1381             logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
1382             return null;
1383         }
1384
1385         dataBroker = mdsalConsumer.getDataBroker();
1386         if (dataBroker == null) {
1387             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1388             return null;
1389         }
1390
1391         InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1392                 .rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
1393                         new GroupKey(groupBuilder.getGroupId())).build();
1394         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
1395         try {
1396             Optional<Group> data = readTx.read(LogicalDatastoreType.CONFIGURATION, path1).get();
1397             if (data.isPresent()) {
1398                 return data.get();
1399             }
1400         } catch (InterruptedException|ExecutionException e) {
1401             logger.error(e.getMessage(), e);
1402         }
1403
1404         logger.debug("Cannot find data for Group " + groupBuilder.getGroupName());
1405         return null;
1406     }
1407
1408     private void writeGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
1409         Preconditions.checkNotNull(mdsalConsumer);
1410         if (mdsalConsumer == null) {
1411             logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
1412             return;
1413         }
1414
1415         dataBroker = mdsalConsumer.getDataBroker();
1416         if (dataBroker == null) {
1417             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1418             return;
1419         }
1420
1421         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
1422         InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1423                 .rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
1424                         new GroupKey(groupBuilder.getGroupId())).build();
1425         modification.put(LogicalDatastoreType.CONFIGURATION, path1, groupBuilder.build(), true /*createMissingParents*/);
1426
1427         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
1428         try {
1429             commitFuture.get();  // TODO: Make it async (See bug 1362)
1430             logger.debug("Transaction success for write of Group "+groupBuilder.getGroupName());
1431         } catch (InterruptedException|ExecutionException e) {
1432             logger.error(e.getMessage(), e);
1433         }
1434     }
1435
1436     private void removeGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
1437         Preconditions.checkNotNull(mdsalConsumer);
1438         if (mdsalConsumer == null) {
1439             logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
1440             return;
1441         }
1442
1443         dataBroker = mdsalConsumer.getDataBroker();
1444         if (dataBroker == null) {
1445             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1446             return;
1447         }
1448
1449         WriteTransaction modification = dataBroker.newWriteOnlyTransaction();
1450         InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1451                 .rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
1452                         new GroupKey(groupBuilder.getGroupId())).build();
1453         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
1454         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
1455
1456         try {
1457             commitFuture.get();  // TODO: Make it async (See bug 1362)
1458             logger.debug("Transaction success for deletion of Group "+groupBuilder.getGroupName());
1459         } catch (InterruptedException|ExecutionException e) {
1460             logger.error(e.getMessage(), e);
1461         }
1462     }
1463
1464     private Flow getFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
1465         Preconditions.checkNotNull(mdsalConsumer);
1466         if (mdsalConsumer == null) {
1467             logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
1468             return null;
1469         }
1470
1471         dataBroker = mdsalConsumer.getDataBroker();
1472         if (dataBroker == null) {
1473             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1474             return null;
1475         }
1476
1477         InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1478                 .rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class,
1479                         new TableKey(flowBuilder.getTableId())).child(Flow.class, flowBuilder.getKey()).build();
1480
1481         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
1482         try {
1483             Optional<Flow> data = readTx.read(LogicalDatastoreType.CONFIGURATION, path1).get();
1484             if (data.isPresent()) {
1485                 return data.get();
1486             }
1487         } catch (InterruptedException|ExecutionException e) {
1488             logger.error(e.getMessage(), e);
1489         }
1490
1491         logger.debug("Cannot find data for Flow " + flowBuilder.getFlowName());
1492         return null;
1493     }
1494
1495     private void writeFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
1496         Preconditions.checkNotNull(mdsalConsumer);
1497         if (mdsalConsumer == null) {
1498             logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
1499             return;
1500         }
1501
1502         dataBroker = mdsalConsumer.getDataBroker();
1503         if (dataBroker == null) {
1504             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1505             return;
1506         }
1507
1508         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
1509         InstanceIdentifier<Flow> path1 =
1510                 InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1511                                 .rev130819.nodes.Node.class,
1512                         nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class,
1513                         new TableKey(flowBuilder.getTableId())).child(Flow.class, flowBuilder.getKey()).build();
1514
1515         //modification.put(LogicalDatastoreType.OPERATIONAL, path1, flowBuilder.build());
1516         modification.put(LogicalDatastoreType.CONFIGURATION, path1, flowBuilder.build(),
1517                 true);//createMissingParents
1518
1519
1520         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
1521         try {
1522             commitFuture.get();  // TODO: Make it async (See bug 1362)
1523             logger.debug("Transaction success for write of Flow "+flowBuilder.getFlowName());
1524         } catch (InterruptedException|ExecutionException e) {
1525             logger.error(e.getMessage(), e);
1526         }
1527     }
1528
1529     private void removeFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
1530         Preconditions.checkNotNull(mdsalConsumer);
1531         if (mdsalConsumer == null) {
1532             logger.error("ERROR finding MDSAL Service.");
1533             return;
1534         }
1535
1536         dataBroker = mdsalConsumer.getDataBroker();
1537         if (dataBroker == null) {
1538             logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
1539             return;
1540         }
1541
1542         WriteTransaction modification = dataBroker.newWriteOnlyTransaction();
1543         InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class)
1544                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
1545                         .rev130819.nodes.Node.class, nodeBuilder.getKey())
1546                         .augmentation(FlowCapableNode.class).child(Table.class,
1547                                 new TableKey(flowBuilder.getTableId())).child(Flow.class, flowBuilder.getKey()).build();
1548         //modification.delete(LogicalDatastoreType.OPERATIONAL, nodeBuilderToInstanceId(nodeBuilder));
1549         //modification.delete(LogicalDatastoreType.OPERATIONAL, path1);
1550         //modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder));
1551         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
1552
1553         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
1554         try {
1555             commitFuture.get();  // TODO: Make it async (See bug 1362)
1556             logger.debug("Transaction success for deletion of Flow "+flowBuilder.getFlowName());
1557         } catch (InterruptedException|ExecutionException e) {
1558             logger.error(e.getMessage(), e);
1559         }
1560     }
1561
1562     /**
1563      * Create Output Port Group Instruction
1564      *
1565      * @param ib       Map InstructionBuilder without any instructions
1566      * @param dpidLong Long the datapath ID of a switch/node
1567      * @param port     Long representing a port on a switch/node
1568      * @return ib InstructionBuilder Map with instructions
1569      */
1570     protected InstructionBuilder createOutputGroupInstructions(NodeBuilder nodeBuilder,
1571             InstructionBuilder ib,
1572             Long dpidLong, Long port ,
1573             List<Instruction> instructions) {
1574         NodeConnectorId ncid = new NodeConnectorId(Constants.OPENFLOW_NODE_PREFIX + dpidLong + ":" + port);
1575         logger.debug("createOutputGroupInstructions() Node Connector ID is - Type=openflow: DPID={} port={} existingInstructions={}", dpidLong, port, instructions);
1576
1577         List<Action> actionList = Lists.newArrayList();
1578         ActionBuilder ab = new ActionBuilder();
1579
1580         List<Action> existingActions;
1581         if (instructions != null) {
1582             for (Instruction in : instructions) {
1583                 if (in.getInstruction() instanceof ApplyActionsCase) {
1584                     existingActions = (((ApplyActionsCase) in.getInstruction()).getApplyActions().getAction());
1585                     actionList.addAll(existingActions);
1586                 }
1587             }
1588         }
1589
1590         GroupBuilder groupBuilder = new GroupBuilder();
1591         Group group = null;
1592
1593         /* Create output action for this port*/
1594         OutputActionBuilder oab = new OutputActionBuilder();
1595         oab.setOutputNodeConnector(ncid);
1596         ab.setAction(new OutputActionCaseBuilder().setOutputAction(oab.build()).build());
1597         logger.debug("createOutputGroupInstructions(): output action {}", ab.build());
1598         boolean addNew = true;
1599         boolean groupActionAdded = false;
1600
1601         /* Find the group action and get the group */
1602         for (Action action : actionList) {
1603             if (action.getAction() instanceof GroupActionCase) {
1604                 groupActionAdded = true;
1605                 GroupActionCase groupAction = (GroupActionCase) action.getAction();
1606                 Long id = groupAction.getGroupAction().getGroupId();
1607                 String groupName = groupAction.getGroupAction().getGroup();
1608                 GroupKey key = new GroupKey(new GroupId(id));
1609
1610                 groupBuilder.setGroupId(new GroupId(id));
1611                 groupBuilder.setGroupName(groupName);
1612                 groupBuilder.setGroupType(GroupTypes.GroupAll);
1613                 groupBuilder.setKey(key);
1614                 group = getGroup(groupBuilder, nodeBuilder);
1615                 logger.debug("createOutputGroupInstructions: group {}", group);
1616                 break;
1617             }
1618         }
1619
1620         logger.debug("createOutputGroupInstructions: groupActionAdded {}", groupActionAdded);
1621         if (groupActionAdded) {
1622             /* modify the action bucket in group */
1623             groupBuilder = new GroupBuilder(group);
1624             Buckets buckets = groupBuilder.getBuckets();
1625             for (Bucket bucket : buckets.getBucket()) {
1626                 List<Action> bucketActions = bucket.getAction();
1627                 logger.debug("createOutputGroupInstructions: bucketActions {}", bucketActions);
1628                 for (Action action : bucketActions) {
1629                     if (action.getAction() instanceof OutputActionCase) {
1630                         OutputActionCase opAction = (OutputActionCase)action.getAction();
1631                         /* If output port action already in the action list of one of the buckets, skip */
1632                         if (opAction.getOutputAction().getOutputNodeConnector().equals(new Uri(ncid))) {
1633                             addNew = false;
1634                             break;
1635                         }
1636                     }
1637                 }
1638             }
1639             logger.debug("createOutputGroupInstructions: addNew {}", addNew);
1640             if (addNew) {
1641                 /* the new output action is not in the bucket, add to bucket */
1642                 if (!buckets.getBucket().isEmpty()) {
1643                     Bucket bucket = buckets.getBucket().get(0);
1644                     List<Action> bucketActionList = Lists.newArrayList();
1645                     bucketActionList.addAll(bucket.getAction());
1646                     /* set order for new action and add to action list */
1647                     ab.setOrder(bucketActionList.size());
1648                     ab.setKey(new ActionKey(bucketActionList.size()));
1649                     bucketActionList.add(ab.build());
1650
1651                     /* set bucket and buckets list. Reset groupBuilder with new buckets.*/
1652                     BucketsBuilder bucketsBuilder = new BucketsBuilder();
1653                     List<Bucket> bucketList = Lists.newArrayList();
1654                     BucketBuilder bucketBuilder = new BucketBuilder();
1655                     bucketBuilder.setBucketId(new BucketId((long) 1));
1656                     bucketBuilder.setKey(new BucketKey(new BucketId((long) 1)));
1657                     bucketBuilder.setAction(bucketActionList);
1658                     bucketList.add(bucketBuilder.build());
1659                     bucketsBuilder.setBucket(bucketList);
1660                     groupBuilder.setBuckets(bucketsBuilder.build());
1661                     logger.debug("createOutputGroupInstructions: bucketList {}", bucketList);
1662                 }
1663             }
1664         } else {
1665             /* create group */
1666             groupBuilder = new GroupBuilder();
1667             groupBuilder.setGroupType(GroupTypes.GroupAll);
1668             groupBuilder.setGroupId(new GroupId(groupId));
1669             groupBuilder.setKey(new GroupKey(new GroupId(groupId)));
1670             groupBuilder.setGroupName("Output port group " + groupId);
1671             groupBuilder.setBarrier(false);
1672
1673             BucketsBuilder bucketBuilder = new BucketsBuilder();
1674             List<Bucket> bucketList = Lists.newArrayList();
1675             BucketBuilder bucket = new BucketBuilder();
1676             bucket.setBucketId(new BucketId((long) 1));
1677             bucket.setKey(new BucketKey(new BucketId((long) 1)));
1678
1679             /* put output action to the bucket */
1680             List<Action> bucketActionList = Lists.newArrayList();
1681             /* set order for new action and add to action list */
1682             ab.setOrder(bucketActionList.size());
1683             ab.setKey(new ActionKey(bucketActionList.size()));
1684             bucketActionList.add(ab.build());
1685
1686             bucket.setAction(bucketActionList);
1687             bucketList.add(bucket.build());
1688             bucketBuilder.setBucket(bucketList);
1689             groupBuilder.setBuckets(bucketBuilder.build());
1690
1691             /* Add new group action */
1692             GroupActionBuilder groupActionB = new GroupActionBuilder();
1693             groupActionB.setGroupId(groupId);
1694             groupActionB.setGroup("Output port group " + groupId);
1695             ab = new ActionBuilder();
1696             ab.setAction(new GroupActionCaseBuilder().setGroupAction(groupActionB.build()).build());
1697             ab.setOrder(actionList.size());
1698             ab.setKey(new ActionKey(actionList.size()));
1699             actionList.add(ab.build());
1700
1701             groupId++;
1702         }
1703         logger.debug("createOutputGroupInstructions: group {}", groupBuilder.build());
1704         logger.debug("createOutputGroupInstructions: actionList {}", actionList);
1705
1706         if (addNew) {
1707             /* rewrite the group to group table */
1708             writeGroup(groupBuilder, nodeBuilder);
1709         }
1710
1711         // Create an Apply Action
1712         ApplyActionsBuilder aab = new ApplyActionsBuilder();
1713         aab.setAction(actionList);
1714         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1715
1716         return ib;
1717     }
1718
1719     /**
1720      * Remove Output Port from action list in group bucket
1721      *
1722      * @param ib       Map InstructionBuilder without any instructions
1723      * @param dpidLong Long the datapath ID of a switch/node
1724      * @param port     Long representing a port on a switch/node
1725      * @return ib InstructionBuilder Map with instructions
1726      */
1727     protected boolean removeOutputPortFromGroup(NodeBuilder nodeBuilder, InstructionBuilder ib,
1728             Long dpidLong, Long port , List<Instruction> instructions) {
1729
1730         NodeConnectorId ncid = new NodeConnectorId(Constants.OPENFLOW_NODE_PREFIX + dpidLong + ":" + port);
1731         logger.debug("removeOutputPortFromGroup() Node Connector ID is - Type=openflow: DPID={} port={} existingInstructions={}", dpidLong, port, instructions);
1732
1733         List<Action> actionList = Lists.newArrayList();
1734         ActionBuilder ab;
1735
1736         List<Action> existingActions;
1737         if (instructions != null) {
1738             for (Instruction in : instructions) {
1739                 if (in.getInstruction() instanceof ApplyActionsCase) {
1740                     existingActions = (((ApplyActionsCase) in.getInstruction()).getApplyActions().getAction());
1741                     actionList.addAll(existingActions);
1742                     break;
1743                 }
1744             }
1745         }
1746
1747         GroupBuilder groupBuilder = new GroupBuilder();
1748         Group group = null;
1749         boolean groupActionAdded = false;
1750         /* Find the group action and get the group */
1751         for (Action action : actionList) {
1752             if (action.getAction() instanceof GroupActionCase) {
1753                 groupActionAdded = true;
1754                 GroupActionCase groupAction = (GroupActionCase) action.getAction();
1755                 Long id = groupAction.getGroupAction().getGroupId();
1756                 String groupName = groupAction.getGroupAction().getGroup();
1757                 GroupKey key = new GroupKey(new GroupId(id));
1758
1759                 groupBuilder.setGroupId(new GroupId(id));
1760                 groupBuilder.setGroupName(groupName);
1761                 groupBuilder.setGroupType(GroupTypes.GroupAll);
1762                 groupBuilder.setKey(key);
1763                 group = getGroup(groupBuilder, nodeBuilder);
1764                 break;
1765             }
1766         }
1767
1768         if (groupActionAdded) {
1769             /* modify the action bucket in group */
1770             groupBuilder = new GroupBuilder(group);
1771             Buckets buckets = groupBuilder.getBuckets();
1772             List<Action> bucketActions = Lists.newArrayList();
1773             for (Bucket bucket : buckets.getBucket()) {
1774                 int index = 0;
1775                 boolean isPortDeleted = false;
1776                 bucketActions = bucket.getAction();
1777                 for (Action action : bucketActions) {
1778                     if (action.getAction() instanceof OutputActionCase) {
1779                         OutputActionCase opAction = (OutputActionCase)action.getAction();
1780                         if (opAction.getOutputAction().getOutputNodeConnector().equals(new Uri(ncid))) {
1781                             /* Find the output port in action list and remove */
1782                             index = bucketActions.indexOf(action);
1783                             bucketActions.remove(action);
1784                             isPortDeleted = true;
1785                             break;
1786                         }
1787                     }
1788                 }
1789                 if (isPortDeleted && !bucketActions.isEmpty()) {
1790                     for (int i = index; i< bucketActions.size(); i++) {
1791                         Action action = bucketActions.get(i);
1792                         if (action.getOrder() != i) {
1793                             /* Shift the action order */
1794                             ab = new ActionBuilder();
1795                             ab.setAction(action.getAction());
1796                             ab.setOrder(i);
1797                             ab.setKey(new ActionKey(i));
1798                             Action actionNewOrder = ab.build();
1799                             bucketActions.remove(action);
1800                             bucketActions.add(i, actionNewOrder);
1801                         }
1802                     }
1803
1804                 } else if (bucketActions.isEmpty()) {
1805                     /* remove bucket with empty action list */
1806                     buckets.getBucket().remove(bucket);
1807                     break;
1808                 }
1809             }
1810             if (!buckets.getBucket().isEmpty()) {
1811                 /* rewrite the group to group table */
1812                 /* set bucket and buckets list. Reset groupBuilder with new buckets.*/
1813                 BucketsBuilder bucketsBuilder = new BucketsBuilder();
1814                 List<Bucket> bucketList = Lists.newArrayList();
1815                 BucketBuilder bucketBuilder = new BucketBuilder();
1816                 bucketBuilder.setBucketId(new BucketId((long) 1));
1817                 bucketBuilder.setKey(new BucketKey(new BucketId((long) 1)));
1818                 bucketBuilder.setAction(bucketActions);
1819                 bucketList.add(bucketBuilder.build());
1820                 bucketsBuilder.setBucket(bucketList);
1821                 groupBuilder.setBuckets(bucketsBuilder.build());
1822                 logger.debug("removeOutputPortFromGroup: bucketList {}", bucketList);
1823
1824                 writeGroup(groupBuilder, nodeBuilder);
1825                 ApplyActionsBuilder aab = new ApplyActionsBuilder();
1826                 aab.setAction(actionList);
1827                 ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1828                 return false;
1829             } else {
1830                 /* remove group with empty bucket. return true to delete flow */
1831                 removeGroup(groupBuilder, nodeBuilder);
1832                 return true;
1833             }
1834         } else {
1835             /* no group for port list. flow can be removed */
1836             return true;
1837         }
1838     }
1839
1840     @Override
1841     public void initializeOFFlowRules(Node openflowNode) {
1842         String bridgeName = MdsalUtils.getBridgeName(openflowNode);
1843         logger.info("initializeOFFlowRules: bridgeName: {}", bridgeName);
1844         if (bridgeName.equals(configurationService.getIntegrationBridgeName())) {
1845             initializeFlowRules(openflowNode, configurationService.getIntegrationBridgeName());
1846             triggerInterfaceUpdates(openflowNode);
1847         } else if (bridgeName.equals(configurationService.getExternalBridgeName())) {
1848             initializeFlowRules(openflowNode, configurationService.getExternalBridgeName());
1849             triggerInterfaceUpdates(openflowNode);
1850         }
1851     }
1852
1853     public static NodeBuilder createNodeBuilder(String nodeId) {
1854         NodeBuilder builder = new NodeBuilder();
1855         builder.setId(new NodeId(nodeId));
1856         builder.setKey(new NodeKey(builder.getId()));
1857         return builder;
1858     }
1859 }