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