opendaylight/forwardingrulesmanager/implementation/src/main/java/org/opendaylight/controller/forwardingrulesmanager/internal/ForwardingRulesManager.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.forwardingrulesmanager.internal;
  10
  11 import java.io.FileNotFoundException;
  12 import java.io.IOException;
  13 import java.io.ObjectInputStream;
  14 import java.util.ArrayList;
  15 import java.util.Collections;
  16 import java.util.EnumSet;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Map.Entry;
  21 import java.util.Set;
  22 import java.util.concurrent.BlockingQueue;
  23 import java.util.concurrent.Callable;
  24 import java.util.concurrent.ConcurrentHashMap;
  25 import java.util.concurrent.ConcurrentMap;
  26 import java.util.concurrent.ExecutionException;
  27 import java.util.concurrent.ExecutorService;
  28 import java.util.concurrent.Executors;
  29 import java.util.concurrent.LinkedBlockingQueue;
  30
  31 import org.opendaylight.controller.clustering.services.CacheConfigException;
  32 import org.opendaylight.controller.clustering.services.CacheExistException;
  33 import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
  34 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
  35 import org.opendaylight.controller.clustering.services.IClusterServices;
  36 import org.opendaylight.controller.configuration.ConfigurationObject;
  37 import org.opendaylight.controller.configuration.IConfigurationContainerAware;
  38 import org.opendaylight.controller.configuration.IConfigurationContainerService;
  39 import org.opendaylight.controller.connectionmanager.IConnectionManager;
  40 import org.opendaylight.controller.containermanager.IContainerManager;
  41 import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
  42 import org.opendaylight.controller.forwardingrulesmanager.FlowEntry;
  43 import org.opendaylight.controller.forwardingrulesmanager.FlowEntryInstall;
  44 import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
  45 import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManagerAware;
  46 import org.opendaylight.controller.forwardingrulesmanager.PortGroup;
  47 import org.opendaylight.controller.forwardingrulesmanager.PortGroupChangeListener;
  48 import org.opendaylight.controller.forwardingrulesmanager.PortGroupConfig;
  49 import org.opendaylight.controller.forwardingrulesmanager.PortGroupProvider;
  50 import org.opendaylight.controller.forwardingrulesmanager.implementation.data.FlowEntryDistributionOrder;
  51 import org.opendaylight.controller.sal.action.Action;
  52 import org.opendaylight.controller.sal.action.ActionType;
  53 import org.opendaylight.controller.sal.action.Enqueue;
  54 import org.opendaylight.controller.sal.action.Flood;
  55 import org.opendaylight.controller.sal.action.FloodAll;
  56 import org.opendaylight.controller.sal.action.Output;
  57 import org.opendaylight.controller.sal.connection.ConnectionLocality;
  58 import org.opendaylight.controller.sal.core.Config;
  59 import org.opendaylight.controller.sal.core.ContainerFlow;
  60 import org.opendaylight.controller.sal.core.IContainer;
  61 import org.opendaylight.controller.sal.core.IContainerLocalListener;
  62 import org.opendaylight.controller.sal.core.Node;
  63 import org.opendaylight.controller.sal.core.NodeConnector;
  64 import org.opendaylight.controller.sal.core.Property;
  65 import org.opendaylight.controller.sal.core.UpdateType;
  66 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  67 import org.opendaylight.controller.sal.flowprogrammer.IFlowProgrammerListener;
  68 import org.opendaylight.controller.sal.flowprogrammer.IFlowProgrammerService;
  69 import org.opendaylight.controller.sal.match.Match;
  70 import org.opendaylight.controller.sal.match.MatchType;
  71 import org.opendaylight.controller.sal.utils.EtherTypes;
  72 import org.opendaylight.controller.sal.utils.GlobalConstants;
  73 import org.opendaylight.controller.sal.utils.IObjectReader;
  74 import org.opendaylight.controller.sal.utils.Status;
  75 import org.opendaylight.controller.sal.utils.StatusCode;
  76 import org.opendaylight.controller.switchmanager.IInventoryListener;
  77 import org.opendaylight.controller.switchmanager.ISwitchManager;
  78 import org.opendaylight.controller.switchmanager.ISwitchManagerAware;
  79 import org.opendaylight.controller.switchmanager.Subnet;
  80 import org.slf4j.Logger;
  81 import org.slf4j.LoggerFactory;
  82
  83 /**
  84  * Class that manages forwarding rule installation and removal per container of
  85  * the network. It also maintains the central repository of all the forwarding
  86  * rules installed on the network nodes.
  87  */
  88 public class ForwardingRulesManager implements
  89         IForwardingRulesManager,
  90         PortGroupChangeListener,
  91         IContainerLocalListener,
  92         ISwitchManagerAware,
  93         IConfigurationContainerAware,
  94         IInventoryListener,
  95         IObjectReader,
  96         ICacheUpdateAware<Object,Object>,
  97         IFlowProgrammerListener {
  98
  99     private static final Logger log = LoggerFactory.getLogger(ForwardingRulesManager.class);
 100     private static final Logger logsync = LoggerFactory.getLogger("FRMsync");
 101     private static final String PORT_REMOVED = "Port removed";
 102     private static final String NODE_DOWN = "Node is Down";
 103     private static final String INVALID_FLOW_ENTRY = "Invalid FlowEntry";
 104     private static final String STATIC_FLOWS_FILE_NAME = "frm_staticflows.conf";
 105     private static final String PORT_GROUP_FILE_NAME = "portgroup.conf";
 106     private ConcurrentMap<Integer, FlowConfig> staticFlows;
 107     private ConcurrentMap<Integer, Integer> staticFlowsOrdinal;
 108     private ConcurrentMap<String, PortGroupConfig> portGroupConfigs;
 109     private ConcurrentMap<PortGroupConfig, Map<Node, PortGroup>> portGroupData;
 110     private ConcurrentMap<String, Object> TSPolicies;
 111     private IContainerManager containerManager;
 112     private IConfigurationContainerService configurationService;
 113     private boolean inContainerMode; // being used by global instance only
 114     protected boolean stopping;
 115
 116     /*
 117      * Flow database. It's the software view of what was requested to install
 118      * and what is installed on the switch. It is indexed by the entry itself.
 119      * The entry's hashcode resumes the network node index, the flow's priority
 120      * and the flow's match. The value element is a class which contains the
 121      * flow entry pushed by the applications modules and the respective
 122      * container flow merged version. In absence of container flows, the two
 123      * flow entries are the same.
 124      */
 125     private ConcurrentMap<FlowEntry, FlowEntry> originalSwView;
 126     private ConcurrentMap<FlowEntryInstall, FlowEntryInstall> installedSwView;
 127     /*
 128      * Per node and per group indexing
 129      */
 130     private ConcurrentMap<Node, List<FlowEntryInstall>> nodeFlows;
 131     private ConcurrentMap<String, List<FlowEntryInstall>> groupFlows;
 132
 133     /*
 134      * Inactive flow list. This is for the global instance of FRM It will
 135      * contain all the flow entries which were installed on the global container
 136      * when the first container is created.
 137      */
 138     private ConcurrentMap<FlowEntry, FlowEntry> inactiveFlows;
 139
 140     private IContainer container;
 141     private Set<IForwardingRulesManagerAware> frmAware =
 142         Collections.synchronizedSet(new HashSet<IForwardingRulesManagerAware>());
 143     private PortGroupProvider portGroupProvider;
 144     private IFlowProgrammerService programmer;
 145     private IClusterContainerServices clusterContainerService = null;
 146     private ISwitchManager switchManager;
 147     private Thread frmEventHandler;
 148     protected BlockingQueue<FRMEvent> pendingEvents;
 149
 150     // Distributes FRM programming in the cluster
 151     private IConnectionManager connectionManager;
 152
 153     /*
 154      * Name clustered caches used to support FRM entry distribution these are by
 155      * necessity non-transactional as long as need to be able to synchronize
 156      * states also while a transaction is in progress
 157      */
 158     static final String WORK_ORDER_CACHE = "frm.workOrder";
 159     static final String WORK_STATUS_CACHE = "frm.workStatus";
 160     static final String ORIGINAL_SW_VIEW_CACHE = "frm.originalSwView";
 161     static final String INSTALLED_SW_VIEW_CACHE = "frm.installedSwView";
 162
 163     /*
 164      * Data structure responsible for distributing the FlowEntryInstall requests
 165      * in the cluster. The key value is entry that is being either Installed or
 166      * Updated or Delete. The value field is the same of the key value in case
 167      * of Installation or Deletion, it's the new entry in case of Modification,
 168      * this because the clustering caches don't allow null values.
 169      *
 170      * The logic behind this data structure is that the controller that initiate
 171      * the request will place the order here, someone will pick it and then will
 172      * remove from this data structure because is being served.
 173      *
 174      * TODO: We need to have a way to cleanup this data structure if entries are
 175      * not picked by anyone, which is always a case can happen especially on
 176      * Node disconnect cases.
 177      */
 178     protected ConcurrentMap<FlowEntryDistributionOrder, FlowEntryInstall> workOrder;
 179
 180     /*
 181      * Data structure responsible for retrieving the results of the workOrder
 182      * submitted to the cluster.
 183      *
 184      * The logic behind this data structure is that the controller that has
 185      * executed the order will then place the result in workStatus signaling
 186      * that there was a success or a failure.
 187      *
 188      * TODO: The workStatus entries need to have a lifetime associated in case
 189      * of requestor controller leaving the cluster.
 190      */
 191     protected ConcurrentMap<FlowEntryDistributionOrder, Status> workStatus;
 192
 193     /*
 194      * Local Map used to hold the Future which a caller can use to monitor for
 195      * completion
 196      */
 197     private ConcurrentMap<FlowEntryDistributionOrder, FlowEntryDistributionOrderFutureTask> workMonitor =
 198             new ConcurrentHashMap<FlowEntryDistributionOrder, FlowEntryDistributionOrderFutureTask>();
 199
 200     /*
 201      * Max pool size for the executor
 202      */
 203     private static final int maxPoolSize = 10;
 204
 205     /**
 206      * @param e
 207      *            Entry being installed/updated/removed
 208      * @param u
 209      *            New entry will be placed after the update operation. Valid
 210      *            only for UpdateType.CHANGED, null for all the other cases
 211      * @param t
 212      *            Type of update
 213      * @return a Future object for monitoring the progress of the result, or
 214      *         null in case the processing should take place locally
 215      */
 216     private FlowEntryDistributionOrderFutureTask distributeWorkOrder(FlowEntryInstall e, FlowEntryInstall u,
 217             UpdateType t) {
 218         // A null entry it's an unexpected condition, anyway it's safe to keep
 219         // the handling local
 220         if (e == null) {
 221             return null;
 222         }
 223
 224         Node n = e.getNode();
 225         if (connectionManager.getLocalityStatus(n) == ConnectionLocality.NOT_LOCAL) {
 226             // Create the work order and distribute it
 227             FlowEntryDistributionOrder fe =
 228                     new FlowEntryDistributionOrder(e, t, clusterContainerService.getMyAddress());
 229             // First create the monitor job
 230             FlowEntryDistributionOrderFutureTask ret = new FlowEntryDistributionOrderFutureTask(fe);
 231             logsync.trace("Node {} not local so sending fe {}", n, fe);
 232             workMonitor.put(fe, ret);
 233             if (t.equals(UpdateType.CHANGED)) {
 234                 // Then distribute the work
 235                 workOrder.put(fe, u);
 236             } else {
 237                 // Then distribute the work
 238                 workOrder.put(fe, e);
 239             }
 240             logsync.trace("WorkOrder requested");
 241             // Now create an Handle to monitor the execution of the operation
 242             return ret;
 243         }
 244
 245         logsync.trace("Node {} could be local. so processing Entry:{} UpdateType:{}", n, e, t);
 246         return null;
 247     }
 248
 249     /**
 250      * Checks if the FlowEntry targets are valid for this container
 251      *
 252      * @param flowEntry
 253      *            The flow entry to test
 254      * @return a Status object representing the result of the validation
 255      */
 256     private Status validateEntry(FlowEntry flowEntry) {
 257         // Node presence check
 258         Node node = flowEntry.getNode();
 259         if (!switchManager.getNodes().contains(node)) {
 260             return new Status(StatusCode.BADREQUEST, String.format("Node %s is not present in this container", node));
 261         }
 262
 263         // Ports and actions validation check
 264         Flow flow = flowEntry.getFlow();
 265         Match match = flow.getMatch();
 266         if (match.isPresent(MatchType.IN_PORT)) {
 267             NodeConnector inputPort = (NodeConnector)match.getField(MatchType.IN_PORT).getValue();
 268             if (!switchManager.getNodeConnectors(node).contains(inputPort)) {
 269                 String msg = String.format("Ingress port %s is not present on this container", inputPort);
 270                 return new Status(StatusCode.BADREQUEST, msg);
 271             }
 272         }
 273         for (Action action : flow.getActions()) {
 274             if (action instanceof Flood && !GlobalConstants.DEFAULT.toString().equals(getContainerName())) {
 275                 return new Status(StatusCode.BADREQUEST, String.format("Flood is only allowed in default container"));
 276             }
 277             if (action instanceof FloodAll && !GlobalConstants.DEFAULT.toString().equals(getContainerName())) {
 278                 return new Status(StatusCode.BADREQUEST, String.format("FloodAll is only allowed in default container"));
 279             }
 280             if (action instanceof Output) {
 281                 Output out = (Output)action;
 282                 NodeConnector outputPort = out.getPort();
 283                 if (!switchManager.getNodeConnectors(node).contains(outputPort)) {
 284                     String msg = String.format("Output port %s is not present on this container", outputPort);
 285                     return new Status(StatusCode.BADREQUEST, msg);
 286                 }
 287             }
 288             if (action instanceof Enqueue) {
 289                 Enqueue out = (Enqueue)action;
 290                 NodeConnector outputPort = out.getPort();
 291                 if (!switchManager.getNodeConnectors(node).contains(outputPort)) {
 292                     String msg = String.format("Enqueue port %s is not present on this container", outputPort);
 293                     return new Status(StatusCode.BADREQUEST, msg);
 294                 }
 295             }
 296         }
 297         return new Status(StatusCode.SUCCESS);
 298     }
 299
 300     /**
 301      * Adds a flow entry onto the network node It runs various validity checks
 302      * and derive the final container flows merged entries that will be
 303      * attempted to be installed
 304      *
 305      * @param flowEntry
 306      *            the original flow entry application requested to add
 307      * @param async
 308      *            the flag indicating if this is a asynchronous request
 309      * @return the status of this request. In case of asynchronous call, it will
 310      *         contain the unique id assigned to this request
 311      */
 312     private Status addEntry(FlowEntry flowEntry, boolean async) {
 313
 314         // Sanity Check
 315         if (flowEntry == null || flowEntry.getNode() == null || flowEntry.getFlow() == null) {
 316             String logMsg = INVALID_FLOW_ENTRY + ": {}";
 317             log.warn(logMsg, flowEntry);
 318             return new Status(StatusCode.NOTACCEPTABLE, INVALID_FLOW_ENTRY);
 319         }
 320
 321         // Operational check: input, output and queue ports presence check and
 322         // action validation for this container
 323         Status status = validateEntry(flowEntry);
 324         if (!status.isSuccess()) {
 325             String msg = String.format("%s: %s", INVALID_FLOW_ENTRY, status.getDescription());
 326             log.warn("{}: {}", msg, flowEntry);
 327             return new Status(StatusCode.NOTACCEPTABLE, msg);
 328         }
 329
 330         /*
 331          * Redundant Check: Check if the request is a redundant one from the
 332          * same application the flowEntry is equal to an existing one. Given we
 333          * do not have an application signature in the requested FlowEntry yet,
 334          * we are here detecting the above condition by comparing the flow
 335          * names, if set. If they are equal to the installed flow, most likely
 336          * this is a redundant installation request from the same application
 337          * and we can silently return success
 338          *
 339          * TODO: in future a sort of application reference list mechanism will
 340          * be added to the FlowEntry so that exact flow can be used by different
 341          * applications.
 342          */
 343         FlowEntry present = this.originalSwView.get(flowEntry);
 344         if (present != null) {
 345             boolean sameFlow = present.getFlow().equals(flowEntry.getFlow());
 346             boolean sameApp = present.getFlowName() != null && present.getFlowName().equals(flowEntry.getFlowName());
 347             if (sameFlow && sameApp) {
 348                 log.trace("Skipping redundant request for flow {} on node {}", flowEntry.getFlowName(),
 349                         flowEntry.getNode());
 350                 return new Status(StatusCode.SUCCESS, "Entry is already present");
 351             }
 352         }
 353
 354         /*
 355          * Derive the container flow merged entries to install In presence of N
 356          * container flows, we may end up with N different entries to install...
 357          */
 358         List<FlowEntryInstall> toInstallList = deriveInstallEntries(flowEntry.clone(), container.getContainerFlows());
 359
 360         // Container Flow conflict Check
 361         if (toInstallList.isEmpty()) {
 362             String msg = "Flow Entry conflicts with all Container Flows";
 363             String logMsg = msg + ": {}";
 364             log.warn(logMsg, flowEntry);
 365             return new Status(StatusCode.CONFLICT, msg);
 366         }
 367
 368         // Derive the list of entries good to be installed
 369         List<FlowEntryInstall> toInstallSafe = new ArrayList<FlowEntryInstall>();
 370         for (FlowEntryInstall entry : toInstallList) {
 371             // Conflict Check: Verify new entry would not overwrite existing
 372             // ones
 373             if (this.installedSwView.containsKey(entry)) {
 374                 log.warn("Operation Rejected: A flow with same match and priority exists on the target node");
 375                 log.trace("Aborting to install {}", entry);
 376                 continue;
 377             }
 378             toInstallSafe.add(entry);
 379         }
 380
 381         // Declare failure if all the container flow merged entries clash with
 382         // existing entries
 383         if (toInstallSafe.size() == 0) {
 384             String msg = "A flow with same match and priority exists on the target node";
 385             String logMsg = msg + ": {}";
 386             log.warn(logMsg, flowEntry);
 387             return new Status(StatusCode.CONFLICT, msg);
 388         }
 389
 390         // Try to install an entry at the time
 391         Status error = new Status(null, null);
 392         Status succeded = null;
 393         boolean oneSucceded = false;
 394         for (FlowEntryInstall installEntry : toInstallSafe) {
 395
 396             // Install and update database
 397             Status ret = addEntryInternal(installEntry, async);
 398
 399             if (ret.isSuccess()) {
 400                 oneSucceded = true;
 401                 /*
 402                  * The first successful status response will be returned For the
 403                  * asynchronous call, we can discard the container flow
 404                  * complication for now and assume we will always deal with one
 405                  * flow only per request
 406                  */
 407                 succeded = ret;
 408             } else {
 409                 error = ret;
 410                 log.trace("Failed to install the entry: {}. The failure is: {}", installEntry, ret.getDescription());
 411             }
 412         }
 413
 414         return (oneSucceded) ? succeded : error;
 415     }
 416
 417     /**
 418      * Given a flow entry and the list of container flows, it returns the list
 419      * of container flow merged flow entries good to be installed on this
 420      * container. If the list of container flows is null or empty, the install
 421      * entry list will contain only one entry, the original flow entry. If the
 422      * flow entry is congruent with all the N container flows, then the output
 423      * install entry list will contain N entries. If the output list is empty,
 424      * it means the passed flow entry conflicts with all the container flows.
 425      *
 426      * @param cFlowList
 427      *            The list of container flows
 428      * @return the list of container flow merged entries good to be installed on
 429      *         this container
 430      */
 431     private List<FlowEntryInstall> deriveInstallEntries(FlowEntry request, List<ContainerFlow> cFlowList) {
 432         List<FlowEntryInstall> toInstallList = new ArrayList<FlowEntryInstall>(1);
 433
 434         if (container.getContainerFlows() == null || container.getContainerFlows().isEmpty()) {
 435             // No container flows => entry good to be installed unchanged
 436             toInstallList.add(new FlowEntryInstall(request.clone(), null));
 437         } else {
 438             // Create the list of entries to be installed. If the flow entry is
 439             // not congruent with any container flow, no install entries will be
 440             // created
 441             for (ContainerFlow cFlow : container.getContainerFlows()) {
 442                 if (cFlow.allowsFlow(request.getFlow())) {
 443                     toInstallList.add(new FlowEntryInstall(request.clone(), cFlow));
 444                 }
 445             }
 446         }
 447         return toInstallList;
 448     }
 449
 450     /**
 451      * Modify a flow entry with a new one It runs various validity check and
 452      * derive the final container flows merged flow entries to work with
 453      *
 454      * @param currentFlowEntry
 455      * @param newFlowEntry
 456      * @param async
 457      *            the flag indicating if this is a asynchronous request
 458      * @return the status of this request. In case of asynchronous call, it will
 459      *         contain the unique id assigned to this request
 460      */
 461     private Status modifyEntry(FlowEntry currentFlowEntry, FlowEntry newFlowEntry, boolean async) {
 462         Status retExt;
 463
 464         // Sanity checks
 465         if (currentFlowEntry == null || currentFlowEntry.getNode() == null || newFlowEntry == null
 466                 || newFlowEntry.getNode() == null || newFlowEntry.getFlow() == null) {
 467             String msg = "Modify: " + INVALID_FLOW_ENTRY;
 468             String logMsg = msg + ": {} or {}";
 469             log.warn(logMsg, currentFlowEntry, newFlowEntry);
 470             return new Status(StatusCode.NOTACCEPTABLE, msg);
 471         }
 472         if (!currentFlowEntry.getNode().equals(newFlowEntry.getNode())
 473                 || !currentFlowEntry.getFlowName().equals(newFlowEntry.getFlowName())) {
 474             String msg = "Modify: Incompatible Flow Entries";
 475             String logMsg = msg + ": {} and {}";
 476             log.warn(logMsg, currentFlowEntry, newFlowEntry);
 477             return new Status(StatusCode.NOTACCEPTABLE, msg);
 478         }
 479
 480         // Equality Check
 481         if (currentFlowEntry.getFlow().equals(newFlowEntry.getFlow())) {
 482             String msg = "Modify skipped as flows are the same";
 483             String logMsg = msg + ": {} and {}";
 484             log.debug(logMsg, currentFlowEntry, newFlowEntry);
 485             return new Status(StatusCode.SUCCESS, msg);
 486         }
 487
 488         // Operational check: input, output and queue ports presence check and
 489         // action validation for this container
 490         Status status = validateEntry(newFlowEntry);
 491         if (!status.isSuccess()) {
 492             String msg = String.format("Modify: %s: %s", INVALID_FLOW_ENTRY, status.getDescription());
 493             log.warn("{}: {}", msg, newFlowEntry);
 494             return new Status(StatusCode.NOTACCEPTABLE, msg);
 495         }
 496
 497         /*
 498          * Conflict Check: Verify the new entry would not conflict with an
 499          * existing one. This is a loose check on the previous original flow
 500          * entry requests. No check on the container flow merged flow entries
 501          * (if any) yet
 502          */
 503         FlowEntry sameMatchOriginalEntry = originalSwView.get(newFlowEntry);
 504         if (sameMatchOriginalEntry != null && !sameMatchOriginalEntry.equals(currentFlowEntry)) {
 505             String msg = "Operation Rejected: Another flow with same match and priority exists on the target node";
 506             String logMsg = msg + ": {}";
 507             log.warn(logMsg, currentFlowEntry);
 508             return new Status(StatusCode.CONFLICT, msg);
 509         }
 510
 511         // Derive the installed and toInstall entries
 512         List<FlowEntryInstall> installedList = deriveInstallEntries(currentFlowEntry.clone(),
 513                 container.getContainerFlows());
 514         List<FlowEntryInstall> toInstallList = deriveInstallEntries(newFlowEntry.clone(), container.getContainerFlows());
 515
 516         if (toInstallList.isEmpty()) {
 517             String msg = "Modify Operation Rejected: The new entry conflicts with all the container flows";
 518             String logMsg = msg + ": {}";
 519             log.warn(logMsg, newFlowEntry);
 520             log.warn(msg);
 521             return new Status(StatusCode.CONFLICT, msg);
 522         }
 523
 524         /*
 525          * If the two list sizes differ, it means the new flow entry does not
 526          * satisfy the same number of container flows the current entry does.
 527          * This is only possible when the new entry and current entry have
 528          * different match. In this scenario the modification would ultimately
 529          * be handled as a remove and add operations in the protocol plugin.
 530          *
 531          * Also, if any of the new flow entries would clash with an existing
 532          * one, we cannot proceed with the modify operation, because it would
 533          * fail for some entries and leave stale entries on the network node.
 534          * Modify path can be taken only if it can be performed completely, for
 535          * all entries.
 536          *
 537          * So, for the above two cases, to simplify, let's decouple the modify
 538          * in: 1) remove current entries 2) install new entries
 539          */
 540         Status succeeded = null;
 541         boolean decouple = false;
 542         if (installedList.size() != toInstallList.size()) {
 543             log.trace("Modify: New flow entry does not satisfy the same "
 544                     + "number of container flows as the original entry does");
 545             decouple = true;
 546         }
 547         List<FlowEntryInstall> toInstallSafe = new ArrayList<FlowEntryInstall>();
 548         for (FlowEntryInstall installEntry : toInstallList) {
 549             /*
 550              * Conflict Check: Verify the new entry would not overwrite another
 551              * existing one
 552              */
 553             FlowEntryInstall sameMatchEntry = installedSwView.get(installEntry);
 554             if (sameMatchEntry != null && !sameMatchEntry.getOriginal().equals(currentFlowEntry)) {
 555                 log.trace("Modify: new container flow merged flow entry clashes with existing flow");
 556                 decouple = true;
 557             } else {
 558                 toInstallSafe.add(installEntry);
 559             }
 560         }
 561
 562         if (decouple) {
 563             // Remove current entries
 564             for (FlowEntryInstall currEntry : installedList) {
 565                 this.removeEntryInternal(currEntry, async);
 566             }
 567             // Install new entries
 568             for (FlowEntryInstall newEntry : toInstallSafe) {
 569                 succeeded = this.addEntryInternal(newEntry, async);
 570             }
 571         } else {
 572             /*
 573              * The two list have the same size and the entries to install do not
 574              * clash with any existing flow on the network node. We assume here
 575              * (and might be wrong) that the same container flows that were
 576              * satisfied by the current entries are the same that are satisfied
 577              * by the new entries. Let's take the risk for now.
 578              *
 579              * Note: modification has to be complete. If any entry modification
 580              * fails, we need to stop, restore the already modified entries, and
 581              * declare failure.
 582              */
 583             Status retModify = null;
 584             int i = 0;
 585             int size = toInstallList.size();
 586             while (i < size) {
 587                 // Modify and update database
 588                 retModify = modifyEntryInternal(installedList.get(i), toInstallList.get(i), async);
 589                 if (retModify.isSuccess()) {
 590                     i++;
 591                 } else {
 592                     break;
 593                 }
 594             }
 595             // Check if uncompleted modify
 596             if (i < size) {
 597                 log.warn("Unable to perform a complete modify for all  the container flows merged entries");
 598                 // Restore original entries
 599                 int j = 0;
 600                 while (j < i) {
 601                     log.info("Attempting to restore initial entries");
 602                     retExt = modifyEntryInternal(toInstallList.get(i), installedList.get(i), async);
 603                     if (retExt.isSuccess()) {
 604                         j++;
 605                     } else {
 606                         break;
 607                     }
 608                 }
 609                 // Fatal error, recovery failed
 610                 if (j < i) {
 611                     String msg = "Flow recovery failed ! Unrecoverable Error";
 612                     log.error(msg);
 613                     return new Status(StatusCode.INTERNALERROR, msg);
 614                 }
 615             }
 616             succeeded = retModify;
 617         }
 618         /*
 619          * The first successful status response will be returned. For the
 620          * asynchronous call, we can discard the container flow complication for
 621          * now and assume we will always deal with one flow only per request
 622          */
 623         return succeeded;
 624     }
 625
 626     /**
 627      * This is the function that modifies the final container flows merged
 628      * entries on the network node and update the database. It expects that all
 629      * the validity checks are passed.
 630      * This function is supposed to be called only on the controller on which
 631      * the IFRM call is executed.
 632      *
 633      * @param currentEntries
 634      * @param newEntries
 635      * @param async
 636      *            the flag indicating if this is a asynchronous request
 637      * @return the status of this request. In case of asynchronous call, it will
 638      *         contain the unique id assigned to this request
 639      */
 640     private Status modifyEntryInternal(FlowEntryInstall currentEntries, FlowEntryInstall newEntries, boolean async) {
 641         Status status = new Status(StatusCode.UNDEFINED);
 642         FlowEntryDistributionOrderFutureTask futureStatus =
 643                 distributeWorkOrder(currentEntries, newEntries, UpdateType.CHANGED);
 644         if (futureStatus != null) {
 645             try {
 646                 status = futureStatus.get();
 647                 if (status.getCode()
 648                         .equals(StatusCode.TIMEOUT)) {
 649                     // A timeout happened, lets cleanup the workMonitor
 650                     workMonitor.remove(futureStatus.getOrder());
 651                 }
 652             } catch (InterruptedException e) {
 653                 log.error("", e);
 654             } catch (ExecutionException e) {
 655                 log.error("", e);
 656             }
 657         } else {
 658             // Modify the flow on the network node
 659             status = modifyEntryInHw(currentEntries, newEntries, async);
 660         }
 661
 662         if (!status.isSuccess()) {
 663             log.trace("{} SDN Plugin failed to program the flow: {}. The failure is: {}",
 664                     (futureStatus != null) ? "Remote" : "Local", newEntries.getInstall(), status.getDescription());
 665             return status;
 666         }
 667
 668         log.trace("Modified {} => {}", currentEntries.getInstall(), newEntries.getInstall());
 669
 670         // Update DB
 671         newEntries.setRequestId(status.getRequestId());
 672         updateSwViews(currentEntries, false);
 673         updateSwViews(newEntries, true);
 674
 675         return status;
 676     }
 677
 678     private Status modifyEntryInHw(FlowEntryInstall currentEntries, FlowEntryInstall newEntries, boolean async) {
 679         return async ? programmer.modifyFlowAsync(currentEntries.getNode(), currentEntries.getInstall().getFlow(),
 680                 newEntries.getInstall().getFlow()) : programmer.modifyFlow(currentEntries.getNode(), currentEntries
 681                 .getInstall().getFlow(), newEntries.getInstall().getFlow());
 682     }
 683
 684     /**
 685      * Remove a flow entry. If the entry is not present in the software view
 686      * (entry or node not present), it return successfully
 687      *
 688      * @param flowEntry
 689      *            the flow entry to remove
 690      * @param async
 691      *            the flag indicating if this is a asynchronous request
 692      * @return the status of this request. In case of asynchronous call, it will
 693      *         contain the unique id assigned to this request
 694      */
 695     private Status removeEntry(FlowEntry flowEntry, boolean async) {
 696         Status error = new Status(null, null);
 697
 698         // Sanity Check
 699         if (flowEntry == null || flowEntry.getNode() == null || flowEntry.getFlow() == null) {
 700             String logMsg = INVALID_FLOW_ENTRY + ": {}";
 701             log.warn(logMsg, flowEntry);
 702             return new Status(StatusCode.NOTACCEPTABLE, INVALID_FLOW_ENTRY);
 703         }
 704
 705         // Derive the container flows merged installed entries
 706         List<FlowEntryInstall> installedList = deriveInstallEntries(flowEntry.clone(), container.getContainerFlows());
 707
 708         Status succeeded = null;
 709         boolean atLeastOneRemoved = false;
 710         for (FlowEntryInstall entry : installedList) {
 711             if (!installedSwView.containsKey(entry)) {
 712                 String logMsg = "Removal skipped (not present in software view) for flow entry: {}";
 713                 log.debug(logMsg, flowEntry);
 714                 if (installedList.size() == 1) {
 715                     // If we had only one entry to remove, we are done
 716                     return new Status(StatusCode.SUCCESS);
 717                 } else {
 718                     continue;
 719                 }
 720             }
 721
 722             // Remove and update DB
 723             Status ret = removeEntryInternal(entry, async);
 724
 725             if (!ret.isSuccess()) {
 726                 error = ret;
 727                 log.trace("Failed to remove the entry: {}. The failure is: {}", entry.getInstall(), ret.getDescription());
 728                 if (installedList.size() == 1) {
 729                     // If we had only one entry to remove, this is fatal failure
 730                     return error;
 731                 }
 732             } else {
 733                 succeeded = ret;
 734                 atLeastOneRemoved = true;
 735             }
 736         }
 737
 738         /*
 739          * No worries if full removal failed. Consistency checker will take care
 740          * of removing the stale entries later, or adjusting the software
 741          * database if not in sync with hardware
 742          */
 743         return (atLeastOneRemoved) ? succeeded : error;
 744     }
 745
 746     /**
 747      * This is the function that removes the final container flows merged entry
 748      * from the network node and update the database. It expects that all the
 749      * validity checks are passed
 750      * This function is supposed to be called only on the controller on which
 751      * the IFRM call is executed.
 752      *
 753      * @param entry
 754      *            the flow entry to remove
 755      * @param async
 756      *            the flag indicating if this is a asynchronous request
 757      * @return the status of this request. In case of asynchronous call, it will
 758      *         contain the unique id assigned to this request
 759      */
 760     private Status removeEntryInternal(FlowEntryInstall entry, boolean async) {
 761         Status status = new Status(StatusCode.UNDEFINED);
 762         FlowEntryDistributionOrderFutureTask futureStatus = distributeWorkOrder(entry, null, UpdateType.REMOVED);
 763         if (futureStatus != null) {
 764             try {
 765                 status = futureStatus.get();
 766                 if (status.getCode().equals(StatusCode.TIMEOUT)) {
 767                     // A timeout happened, lets cleanup the workMonitor
 768                     workMonitor.remove(futureStatus.getOrder());
 769                 }
 770             } catch (InterruptedException e) {
 771                 log.error("", e);
 772             } catch (ExecutionException e) {
 773                 log.error("", e);
 774             }
 775         } else {
 776             // Mark the entry to be deleted (for CC just in case we fail)
 777             entry.toBeDeleted();
 778
 779             // Remove from node
 780             status = removeEntryInHw(entry, async);
 781         }
 782
 783         if (!status.isSuccess()) {
 784             log.trace("{} SDN Plugin failed to remove the flow: {}. The failure is: {}",
 785                     (futureStatus != null) ? "Remote" : "Local", entry.getInstall(), status.getDescription());
 786             return status;
 787         }
 788
 789         log.trace("Removed  {}", entry.getInstall());
 790
 791         // Update DB
 792         updateSwViews(entry, false);
 793
 794         return status;
 795     }
 796
 797     private Status removeEntryInHw(FlowEntryInstall entry, boolean async) {
 798         return async ? programmer.removeFlowAsync(entry.getNode(), entry.getInstall().getFlow()) : programmer
 799                 .removeFlow(entry.getNode(), entry.getInstall().getFlow());
 800     }
 801
 802     /**
 803      * This is the function that installs the final container flow merged entry
 804      * on the network node and updates the database. It expects that all the
 805      * validity and conflict checks are passed. That means it does not check
 806      * whether this flow would conflict or overwrite an existing one.
 807      * This function is supposed to be called only on the controller on which
 808      * the IFRM call is executed.
 809      *
 810      * @param entry
 811      *            the flow entry to install
 812      * @param async
 813      *            the flag indicating if this is a asynchronous request
 814      * @return the status of this request. In case of asynchronous call, it will
 815      *         contain the unique id assigned to this request
 816      */
 817     private Status addEntryInternal(FlowEntryInstall entry, boolean async) {
 818         Status status = new Status(StatusCode.UNDEFINED);
 819         FlowEntryDistributionOrderFutureTask futureStatus = distributeWorkOrder(entry, null, UpdateType.ADDED);
 820         if (futureStatus != null) {
 821             try {
 822                 status = futureStatus.get();
 823                 if (status.getCode().equals(StatusCode.TIMEOUT)) {
 824                     // A timeout happened, lets cleanup the workMonitor
 825                     workMonitor.remove(futureStatus.getOrder());
 826                 }
 827             } catch (InterruptedException e) {
 828                 log.error("", e);
 829             } catch (ExecutionException e) {
 830                 log.error("", e);
 831             }
 832         } else {
 833             status = addEntryInHw(entry, async);
 834         }
 835
 836         if (!status.isSuccess()) {
 837             log.trace("{} SDN Plugin failed to program the flow: {}. The failure is: {}",
 838                     (futureStatus != null) ? "Remote" : "Local", entry.getInstall(), status.getDescription());
 839             return status;
 840         }
 841
 842         log.trace("Added    {}", entry.getInstall());
 843
 844         // Update DB
 845         entry.setRequestId(status.getRequestId());
 846         updateSwViews(entry, true);
 847
 848         return status;
 849     }
 850
 851     private Status addEntryInHw(FlowEntryInstall entry, boolean async) {
 852         // Install the flow on the network node
 853         return async ? programmer.addFlowAsync(entry.getNode(), entry.getInstall().getFlow()) : programmer.addFlow(
 854                 entry.getNode(), entry.getInstall().getFlow());
 855     }
 856
 857     /**
 858      * Returns true if the flow conflicts with all the container's flows. This
 859      * means that if the function returns true, the passed flow entry is
 860      * congruent with at least one container flow, hence it is good to be
 861      * installed on this container.
 862      *
 863      * @param flowEntry
 864      * @return true if flow conflicts with all the container flows, false
 865      *         otherwise
 866      */
 867     private boolean entryConflictsWithContainerFlows(FlowEntry flowEntry) {
 868         List<ContainerFlow> cFlowList = container.getContainerFlows();
 869
 870         // Validity check and avoid unnecessary computation
 871         // Also takes care of default container where no container flows are
 872         // present
 873         if (cFlowList == null || cFlowList.isEmpty()) {
 874             return false;
 875         }
 876
 877         for (ContainerFlow cFlow : cFlowList) {
 878             if (cFlow.allowsFlow(flowEntry.getFlow())) {
 879                 // Entry is allowed by at least one container flow: good to go
 880                 return false;
 881             }
 882         }
 883         return true;
 884     }
 885
 886     private ConcurrentMap.Entry<Integer, FlowConfig> getStaticFlowEntry(String name, Node node) {
 887         for (ConcurrentMap.Entry<Integer, FlowConfig> flowEntry : staticFlows.entrySet()) {
 888             FlowConfig flowConfig = flowEntry.getValue();
 889             if (flowConfig.isByNameAndNodeIdEqual(name, node)) {
 890                 return flowEntry;
 891             }
 892         }
 893         return null;
 894     }
 895
 896     private void updateIndexDatabase(FlowEntryInstall entry, boolean add) {
 897         // Update node indexed flow database
 898         updateNodeFlowsDB(entry, add);
 899
 900         // Update group indexed flow database
 901         updateGroupFlowsDB(entry, add);
 902     }
 903
 904     /*
 905      * Update the node mapped flows database
 906      */
 907     private void updateSwViews(FlowEntryInstall flowEntries, boolean add) {
 908         if (add) {
 909             originalSwView.put(flowEntries.getOriginal(), flowEntries.getOriginal());
 910             installedSwView.put(flowEntries, flowEntries);
 911         } else {
 912             originalSwView.remove(flowEntries.getOriginal());
 913             installedSwView.remove(flowEntries);
 914         }
 915     }
 916
 917     /*
 918      * Update the node mapped flows database
 919      */
 920     private void updateNodeFlowsDB(FlowEntryInstall flowEntries, boolean add) {
 921         Node node = flowEntries.getNode();
 922
 923         List<FlowEntryInstall> nodeIndeces = this.nodeFlows.get(node);
 924         if (nodeIndeces == null) {
 925             if (!add) {
 926                 return;
 927             } else {
 928                 nodeIndeces = new ArrayList<FlowEntryInstall>();
 929             }
 930         }
 931
 932         if (add) {
 933             // there may be an already existing entry.
 934             // remove it before adding the new one.
 935             // This is necessary since we have observed that in some cases
 936             // Infinispan does aggregation for operations (eg:- remove and then put a different value)
 937             // related to the same key within the same transaction.
 938             // Need this defensive code as the new FlowEntryInstall may be different
 939             // than the old one even though the equals method returns true. This is because
 940             // the equals method does not take into account the action list.
 941             if(nodeIndeces.contains(flowEntries)) {
 942                 nodeIndeces.remove(flowEntries);
 943             }
 944             nodeIndeces.add(flowEntries);
 945         } else {
 946             nodeIndeces.remove(flowEntries);
 947         }
 948
 949         // Update cache across cluster
 950         if (nodeIndeces.isEmpty()) {
 951             this.nodeFlows.remove(node);
 952         } else {
 953             this.nodeFlows.put(node, nodeIndeces);
 954         }
 955     }
 956
 957     /*
 958      * Update the group name mapped flows database
 959      */
 960     private void updateGroupFlowsDB(FlowEntryInstall flowEntries, boolean add) {
 961         String groupName = flowEntries.getGroupName();
 962
 963         // Flow may not be part of a group
 964         if (groupName == null) {
 965             return;
 966         }
 967
 968         List<FlowEntryInstall> indices = this.groupFlows.get(groupName);
 969         if (indices == null) {
 970             if (!add) {
 971                 return;
 972             } else {
 973                 indices = new ArrayList<FlowEntryInstall>();
 974             }
 975         }
 976
 977         if (add) {
 978             // same comments in the similar code section in
 979             // updateNodeFlowsDB method apply here too
 980             if(indices.contains(flowEntries)) {
 981                 indices.remove(flowEntries);
 982             }
 983             indices.add(flowEntries);
 984         } else {
 985             indices.remove(flowEntries);
 986         }
 987
 988         // Update cache across cluster
 989         if (indices.isEmpty()) {
 990             this.groupFlows.remove(groupName);
 991         } else {
 992             this.groupFlows.put(groupName, indices);
 993         }
 994     }
 995
 996     /**
 997      * Remove a flow entry that has been added previously First checks if the
 998      * entry is effectively present in the local database
 999      */
1000     @SuppressWarnings("unused")
1001     private Status removeEntry(Node node, String flowName) {
1002         FlowEntryInstall target = null;
1003
1004         // Find in database
1005         for (FlowEntryInstall entry : installedSwView.values()) {
1006             if (entry.equalsByNodeAndName(node, flowName)) {
1007                 target = entry;
1008                 break;
1009             }
1010         }
1011
1012         // If it is not there, stop any further processing
1013         if (target == null) {
1014             return new Status(StatusCode.SUCCESS, "Entry is not present");
1015         }
1016
1017         // Remove from node
1018         Status status = programmer.removeFlow(target.getNode(), target.getInstall().getFlow());
1019
1020         // Update DB
1021         if (status.isSuccess()) {
1022             updateSwViews(target, false);
1023         } else {
1024             // log the error
1025             log.trace("SDN Plugin failed to remove the flow: {}. The failure is: {}", target.getInstall(),
1026                     status.getDescription());
1027         }
1028
1029         return status;
1030     }
1031
1032     @Override
1033     public Status installFlowEntry(FlowEntry flowEntry) {
1034         Status status;
1035         if (isContainerModeAllowed(flowEntry)) {
1036             status = addEntry(flowEntry, false);
1037         } else {
1038             String msg = "Controller in container mode: Install Refused";
1039             String logMsg = msg + ": {}";
1040             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1041             log.warn(logMsg, flowEntry);
1042         }
1043         return status;
1044     }
1045
1046     @Override
1047     public Status installFlowEntryAsync(FlowEntry flowEntry) {
1048         Status status;
1049         if (isContainerModeAllowed(flowEntry)) {
1050             status = addEntry(flowEntry, true);
1051         } else {
1052             String msg = "Controller in container mode: Install Refused";
1053             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1054             log.warn(msg);
1055         }
1056         return status;
1057     }
1058
1059     @Override
1060     public Status uninstallFlowEntry(FlowEntry flowEntry) {
1061         Status status;
1062         if (isContainerModeAllowed(flowEntry)) {
1063             status = removeEntry(flowEntry, false);
1064         } else {
1065             String msg = "Controller in container mode: Uninstall Refused";
1066             String logMsg = msg + ": {}";
1067             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1068             log.warn(logMsg, flowEntry);
1069         }
1070         return status;
1071     }
1072
1073     @Override
1074     public Status uninstallFlowEntryAsync(FlowEntry flowEntry) {
1075         Status status;
1076         if (isContainerModeAllowed(flowEntry)) {
1077             status = removeEntry(flowEntry, true);
1078         } else {
1079             String msg = "Controller in container mode: Uninstall Refused";
1080             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1081             log.warn(msg);
1082         }
1083         return status;
1084     }
1085
1086     @Override
1087     public Status modifyFlowEntry(FlowEntry currentFlowEntry, FlowEntry newFlowEntry) {
1088         Status status = null;
1089         if (isContainerModeAllowed(currentFlowEntry)) {
1090             status = modifyEntry(currentFlowEntry, newFlowEntry, false);
1091         } else {
1092             String msg = "Controller in container mode: Modify Refused";
1093             String logMsg = msg + ": {}";
1094             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1095             log.warn(logMsg, newFlowEntry);
1096         }
1097         return status;
1098     }
1099
1100     @Override
1101     public Status modifyFlowEntryAsync(FlowEntry currentFlowEntry, FlowEntry newFlowEntry) {
1102         Status status = null;
1103         if (isContainerModeAllowed(currentFlowEntry)) {
1104             status = modifyEntry(currentFlowEntry, newFlowEntry, true);
1105         } else {
1106             String msg = "Controller in container mode: Modify Refused";
1107             status = new Status(StatusCode.NOTACCEPTABLE, msg);
1108             log.warn(msg);
1109         }
1110         return status;
1111     }
1112
1113     /**
1114      * Returns whether the specified flow entry is allowed to be
1115      * installed/removed/modified based on the current container mode status.
1116      * This call always returns true in the container instance of forwarding
1117      * rules manager. It is meant for the global instance only (default
1118      * container) of forwarding rules manager. Idea is that for assuring
1119      * container isolation of traffic, flow installation in default container is
1120      * blocked when in container mode (containers are present). The only flows
1121      * that are allowed in container mode in the default container are the
1122      * proactive flows, the ones automatically installed on the network node
1123      * which forwarding mode has been configured to "proactive". These flows are
1124      * needed by controller to discover the nodes topology and to discover the
1125      * attached hosts for some SDN switches.
1126      *
1127      * @param flowEntry
1128      *            The flow entry to be installed/removed/modified
1129      * @return true if not in container mode or if flowEntry is internally
1130      *         generated
1131      */
1132     private boolean isContainerModeAllowed(FlowEntry flowEntry) {
1133         return (!inContainerMode) ? true : flowEntry.isInternal();
1134     }
1135
1136     @Override
1137     public Status modifyOrAddFlowEntry(FlowEntry newFlowEntry) {
1138         /*
1139          * Run a check on the original entries to decide whether to go with a
1140          * add or modify method. A loose check means only check against the
1141          * original flow entry requests and not against the installed flow
1142          * entries which are the result of the original entry merged with the
1143          * container flow(s) (if any). The modifyFlowEntry method in presence of
1144          * conflicts with the Container flows (if any) would revert back to a
1145          * delete + add pattern
1146          */
1147         FlowEntry currentFlowEntry = originalSwView.get(newFlowEntry);
1148
1149         if (currentFlowEntry != null) {
1150             return modifyFlowEntry(currentFlowEntry, newFlowEntry);
1151         } else {
1152             return installFlowEntry(newFlowEntry);
1153         }
1154     }
1155
1156     @Override
1157     public Status modifyOrAddFlowEntryAsync(FlowEntry newFlowEntry) {
1158         /*
1159          * Run a check on the original entries to decide whether to go with a
1160          * add or modify method. A loose check means only check against the
1161          * original flow entry requests and not against the installed flow
1162          * entries which are the result of the original entry merged with the
1163          * container flow(s) (if any). The modifyFlowEntry method in presence of
1164          * conflicts with the Container flows (if any) would revert back to a
1165          * delete + add pattern
1166          */
1167         FlowEntry currentFlowEntry = originalSwView.get(newFlowEntry);
1168
1169         if (currentFlowEntry != null) {
1170             return modifyFlowEntryAsync(currentFlowEntry, newFlowEntry);
1171         } else {
1172             return installFlowEntryAsync(newFlowEntry);
1173         }
1174     }
1175
1176     @Override
1177     public Status uninstallFlowEntryGroup(String groupName) {
1178         if (groupName == null || groupName.isEmpty()) {
1179             return new Status(StatusCode.BADREQUEST, "Invalid group name");
1180         }
1181         if (groupName.equals(FlowConfig.INTERNALSTATICFLOWGROUP)) {
1182             return new Status(StatusCode.BADREQUEST, "Internal static flows group cannot be deleted through this api");
1183         }
1184         if (inContainerMode) {
1185             String msg = "Controller in container mode: Group Uninstall Refused";
1186             String logMsg = msg + ": {}";
1187             log.warn(logMsg, groupName);
1188             return new Status(StatusCode.NOTACCEPTABLE, msg);
1189         }
1190         int toBeRemoved = 0;
1191         String error = "";
1192         if (groupFlows.containsKey(groupName)) {
1193             List<FlowEntryInstall> list = new ArrayList<FlowEntryInstall>(groupFlows.get(groupName));
1194             toBeRemoved = list.size();
1195             for (FlowEntryInstall entry : list) {
1196                 // since this is the entry that was stored in groupFlows
1197                 // it is already validated and merged
1198                 // so can call removeEntryInternal directly
1199                 Status status = this.removeEntryInternal(entry, false);
1200                 if (status.isSuccess()) {
1201                     toBeRemoved -= 1;
1202                 } else {
1203                     error = status.getDescription();
1204                 }
1205             }
1206         }
1207         return (toBeRemoved == 0) ? new Status(StatusCode.SUCCESS) : new Status(StatusCode.INTERNALERROR,
1208                 "Not all the flows were removed: " + error);
1209     }
1210
1211     @Override
1212     public Status uninstallFlowEntryGroupAsync(String groupName) {
1213         if (groupName == null || groupName.isEmpty()) {
1214             return new Status(StatusCode.BADREQUEST, "Invalid group name");
1215         }
1216         if (groupName.equals(FlowConfig.INTERNALSTATICFLOWGROUP)) {
1217             return new Status(StatusCode.BADREQUEST, "Static flows group cannot be deleted through this api");
1218         }
1219         if (inContainerMode) {
1220             String msg = "Controller in container mode: Group Uninstall Refused";
1221             String logMsg = msg + ": {}";
1222             log.warn(logMsg, groupName);
1223             return new Status(StatusCode.NOTACCEPTABLE, msg);
1224         }
1225         if (groupFlows.containsKey(groupName)) {
1226             List<FlowEntryInstall> list = new ArrayList<FlowEntryInstall>(groupFlows.get(groupName));
1227             for (FlowEntryInstall entry : list) {
1228                 this.removeEntry(entry.getOriginal(), true);
1229             }
1230         }
1231         return new Status(StatusCode.SUCCESS);
1232     }
1233
1234     @Override
1235     public boolean checkFlowEntryConflict(FlowEntry flowEntry) {
1236         return entryConflictsWithContainerFlows(flowEntry);
1237     }
1238
1239     /**
1240      * Updates all installed flows because the container flow got updated This
1241      * is obtained in two phases on per node basis: 1) Uninstall of all flows 2)
1242      * Reinstall of all flows This is needed because a new container flows
1243      * merged flow may conflict with an existing old container flows merged flow
1244      * on the network node
1245      */
1246     protected void updateFlowsContainerFlow() {
1247         Set<FlowEntry> toReInstall = new HashSet<FlowEntry>();
1248         // First remove all installed entries
1249         for (ConcurrentMap.Entry<FlowEntryInstall, FlowEntryInstall> entry : installedSwView.entrySet()) {
1250             FlowEntryInstall current = entry.getValue();
1251             // Store the original entry
1252             toReInstall.add(current.getOriginal());
1253             // Remove the old couples. No validity checks to be run, use the
1254             // internal remove
1255             this.removeEntryInternal(current, false);
1256         }
1257         // Then reinstall the original entries
1258         for (FlowEntry entry : toReInstall) {
1259             // Reinstall the original flow entries, via the regular path: new
1260             // cFlow merge + validations
1261             this.installFlowEntry(entry);
1262         }
1263     }
1264
1265     private void nonClusterObjectCreate() {
1266         originalSwView = new ConcurrentHashMap<FlowEntry, FlowEntry>();
1267         installedSwView = new ConcurrentHashMap<FlowEntryInstall, FlowEntryInstall>();
1268         TSPolicies = new ConcurrentHashMap<String, Object>();
1269         staticFlowsOrdinal = new ConcurrentHashMap<Integer, Integer>();
1270         portGroupConfigs = new ConcurrentHashMap<String, PortGroupConfig>();
1271         portGroupData = new ConcurrentHashMap<PortGroupConfig, Map<Node, PortGroup>>();
1272         staticFlows = new ConcurrentHashMap<Integer, FlowConfig>();
1273         inactiveFlows = new ConcurrentHashMap<FlowEntry, FlowEntry>();
1274     }
1275
1276     @Override
1277     public void setTSPolicyData(String policyname, Object o, boolean add) {
1278
1279         if (add) {
1280             /* Check if this policy already exists */
1281             if (!(TSPolicies.containsKey(policyname))) {
1282                 TSPolicies.put(policyname, o);
1283             }
1284         } else {
1285             TSPolicies.remove(policyname);
1286         }
1287         if (frmAware != null) {
1288             synchronized (frmAware) {
1289                 for (IForwardingRulesManagerAware frma : frmAware) {
1290                     try {
1291                         frma.policyUpdate(policyname, add);
1292                     } catch (Exception e) {
1293                         log.warn("Exception on callback", e);
1294                     }
1295                 }
1296             }
1297         }
1298     }
1299
1300     @Override
1301     public Map<String, Object> getTSPolicyData() {
1302         return TSPolicies;
1303     }
1304
1305     @Override
1306     public Object getTSPolicyData(String policyName) {
1307         if (TSPolicies.containsKey(policyName)) {
1308             return TSPolicies.get(policyName);
1309         } else {
1310             return null;
1311         }
1312     }
1313
1314     @Override
1315     public List<FlowEntry> getFlowEntriesForGroup(String policyName) {
1316         List<FlowEntry> list = new ArrayList<FlowEntry>();
1317         if (policyName != null && !policyName.trim().isEmpty()) {
1318             for (Map.Entry<FlowEntry, FlowEntry> entry : this.originalSwView.entrySet()) {
1319                 if (policyName.equals(entry.getKey().getGroupName())) {
1320                     list.add(entry.getValue().clone());
1321                 }
1322             }
1323         }
1324         return list;
1325     }
1326
1327     @Override
1328     public List<FlowEntry> getInstalledFlowEntriesForGroup(String policyName) {
1329         List<FlowEntry> list = new ArrayList<FlowEntry>();
1330         if (policyName != null && !policyName.trim().isEmpty()) {
1331             for (Map.Entry<FlowEntryInstall, FlowEntryInstall> entry : this.installedSwView.entrySet()) {
1332                 if (policyName.equals(entry.getKey().getGroupName())) {
1333                     list.add(entry.getValue().getInstall().clone());
1334                 }
1335             }
1336         }
1337         return list;
1338     }
1339
1340     @Override
1341     public void addOutputPort(Node node, String flowName, List<NodeConnector> portList) {
1342
1343         for (FlowEntryInstall flow : this.nodeFlows.get(node)) {
1344             if (flow.getFlowName().equals(flowName)) {
1345                 FlowEntry currentFlowEntry = flow.getOriginal();
1346                 FlowEntry newFlowEntry = currentFlowEntry.clone();
1347                 for (NodeConnector dstPort : portList) {
1348                     newFlowEntry.getFlow().addAction(new Output(dstPort));
1349                 }
1350                 Status error = modifyEntry(currentFlowEntry, newFlowEntry, false);
1351                 if (error.isSuccess()) {
1352                     log.trace("Ports {} added to FlowEntry {}", portList, flowName);
1353                 } else {
1354                     log.warn("Failed to add ports {} to Flow entry {}. The failure is: {}", portList,
1355                             currentFlowEntry.toString(), error.getDescription());
1356                 }
1357                 return;
1358             }
1359         }
1360         log.warn("Failed to add ports to Flow {} on Node {}: Entry Not Found", flowName, node);
1361     }
1362
1363     @Override
1364     public void removeOutputPort(Node node, String flowName, List<NodeConnector> portList) {
1365         for (FlowEntryInstall index : this.nodeFlows.get(node)) {
1366             FlowEntryInstall flow = this.installedSwView.get(index);
1367             if (flow.getFlowName().equals(flowName)) {
1368                 FlowEntry currentFlowEntry = flow.getOriginal();
1369                 FlowEntry newFlowEntry = currentFlowEntry.clone();
1370                 for (NodeConnector dstPort : portList) {
1371                     Action action = new Output(dstPort);
1372                     newFlowEntry.getFlow().removeAction(action);
1373                 }
1374                 Status status = modifyEntry(currentFlowEntry, newFlowEntry, false);
1375                 if (status.isSuccess()) {
1376                     log.trace("Ports {} removed from FlowEntry {}", portList, flowName);
1377                 } else {
1378                     log.warn("Failed to remove ports {} from Flow entry {}. The failure is: {}", portList,
1379                             currentFlowEntry.toString(), status.getDescription());
1380                 }
1381                 return;
1382             }
1383         }
1384         log.warn("Failed to remove ports from Flow {} on Node {}: Entry Not Found", flowName, node);
1385     }
1386
1387     /*
1388      * This function assumes the target flow has only one output port
1389      */
1390     @Override
1391     public void replaceOutputPort(Node node, String flowName, NodeConnector outPort) {
1392         FlowEntry currentFlowEntry = null;
1393         FlowEntry newFlowEntry = null;
1394
1395         // Find the flow
1396         for (FlowEntryInstall index : this.nodeFlows.get(node)) {
1397             FlowEntryInstall flow = this.installedSwView.get(index);
1398             if (flow.getFlowName().equals(flowName)) {
1399                 currentFlowEntry = flow.getOriginal();
1400                 break;
1401             }
1402         }
1403         if (currentFlowEntry == null) {
1404             log.warn("Failed to replace output port for flow {} on node {}: Entry Not Found", flowName, node);
1405             return;
1406         }
1407
1408         // Create a flow copy with the new output port
1409         newFlowEntry = currentFlowEntry.clone();
1410         Action target = null;
1411         for (Action action : newFlowEntry.getFlow().getActions()) {
1412             if (action.getType() == ActionType.OUTPUT) {
1413                 target = action;
1414                 break;
1415             }
1416         }
1417         newFlowEntry.getFlow().removeAction(target);
1418         newFlowEntry.getFlow().addAction(new Output(outPort));
1419
1420         // Modify on network node
1421         Status status = modifyEntry(currentFlowEntry, newFlowEntry, false);
1422
1423         if (status.isSuccess()) {
1424             log.trace("Output port replaced with {} for flow {} on node {}", outPort, flowName, node);
1425         } else {
1426             log.warn("Failed to replace output port for flow {} on node {}. The failure is: {}", flowName, node,
1427                     status.getDescription());
1428         }
1429         return;
1430     }
1431
1432     @Override
1433     public NodeConnector getOutputPort(Node node, String flowName) {
1434         for (FlowEntryInstall index : this.nodeFlows.get(node)) {
1435             FlowEntryInstall flow = this.installedSwView.get(index);
1436             if (flow.getFlowName().equals(flowName)) {
1437                 for (Action action : flow.getOriginal().getFlow().getActions()) {
1438                     if (action.getType() == ActionType.OUTPUT) {
1439                         return ((Output) action).getPort();
1440                     }
1441                 }
1442             }
1443         }
1444         return null;
1445     }
1446
1447     private void cacheStartup() {
1448         allocateCaches();
1449         retrieveCaches();
1450     }
1451
1452     private void allocateCaches() {
1453         if (this.clusterContainerService == null) {
1454             log.warn("Un-initialized clusterContainerService, can't create cache");
1455             return;
1456         }
1457
1458         log.debug("Allocating caches for Container {}", container.getName());
1459
1460         try {
1461             clusterContainerService.createCache(ORIGINAL_SW_VIEW_CACHE,
1462                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1463
1464             clusterContainerService.createCache(INSTALLED_SW_VIEW_CACHE,
1465                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1466
1467             clusterContainerService.createCache("frm.inactiveFlows",
1468                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1469
1470             clusterContainerService.createCache("frm.staticFlows",
1471                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1472
1473             clusterContainerService.createCache("frm.staticFlowsOrdinal",
1474                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1475
1476             clusterContainerService.createCache("frm.portGroupConfigs",
1477                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1478
1479             clusterContainerService.createCache("frm.portGroupData",
1480                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1481
1482             clusterContainerService.createCache("frm.TSPolicies",
1483                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
1484
1485             clusterContainerService.createCache(WORK_STATUS_CACHE,
1486                     EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL, IClusterServices.cacheMode.ASYNC));
1487
1488             clusterContainerService.createCache(WORK_ORDER_CACHE,
1489                     EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL, IClusterServices.cacheMode.ASYNC));
1490
1491         } catch (CacheConfigException cce) {
1492             log.error("CacheConfigException");
1493         } catch (CacheExistException cce) {
1494             log.error("CacheExistException");
1495         }
1496     }
1497
1498     @SuppressWarnings({ "unchecked" })
1499     private void retrieveCaches() {
1500         ConcurrentMap<?, ?> map;
1501
1502         if (this.clusterContainerService == null) {
1503             log.warn("un-initialized clusterContainerService, can't retrieve cache");
1504             nonClusterObjectCreate();
1505             return;
1506         }
1507
1508         log.debug("Retrieving Caches for Container {}", container.getName());
1509
1510         map = clusterContainerService.getCache(ORIGINAL_SW_VIEW_CACHE);
1511         if (map != null) {
1512             originalSwView = (ConcurrentMap<FlowEntry, FlowEntry>) map;
1513         } else {
1514             log.error("Retrieval of frm.originalSwView cache failed for Container {}", container.getName());
1515         }
1516
1517         map = clusterContainerService.getCache(INSTALLED_SW_VIEW_CACHE);
1518         if (map != null) {
1519             installedSwView = (ConcurrentMap<FlowEntryInstall, FlowEntryInstall>) map;
1520         } else {
1521             log.error("Retrieval of frm.installedSwView cache failed for Container {}", container.getName());
1522         }
1523
1524         map = clusterContainerService.getCache("frm.inactiveFlows");
1525         if (map != null) {
1526             inactiveFlows = (ConcurrentMap<FlowEntry, FlowEntry>) map;
1527         } else {
1528             log.error("Retrieval of frm.inactiveFlows cache failed for Container {}", container.getName());
1529         }
1530
1531         map = clusterContainerService.getCache("frm.staticFlows");
1532         if (map != null) {
1533             staticFlows = (ConcurrentMap<Integer, FlowConfig>) map;
1534         } else {
1535             log.error("Retrieval of frm.staticFlows cache failed for Container {}", container.getName());
1536         }
1537
1538         map = clusterContainerService.getCache("frm.staticFlowsOrdinal");
1539         if (map != null) {
1540             staticFlowsOrdinal = (ConcurrentMap<Integer, Integer>) map;
1541         } else {
1542             log.error("Retrieval of frm.staticFlowsOrdinal cache failed for Container {}", container.getName());
1543         }
1544
1545         map = clusterContainerService.getCache("frm.portGroupConfigs");
1546         if (map != null) {
1547             portGroupConfigs = (ConcurrentMap<String, PortGroupConfig>) map;
1548         } else {
1549             log.error("Retrieval of frm.portGroupConfigs cache failed for Container {}", container.getName());
1550         }
1551
1552         map = clusterContainerService.getCache("frm.portGroupData");
1553         if (map != null) {
1554             portGroupData = (ConcurrentMap<PortGroupConfig, Map<Node, PortGroup>>) map;
1555         } else {
1556             log.error("Retrieval of frm.portGroupData allocation failed for Container {}", container.getName());
1557         }
1558
1559         map = clusterContainerService.getCache("frm.TSPolicies");
1560         if (map != null) {
1561             TSPolicies = (ConcurrentMap<String, Object>) map;
1562         } else {
1563             log.error("Retrieval of frm.TSPolicies cache failed for Container {}", container.getName());
1564         }
1565
1566         map = clusterContainerService.getCache(WORK_ORDER_CACHE);
1567         if (map != null) {
1568             workOrder = (ConcurrentMap<FlowEntryDistributionOrder, FlowEntryInstall>) map;
1569         } else {
1570             log.error("Retrieval of " + WORK_ORDER_CACHE + " cache failed for Container {}", container.getName());
1571         }
1572
1573         map = clusterContainerService.getCache(WORK_STATUS_CACHE);
1574         if (map != null) {
1575             workStatus = (ConcurrentMap<FlowEntryDistributionOrder, Status>) map;
1576         } else {
1577             log.error("Retrieval of " + WORK_STATUS_CACHE + " cache failed for Container {}", container.getName());
1578         }
1579     }
1580
1581     private boolean flowConfigExists(FlowConfig config) {
1582         // Flow name has to be unique on per node id basis
1583         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1584             if (entry.getValue().isByNameAndNodeIdEqual(config)) {
1585                 return true;
1586             }
1587         }
1588         return false;
1589     }
1590
1591     @Override
1592     public Status addStaticFlow(FlowConfig config) {
1593         return addStaticFlow(config, false);
1594     }
1595
1596     private Status addStaticFlow(FlowConfig config, boolean async) {
1597         // Configuration object validation
1598         Status status = config.validate();
1599         if (!status.isSuccess()) {
1600             log.warn("Invalid Configuration for flow {}. The failure is {}", config, status.getDescription());
1601             String error = "Invalid Configuration (" + status.getDescription() + ")";
1602             config.setStatus(error);
1603             return new Status(StatusCode.BADREQUEST, error);
1604         }
1605         return addStaticFlowInternal(config, async, false);
1606     }
1607
1608
1609     @Override
1610     public Status addStaticFlowAsync(FlowConfig config) {
1611         return addStaticFlow(config, true);
1612     }
1613
1614     /**
1615      * Private method to add a static flow configuration which does not run any
1616      * validation on the passed FlowConfig object. If restore is set to true,
1617      * configuration is stored in configuration database regardless the
1618      * installation on the network node was successful. This is useful at boot
1619      * when static flows are present in startup configuration and are read
1620      * before the switches connects.
1621      *
1622      * @param config
1623      *            The static flow configuration
1624      * @param restore
1625      *            if true, the configuration is stored regardless the
1626      *            installation on the network node was successful
1627      * @return The status of this request
1628      */
1629     private Status addStaticFlowInternal(FlowConfig config, boolean async, boolean restore) {
1630         boolean multipleFlowPush = false;
1631         String error;
1632         Status status;
1633         config.setStatus(StatusCode.SUCCESS.toString());
1634
1635         // Presence check
1636         if (flowConfigExists(config)) {
1637             error = "Entry with this name on specified switch already exists";
1638             log.warn("Entry with this name on specified switch already exists: {}", config);
1639             config.setStatus(error);
1640             return new Status(StatusCode.CONFLICT, error);
1641         }
1642
1643         if ((config.getIngressPort() == null) && config.getPortGroup() != null) {
1644             for (String portGroupName : portGroupConfigs.keySet()) {
1645                 if (portGroupName.equalsIgnoreCase(config.getPortGroup())) {
1646                     multipleFlowPush = true;
1647                     break;
1648                 }
1649             }
1650             if (!multipleFlowPush) {
1651                 log.warn("Invalid Configuration(Invalid PortGroup Name) for flow {}", config);
1652                 error = "Invalid Configuration (Invalid PortGroup Name)";
1653                 config.setStatus(error);
1654                 return new Status(StatusCode.BADREQUEST, error);
1655             }
1656         }
1657
1658         /*
1659          * If requested program the entry in hardware first before updating the
1660          * StaticFlow DB
1661          */
1662         if (!multipleFlowPush) {
1663             // Program hw
1664             if (config.installInHw()) {
1665                 FlowEntry entry = config.getFlowEntry();
1666                 status = async ? this.installFlowEntryAsync(entry) : this.installFlowEntry(entry);
1667                 if (!status.isSuccess()) {
1668                     config.setStatus(status.getDescription());
1669                     if (!restore) {
1670                         return status;
1671                     }
1672                 }
1673             }
1674         }
1675
1676         /*
1677          * When the control reaches this point, either of the following
1678          * conditions is true 1. This is a single entry configuration (non
1679          * PortGroup) and the hardware installation is successful 2. This is a
1680          * multiple entry configuration (PortGroup) and hardware installation is
1681          * NOT done directly on this event. 3. The User prefers to retain the
1682          * configuration in Controller and skip hardware installation.
1683          *
1684          * Hence it is safe to update the StaticFlow DB at this point.
1685          *
1686          * Note : For the case of PortGrouping, it is essential to have this DB
1687          * populated before the PortGroupListeners can query for the DB
1688          * triggered using portGroupChanged event...
1689          */
1690         Integer ordinal = staticFlowsOrdinal.get(0);
1691         staticFlowsOrdinal.put(0, ++ordinal);
1692         staticFlows.put(ordinal, config);
1693
1694         if (multipleFlowPush) {
1695             PortGroupConfig pgconfig = portGroupConfigs.get(config.getPortGroup());
1696             Map<Node, PortGroup> existingData = portGroupData.get(pgconfig);
1697             if (existingData != null) {
1698                 portGroupChanged(pgconfig, existingData, true);
1699             }
1700         }
1701         return new Status(StatusCode.SUCCESS);
1702     }
1703
1704     private void addStaticFlowsToSwitch(Node node) {
1705         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1706             FlowConfig config = entry.getValue();
1707             if (config.isPortGroupEnabled()) {
1708                 continue;
1709             }
1710             if (config.getNode().equals(node)) {
1711                 if (config.installInHw() && !config.getStatus().equals(StatusCode.SUCCESS.toString())) {
1712                     Status status = this.installFlowEntryAsync(config.getFlowEntry());
1713                     config.setStatus(status.getDescription());
1714                 }
1715             }
1716         }
1717         // Update cluster cache
1718         refreshClusterStaticFlowsStatus(node);
1719     }
1720
1721     private void updateStaticFlowConfigsOnNodeDown(Node node) {
1722         log.trace("Updating Static Flow configs on node down: {}", node);
1723
1724         List<Integer> toRemove = new ArrayList<Integer>();
1725         for (Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1726
1727             FlowConfig config = entry.getValue();
1728
1729             if (config.isPortGroupEnabled()) {
1730                 continue;
1731             }
1732
1733             if (config.installInHw() && config.getNode().equals(node)) {
1734                 if (config.isInternalFlow()) {
1735                     // Take note of this controller generated static flow
1736                     toRemove.add(entry.getKey());
1737                 } else {
1738                     config.setStatus(NODE_DOWN);
1739                 }
1740             }
1741         }
1742         // Remove controller generated static flows for this node
1743         for (Integer index : toRemove) {
1744             staticFlows.remove(index);
1745         }
1746         // Update cluster cache
1747         refreshClusterStaticFlowsStatus(node);
1748
1749     }
1750
1751     private void updateStaticFlowConfigsOnContainerModeChange(UpdateType update) {
1752         log.trace("Updating Static Flow configs on container mode change: {}", update);
1753
1754         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1755             FlowConfig config = entry.getValue();
1756             if (config.isPortGroupEnabled()) {
1757                 continue;
1758             }
1759             if (config.installInHw() && !config.isInternalFlow()) {
1760                 switch (update) {
1761                 case ADDED:
1762                     config.setStatus("Removed from node because in container mode");
1763                     break;
1764                 case REMOVED:
1765                     config.setStatus(StatusCode.SUCCESS.toString());
1766                     break;
1767                 default:
1768                     break;
1769                 }
1770             }
1771         }
1772         // Update cluster cache
1773         refreshClusterStaticFlowsStatus(null);
1774     }
1775
1776     @Override
1777     public Status removeStaticFlow(FlowConfig config) {
1778         return removeStaticFlow(config, false);
1779     }
1780
1781     @Override
1782     public Status removeStaticFlowAsync(FlowConfig config) {
1783         return removeStaticFlow(config, true);
1784     }
1785
1786     private Status removeStaticFlow(FlowConfig config, boolean async) {
1787         /*
1788          * No config.isInternal() check as NB does not take this path and GUI
1789          * cannot issue a delete on an internal generated flow. We need this
1790          * path to be accessible when switch mode is changed from proactive to
1791          * reactive, so that we can remove the internal generated LLDP and ARP
1792          * punt flows
1793          */
1794
1795         // Look for the target configuration entry
1796         Integer key = 0;
1797         FlowConfig target = null;
1798         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1799             if (entry.getValue().isByNameAndNodeIdEqual(config)) {
1800                 key = entry.getKey();
1801                 target = entry.getValue();
1802                 break;
1803             }
1804         }
1805         if (target == null) {
1806             return new Status(StatusCode.NOTFOUND, "Entry Not Present");
1807         }
1808
1809         // Program the network node
1810         Status status = async ? this.uninstallFlowEntryAsync(config.getFlowEntry()) : this.uninstallFlowEntry(config
1811                 .getFlowEntry());
1812
1813         // Update configuration database if programming was successful
1814         if (status.isSuccess()) {
1815             staticFlows.remove(key);
1816         }
1817
1818         return status;
1819     }
1820
1821     @Override
1822     public Status removeStaticFlow(String name, Node node) {
1823        return removeStaticFlow(name, node, false);
1824     }
1825
1826     @Override
1827     public Status removeStaticFlowAsync(String name, Node node) {
1828         return removeStaticFlow(name, node, true);
1829     }
1830
1831     private Status removeStaticFlow(String name, Node node, boolean async) {
1832         // Look for the target configuration entry
1833         Integer key = 0;
1834         FlowConfig target = null;
1835         for (ConcurrentMap.Entry<Integer, FlowConfig> mapEntry : staticFlows.entrySet()) {
1836             if (mapEntry.getValue().isByNameAndNodeIdEqual(name, node)) {
1837                 key = mapEntry.getKey();
1838                 target = mapEntry.getValue();
1839                 break;
1840             }
1841         }
1842         if (target == null) {
1843             return new Status(StatusCode.NOTFOUND, "Entry Not Present");
1844         }
1845
1846         // Validity check for api3 entry point
1847         if (target.isInternalFlow()) {
1848             String msg = "Invalid operation: Controller generated flow cannot be deleted";
1849             String logMsg = msg + ": {}";
1850             log.warn(logMsg, name);
1851             return new Status(StatusCode.NOTACCEPTABLE, msg);
1852         }
1853
1854         if (target.isPortGroupEnabled()) {
1855             String msg = "Invalid operation: Port Group flows cannot be deleted through this API";
1856             String logMsg = msg + ": {}";
1857             log.warn(logMsg, name);
1858             return new Status(StatusCode.NOTACCEPTABLE, msg);
1859         }
1860
1861         // Program the network node
1862         Status status = this.removeEntry(target.getFlowEntry(), async);
1863
1864         // Update configuration database if programming was successful
1865         if (status.isSuccess()) {
1866             staticFlows.remove(key);
1867         }
1868
1869         return status;
1870     }
1871
1872     @Override
1873     public Status modifyStaticFlow(FlowConfig newFlowConfig) {
1874         // Validity check for api3 entry point
1875         if (newFlowConfig.isInternalFlow()) {
1876             String msg = "Invalid operation: Controller generated flow cannot be modified";
1877             String logMsg = msg + ": {}";
1878             log.warn(logMsg, newFlowConfig);
1879             return new Status(StatusCode.NOTACCEPTABLE, msg);
1880         }
1881
1882         // Validity Check
1883         Status status = newFlowConfig.validate();
1884         if (!status.isSuccess()) {
1885             String msg = "Invalid Configuration (" + status.getDescription() + ")";
1886             newFlowConfig.setStatus(msg);
1887             log.warn("Invalid Configuration for flow {}. The failure is {}", newFlowConfig, status.getDescription());
1888             return new Status(StatusCode.BADREQUEST, msg);
1889         }
1890
1891         FlowConfig oldFlowConfig = null;
1892         Integer index = null;
1893         for (ConcurrentMap.Entry<Integer, FlowConfig> mapEntry : staticFlows.entrySet()) {
1894             FlowConfig entry = mapEntry.getValue();
1895             if (entry.isByNameAndNodeIdEqual(newFlowConfig.getName(), newFlowConfig.getNode())) {
1896                 oldFlowConfig = entry;
1897                 index = mapEntry.getKey();
1898                 break;
1899             }
1900         }
1901
1902         if (oldFlowConfig == null) {
1903             String msg = "Attempt to modify a non existing static flow";
1904             String logMsg = msg + ": {}";
1905             log.warn(logMsg, newFlowConfig);
1906             return new Status(StatusCode.NOTFOUND, msg);
1907         }
1908
1909         // Do not attempt to reinstall the flow, warn user
1910         if (newFlowConfig.equals(oldFlowConfig)) {
1911             String msg = "No modification detected";
1912             log.trace("Static flow modification skipped. New flow and old flow are the same: {}", newFlowConfig);
1913             return new Status(StatusCode.SUCCESS, msg);
1914         }
1915
1916         // If flow is installed, program the network node
1917         status = new Status(StatusCode.SUCCESS, "Saved in config");
1918         if (oldFlowConfig.installInHw()) {
1919             status = this.modifyFlowEntry(oldFlowConfig.getFlowEntry(), newFlowConfig.getFlowEntry());
1920         }
1921
1922         // Update configuration database if programming was successful
1923         if (status.isSuccess()) {
1924             newFlowConfig.setStatus(status.getDescription());
1925             staticFlows.put(index, newFlowConfig);
1926         }
1927
1928         return status;
1929     }
1930
1931     @Override
1932     public Status toggleStaticFlowStatus(String name, Node node) {
1933         return toggleStaticFlowStatus(getStaticFlow(name, node));
1934     }
1935
1936     @Override
1937     public Status toggleStaticFlowStatus(FlowConfig config) {
1938         if (config == null) {
1939             String msg = "Invalid request: null flow config";
1940             log.warn(msg);
1941             return new Status(StatusCode.BADREQUEST, msg);
1942         }
1943         // Validity check for api3 entry point
1944         if (config.isInternalFlow()) {
1945             String msg = "Invalid operation: Controller generated flow cannot be modified";
1946             String logMsg = msg + ": {}";
1947             log.warn(logMsg, config);
1948             return new Status(StatusCode.NOTACCEPTABLE, msg);
1949         }
1950
1951         // Find the config entry
1952         Integer key = 0;
1953         FlowConfig target = null;
1954         for (Map.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1955             FlowConfig conf = entry.getValue();
1956             if (conf.isByNameAndNodeIdEqual(config)) {
1957                 key = entry.getKey();
1958                 target = conf;
1959                 break;
1960             }
1961         }
1962         if (target != null) {
1963             Status status = target.validate();
1964             if (!status.isSuccess()) {
1965                 log.warn(status.getDescription());
1966                 return status;
1967             }
1968             status = (target.installInHw()) ? this.uninstallFlowEntry(target.getFlowEntry()) : this
1969                                     .installFlowEntry(target.getFlowEntry());
1970             if (status.isSuccess()) {
1971                 // Update Configuration database
1972                 target.setStatus(StatusCode.SUCCESS.toString());
1973                 target.toggleInstallation();
1974                 staticFlows.put(key, target);
1975             }
1976             return status;
1977         }
1978
1979         return new Status(StatusCode.NOTFOUND, "Unable to locate the entry. Failed to toggle status");
1980     }
1981
1982     /**
1983      * Reinsert all static flows entries in the cache to force cache updates in
1984      * the cluster. This is useful when only some parameters were changed in the
1985      * entries, like the status.
1986      *
1987      * @param node
1988      *            The node for which the static flow configurations have to be
1989      *            refreshed. If null, all nodes static flows will be refreshed.
1990      */
1991     private void refreshClusterStaticFlowsStatus(Node node) {
1992         // Refresh cluster cache
1993         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
1994             if (node == null || entry.getValue().getNode().equals(node)) {
1995                 staticFlows.put(entry.getKey(), entry.getValue());
1996             }
1997         }
1998     }
1999
2000     /**
2001      * Uninstall all the non-internal Flow Entries present in the software view.
2002      * If requested, a copy of each original flow entry will be stored in the
2003      * inactive list so that it can be re-applied when needed (This is typically
2004      * the case when running in the default container and controller moved to
2005      * container mode) NOTE WELL: The routine as long as does a bulk change will
2006      * operate only on the entries for nodes locally attached so to avoid
2007      * redundant operations initiated by multiple nodes
2008      *
2009      * @param preserveFlowEntries
2010      *            if true, a copy of each original entry is stored in the
2011      *            inactive list
2012      */
2013     private void uninstallAllFlowEntries(boolean preserveFlowEntries) {
2014         log.trace("Uninstalling all non-internal flows");
2015
2016         List<FlowEntryInstall> toRemove = new ArrayList<FlowEntryInstall>();
2017
2018         // Store entries / create target list
2019         for (ConcurrentMap.Entry<FlowEntryInstall, FlowEntryInstall> mapEntry : installedSwView.entrySet()) {
2020             FlowEntryInstall flowEntries = mapEntry.getValue();
2021             // Skip internal generated static flows
2022             if (!flowEntries.isInternal()) {
2023                 toRemove.add(flowEntries);
2024                 // Store the original entries if requested
2025                 if (preserveFlowEntries) {
2026                     inactiveFlows.put(flowEntries.getOriginal(), flowEntries.getOriginal());
2027                 }
2028             }
2029         }
2030
2031         // Now remove the entries
2032         for (FlowEntryInstall flowEntryHw : toRemove) {
2033             Node n = flowEntryHw.getNode();
2034             if (n != null && connectionManager.getLocalityStatus(n) == ConnectionLocality.LOCAL) {
2035                 Status status = this.removeEntryInternal(flowEntryHw, false);
2036                 if (!status.isSuccess()) {
2037                     log.trace("Failed to remove entry: {}. The failure is: {}", flowEntryHw, status.getDescription());
2038                 }
2039             } else {
2040                 log.debug("Not removing entry {} because not connected locally, the remote guy will do it's job",
2041                         flowEntryHw);
2042             }
2043         }
2044     }
2045
2046     /**
2047      * Re-install all the Flow Entries present in the inactive list The inactive
2048      * list will be empty at the end of this call This function is called on the
2049      * default container instance of FRM only when the last container is deleted
2050      */
2051     private void reinstallAllFlowEntries() {
2052         log.trace("Reinstalling all inactive flows");
2053
2054         for (FlowEntry flowEntry : this.inactiveFlows.keySet()) {
2055             this.addEntry(flowEntry, false);
2056         }
2057
2058         // Empty inactive list in any case
2059         inactiveFlows.clear();
2060     }
2061
2062     @Override
2063     public List<FlowConfig> getStaticFlows() {
2064         return new ArrayList<FlowConfig>(staticFlows.values());
2065     }
2066
2067     @Override
2068     public FlowConfig getStaticFlow(String name, Node node) {
2069         ConcurrentMap.Entry<Integer, FlowConfig> entry = getStaticFlowEntry(name, node);
2070         if(entry != null) {
2071             return entry.getValue();
2072         }
2073         return null;
2074     }
2075
2076     @Override
2077     public List<FlowConfig> getStaticFlows(Node node) {
2078         List<FlowConfig> list = new ArrayList<FlowConfig>();
2079         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
2080             if (entry.getValue().onNode(node)) {
2081                 list.add(entry.getValue());
2082             }
2083         }
2084         return list;
2085     }
2086
2087     @Override
2088     public List<String> getStaticFlowNamesForNode(Node node) {
2089         List<String> list = new ArrayList<String>();
2090         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
2091             if (entry.getValue().onNode(node)) {
2092                 list.add(entry.getValue().getName());
2093             }
2094         }
2095         return list;
2096     }
2097
2098     @Override
2099     public List<Node> getListNodeWithConfiguredFlows() {
2100         Set<Node> set = new HashSet<Node>();
2101         for (ConcurrentMap.Entry<Integer, FlowConfig> entry : staticFlows.entrySet()) {
2102             set.add(entry.getValue().getNode());
2103         }
2104         return new ArrayList<Node>(set);
2105     }
2106
2107     private void loadFlowConfiguration() {
2108         for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, PORT_GROUP_FILE_NAME)) {
2109             addPortGroupConfig(((PortGroupConfig) conf).getName(), ((PortGroupConfig) conf).getMatchString(), true);
2110         }
2111
2112         for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, STATIC_FLOWS_FILE_NAME)) {
2113             addStaticFlowInternal((FlowConfig) conf, false, true);
2114         }
2115     }
2116
2117     @Override
2118     public Object readObject(ObjectInputStream ois) throws FileNotFoundException, IOException, ClassNotFoundException {
2119         return ois.readObject();
2120     }
2121
2122     @Override
2123     public Status saveConfig() {
2124         return saveConfigInternal();
2125     }
2126
2127     private Status saveConfigInternal() {
2128         List<ConfigurationObject> nonDynamicFlows = new ArrayList<ConfigurationObject>();
2129
2130         for (Integer ordinal : staticFlows.keySet()) {
2131             FlowConfig config = staticFlows.get(ordinal);
2132             // Do not save dynamic and controller generated static flows
2133             if (config.isDynamic() || config.isInternalFlow()) {
2134                 continue;
2135             }
2136             nonDynamicFlows.add(config);
2137         }
2138
2139         configurationService.persistConfiguration(nonDynamicFlows, STATIC_FLOWS_FILE_NAME);
2140         configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(portGroupConfigs.values()),
2141                 PORT_GROUP_FILE_NAME);
2142
2143         return new Status(StatusCode.SUCCESS);
2144     }
2145
2146     @Override
2147     public void subnetNotify(Subnet sub, boolean add) {
2148     }
2149
2150     private boolean programInternalFlow(boolean proactive, FlowConfig fc) {
2151         boolean retVal = true; // program flows unless determined otherwise
2152         if(proactive) {
2153             // if the flow already exists do not program
2154             if(flowConfigExists(fc)) {
2155                 retVal = false;
2156             }
2157         } else {
2158             // if the flow does not exist do not program
2159             if(!flowConfigExists(fc)) {
2160                 retVal = false;
2161             }
2162         }
2163         return retVal;
2164     }
2165
2166     /**
2167      * (non-Javadoc)
2168      *
2169      * @see org.opendaylight.controller.switchmanager.ISwitchManagerAware#modeChangeNotify(org.opendaylight.controller.sal.core.Node,
2170      *      boolean)
2171      *
2172      *      This method can be called from within the OSGi framework context,
2173      *      given the programming operation can take sometime, it not good
2174      *      pratice to have in it's context operations that can take time,
2175      *      hence moving off to a different thread for async processing.
2176      */
2177     private ExecutorService executor;
2178     @Override
2179     public void modeChangeNotify(final Node node, final boolean proactive) {
2180         Callable<Status> modeChangeCallable = new Callable<Status>() {
2181             @Override
2182             public Status call() throws Exception {
2183                 List<FlowConfig> defaultConfigs = new ArrayList<FlowConfig>();
2184
2185                 List<String> puntAction = new ArrayList<String>();
2186                 puntAction.add(ActionType.CONTROLLER.toString());
2187
2188                 FlowConfig allowARP = new FlowConfig();
2189                 allowARP.setInstallInHw(true);
2190                 allowARP.setName(FlowConfig.INTERNALSTATICFLOWBEGIN + "Punt ARP" + FlowConfig.INTERNALSTATICFLOWEND);
2191                 allowARP.setPriority("1");
2192                 allowARP.setNode(node);
2193                 allowARP.setEtherType("0x" + Integer.toHexString(EtherTypes.ARP.intValue())
2194                         .toUpperCase());
2195                 allowARP.setActions(puntAction);
2196                 defaultConfigs.add(allowARP);
2197
2198                 FlowConfig allowLLDP = new FlowConfig();
2199                 allowLLDP.setInstallInHw(true);
2200                 allowLLDP.setName(FlowConfig.INTERNALSTATICFLOWBEGIN + "Punt LLDP" + FlowConfig.INTERNALSTATICFLOWEND);
2201                 allowLLDP.setPriority("1");
2202                 allowLLDP.setNode(node);
2203                 allowLLDP.setEtherType("0x" + Integer.toHexString(EtherTypes.LLDP.intValue())
2204                         .toUpperCase());
2205                 allowLLDP.setActions(puntAction);
2206                 defaultConfigs.add(allowLLDP);
2207
2208                 List<String> dropAction = new ArrayList<String>();
2209                 dropAction.add(ActionType.DROP.toString());
2210
2211                 FlowConfig dropAllConfig = new FlowConfig();
2212                 dropAllConfig.setInstallInHw(true);
2213                 dropAllConfig.setName(FlowConfig.INTERNALSTATICFLOWBEGIN + "Catch-All Drop"
2214                         + FlowConfig.INTERNALSTATICFLOWEND);
2215                 dropAllConfig.setPriority("0");
2216                 dropAllConfig.setNode(node);
2217                 dropAllConfig.setActions(dropAction);
2218                 defaultConfigs.add(dropAllConfig);
2219
2220                 log.trace("Forwarding mode for node {} set to {}", node, (proactive ? "proactive" : "reactive"));
2221                 for (FlowConfig fc : defaultConfigs) {
2222                     // check if the frm really needs to act on the notification.
2223                     // this is to check against duplicate notifications
2224                     if(programInternalFlow(proactive, fc)) {
2225                         Status status = (proactive) ? addStaticFlowInternal(fc, false, false) : removeStaticFlow(fc);
2226                         if (status.isSuccess()) {
2227                             log.trace("{} Proactive Static flow: {}", (proactive ? "Installed" : "Removed"), fc.getName());
2228                         } else {
2229                             log.warn("Failed to {} Proactive Static flow: {}", (proactive ? "install" : "remove"),
2230                                     fc.getName());
2231                         }
2232                     } else {
2233                         log.debug("Got redundant install request for internal flow: {} on node: {}. Request not sent to FRM.", fc.getName(), node);
2234                     }
2235                 }
2236                 return new Status(StatusCode.SUCCESS);
2237             }
2238         };
2239
2240         /*
2241          * Execute the work outside the caller context, this could be an
2242          * expensive operation and we don't want to block the caller for it.
2243          */
2244         this.executor.submit(modeChangeCallable);
2245     }
2246
2247     /**
2248      * Remove from the databases all the flows installed on the node
2249      *
2250      * @param node
2251      */
2252     private void cleanDatabaseForNode(Node node) {
2253         log.trace("Cleaning Flow database for Node {}", node);
2254         if (nodeFlows.containsKey(node)) {
2255             List<FlowEntryInstall> toRemove = new ArrayList<FlowEntryInstall>(nodeFlows.get(node));
2256
2257             for (FlowEntryInstall entry : toRemove) {
2258                 updateSwViews(entry, false);
2259             }
2260         }
2261     }
2262
2263     private boolean doesFlowContainNodeConnector(Flow flow, NodeConnector nc) {
2264         if (nc == null) {
2265             return false;
2266         }
2267
2268         Match match = flow.getMatch();
2269         if (match.isPresent(MatchType.IN_PORT)) {
2270             NodeConnector matchPort = (NodeConnector) match.getField(MatchType.IN_PORT).getValue();
2271             if (matchPort.equals(nc)) {
2272                 return true;
2273             }
2274         }
2275         List<Action> actionsList = flow.getActions();
2276         if (actionsList != null) {
2277             for (Action action : actionsList) {
2278                 if (action instanceof Output) {
2279       &nb