Do not catch Throwables, but rather Exceptions
[controller.git] / opendaylight / samples / simpleforwarding / src / main / java / org / opendaylight / controller / samples / simpleforwarding / internal / SimpleForwardingImpl.java
1
2 /*
3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
4  *
5  * This program and the accompanying materials are made available under the
6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
7  * and is available at http://www.eclipse.org/legal/epl-v10.html
8  */
9
10 package org.opendaylight.controller.samples.simpleforwarding.internal;
11
12 import java.util.ArrayList;
13 import java.util.EnumSet;
14 import java.util.HashMap;
15 import java.util.HashSet;
16 import java.util.Iterator;
17 import java.util.LinkedList;
18 import java.util.List;
19 import java.util.Map;
20 import java.util.Set;
21 import java.util.concurrent.ConcurrentMap;
22
23 import org.opendaylight.controller.clustering.services.CacheConfigException;
24 import org.opendaylight.controller.clustering.services.CacheExistException;
25 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
26 import org.opendaylight.controller.clustering.services.IClusterServices;
27 import org.opendaylight.controller.forwardingrulesmanager.FlowEntry;
28 import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
29 import org.opendaylight.controller.hosttracker.IfIptoHost;
30 import org.opendaylight.controller.hosttracker.IfNewHostNotify;
31 import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
32 import org.opendaylight.controller.sal.action.Action;
33 import org.opendaylight.controller.sal.action.Output;
34 import org.opendaylight.controller.sal.action.PopVlan;
35 import org.opendaylight.controller.sal.action.SetDlDst;
36 import org.opendaylight.controller.sal.action.SetVlanId;
37 import org.opendaylight.controller.sal.core.Edge;
38 import org.opendaylight.controller.sal.core.Node;
39 import org.opendaylight.controller.sal.core.NodeConnector;
40 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
41 import org.opendaylight.controller.sal.core.Path;
42 import org.opendaylight.controller.sal.core.Property;
43 import org.opendaylight.controller.sal.core.State;
44 import org.opendaylight.controller.sal.core.UpdateType;
45 import org.opendaylight.controller.sal.flowprogrammer.Flow;
46 import org.opendaylight.controller.sal.match.Match;
47 import org.opendaylight.controller.sal.match.MatchType;
48 import org.opendaylight.controller.sal.routing.IListenRoutingUpdates;
49 import org.opendaylight.controller.sal.routing.IRouting;
50 import org.opendaylight.controller.sal.utils.EtherTypes;
51 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
52 import org.opendaylight.controller.sal.utils.Status;
53 import org.opendaylight.controller.samples.simpleforwarding.HostNodePair;
54 import org.opendaylight.controller.switchmanager.IInventoryListener;
55 import org.opendaylight.controller.switchmanager.ISwitchManager;
56 import org.opendaylight.controller.topologymanager.ITopologyManager;
57 import org.slf4j.Logger;
58 import org.slf4j.LoggerFactory;
59
60 /**
61  * This class implements basic L3 forwarding within the managed devices.
62  * Forwarding is only done within configured subnets.</br>
63  * <br/>
64  * The basic flow is that the module listens for new hosts from the
65  * {@link org.opendaylight.controller.hosttracker.IfIptoHost HostTracker}
66  * service and on discovering a new host it first calls
67  * <tt>preparePerHostRules()</tt> to create a set of new rules that must be
68  * installed in the network. This is done by repeatedly calling
69  * <tt>updatePerHostRuleInSW()</tt> for each switch in the network. Then it
70  * installs those rules using <tt>installPerHostRules()</tt>.
71  */
72 public class SimpleForwardingImpl implements IfNewHostNotify,
73         IListenRoutingUpdates, IInventoryListener {
74     private static Logger log = LoggerFactory
75             .getLogger(SimpleForwardingImpl.class);
76     private static short DEFAULT_IPSWITCH_PRIORITY = 1;
77     private static String FORWARDING_RULES_CACHE_NAME = "forwarding.ipswitch.rules";
78     private IfIptoHost hostTracker;
79     private IForwardingRulesManager frm;
80     private ITopologyManager topologyManager;
81     private IRouting routing;
82
83     /**
84      * The set of all forwarding rules: (host) -> (switch -> flowmod). Note that
85      * the host includes an attachment point and that while the switch appears
86      * to be a switch's port, in actuality it is a special port which just
87      * represents the switch.
88      */
89     private ConcurrentMap<HostNodePair, HashMap<NodeConnector, FlowEntry>> rulesDB;
90     private Map<Node, List<FlowEntry>> tobePrunedPos = new HashMap<Node, List<FlowEntry>>();
91     private IClusterContainerServices clusterContainerService = null;
92     private ISwitchManager switchManager;
93
94     /**
95      * Return codes from the programming of the perHost rules in HW
96      */
97     public enum RulesProgrammingReturnCode {
98         SUCCESS, FAILED_FEW_SWITCHES, FAILED_ALL_SWITCHES, FAILED_WRONG_PARAMS
99     }
100
101     public void setRouting(IRouting routing) {
102         this.routing = routing;
103     }
104
105     public void unsetRouting(IRouting routing) {
106         if (this.routing == routing) {
107             this.routing = null;
108         }
109     }
110
111     public ITopologyManager getTopologyManager() {
112         return topologyManager;
113     }
114
115     public void setTopologyManager(ITopologyManager topologyManager) {
116         log.debug("Setting topologyManager");
117         this.topologyManager = topologyManager;
118     }
119
120     public void unsetTopologyManager(ITopologyManager topologyManager) {
121         if (this.topologyManager == topologyManager) {
122             this.topologyManager = null;
123         }
124     }
125
126     public void setHostTracker(IfIptoHost hostTracker) {
127         log.debug("Setting HostTracker");
128         this.hostTracker = hostTracker;
129     }
130
131     public void setForwardingRulesManager(
132             IForwardingRulesManager forwardingRulesManager) {
133         log.debug("Setting ForwardingRulesManager");
134         this.frm = forwardingRulesManager;
135     }
136
137     public void unsetHostTracker(IfIptoHost hostTracker) {
138         if (this.hostTracker == hostTracker) {
139             this.hostTracker = null;
140         }
141     }
142
143     public void unsetForwardingRulesManager(
144             IForwardingRulesManager forwardingRulesManager) {
145         if (this.frm == forwardingRulesManager) {
146             this.frm = null;
147         }
148     }
149
150     /**
151      * Function called when the bundle gets activated
152      *
153      */
154     public void startUp() {
155         allocateCaches();
156         retrieveCaches();
157     }
158
159     /**
160      * Function called when the bundle gets stopped
161      *
162      */
163     public void shutDown() {
164         log.debug("Destroy all the host Rules given we are shutting down");
165         uninstallPerHostRules();
166         destroyCaches();
167     }
168
169     private void allocateCaches() {
170         if (this.clusterContainerService == null) {
171             log.trace("un-initialized clusterContainerService, can't create cache");
172             return;
173         }
174
175         try {
176             clusterContainerService.createCache(FORWARDING_RULES_CACHE_NAME,
177                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
178         } catch (CacheExistException cee) {
179             log.error("\nCache already exists - destroy and recreate if needed");
180         } catch (CacheConfigException cce) {
181             log.error("\nCache configuration invalid - check cache mode");
182         }
183     }
184
185     @SuppressWarnings({ "unchecked" })
186     private void retrieveCaches() {
187         if (this.clusterContainerService == null) {
188             log.trace("un-initialized clusterContainerService, can't retrieve cache");
189             return;
190         }
191
192         rulesDB = (ConcurrentMap<HostNodePair, HashMap<NodeConnector, FlowEntry>>) clusterContainerService
193                 .getCache(FORWARDING_RULES_CACHE_NAME);
194         if (rulesDB == null) {
195             log.error("\nFailed to get rulesDB handle");
196         }
197     }
198
199     private void destroyCaches() {
200         if (this.clusterContainerService == null) {
201             log.trace("un-initialized clusterContainerService, can't destroy cache");
202             return;
203         }
204
205         clusterContainerService.destroyCache(FORWARDING_RULES_CACHE_NAME);
206     }
207
208     /**
209      * Populates <tt>rulesDB</tt> with rules specifying how to reach
210      * <tt>host</tt> from <tt>currNode</tt> assuming that:
211      * <ul>
212      * <li><tt>host</tt> is attached to <tt>rootNode</tt>
213      * <li><tt>link</tt> is the next part of the path to reach <tt>rootNode</tt>
214      * from <tt>currNode</tt>
215      * <li><tt>rulesDB.get(key)</tt> represents the list of rules stored about
216      * <tt>host</tt> at <tt>currNode</tt>
217      * </ul>
218      *
219      * @param host
220      *            The host to be reached.
221      * @param currNode
222      *            The current node being processed.
223      * @param rootNode
224      *            The node to be reached. Really, the switch which host is
225      *            attached to.
226      * @param link
227      *            The link to follow from curNode to get to rootNode
228      * @param key
229      *            The key to store computed rules at in the rulesDB. For now,
230      *            this is a {@link HostNodePair} of host and currNode.
231      */
232     private void updatePerHostRuleInSW(HostNodeConnector host, Node currNode,
233             Node rootNode, Edge link, HostNodePair key) {
234
235         // only the link parameter is optional
236         if (host == null || key == null || currNode == null || rootNode == null) {
237             return;
238         }
239
240         Set<NodeConnector> ports = new HashSet<NodeConnector>();
241         // add a special port of type ALL and port 0 to represent the node
242         // without specifying a port on that node
243         ports.add(NodeConnectorCreator.createNodeConnector(
244                 NodeConnectorIDType.ALL, NodeConnector.SPECIALNODECONNECTORID,
245                 currNode));
246
247         HashMap<NodeConnector, FlowEntry> pos = this.rulesDB.get(key);
248         if (pos == null) {
249             pos = new HashMap<NodeConnector, FlowEntry>();
250         }
251
252         for (NodeConnector inPort : ports) {
253             // skip the port connected to the target host
254             if (currNode.equals(rootNode)
255                     && (host.getnodeConnector().equals(inPort))) {
256                 continue;
257             }
258
259             // remove the current rule, if any
260             FlowEntry removed_po = pos.remove(inPort);
261             Match match = new Match();
262             List<Action> actions = new ArrayList<Action>();
263
264             // IP destination based forwarding on /32 entries only!
265             match.setField(MatchType.DL_TYPE, EtherTypes.IPv4.shortValue());
266             match.setField(MatchType.NW_DST, host.getNetworkAddress());
267
268             /* Action for the policy is to forward to a port except on the
269              * switch where the host sits, which is to rewrite also the MAC
270              * and to forward on the Host port */
271             NodeConnector outPort = null;
272
273             if (currNode.equals(rootNode)) {
274                 /* If we're at the root node, then rewrite the DL addr and
275                  * possibly pop the VLAN tag. This allows for MAC rewriting
276                  * in the core of the network assuming we can uniquely ID
277                  * packets based on IP address. */
278
279                 outPort = host.getnodeConnector();
280                 if (inPort.equals(outPort)) {
281                     // TODO: isn't this code skipped already by the above continue?
282                     // skip the host port
283                     continue;
284                 }
285                 actions.add(new SetDlDst(host.getDataLayerAddressBytes()));
286
287                 if (!inPort.getType().equals(NodeConnectorIDType.ALL)) {
288                     // Container mode: at the destination switch, we need to strip out the tag (VLAN)
289                     actions.add(new PopVlan());
290                 }
291             } else {
292                 // currNode is NOT the rootNode, find the next hop and create a rule
293                 if (link != null) {
294                     outPort = link.getTailNodeConnector();
295                     if (inPort.equals(outPort)) {
296                         // skip the outgoing port
297                         continue;
298                     }
299
300                     // If outPort is network link, add VLAN tag
301                     if (topologyManager.isInternal(outPort)) {
302                         log.debug("outPort {}/{} is internal uplink port",
303                                 currNode, outPort);
304                     } else {
305                         log.debug("outPort {}/{} is host facing port",
306                                 currNode, outPort);
307                     }
308
309                     if ((!inPort.getType().equals(NodeConnectorIDType.ALL))
310                         && (topologyManager.isInternal(outPort))) {
311                         Node nextNode = link.getHeadNodeConnector()
312                                             .getNode();
313                         // TODO: Replace this with SAL equivalent
314                         //short tag = container.getTag((Long)nextNode.getNodeID());
315                         short tag = 0;
316                         if (tag != 0) {
317                             log.debug("adding SET_VLAN {} for traffic " +
318                                     "leaving {}/{} toward switch {}",
319                                     new Object[] { tag, currNode, outPort,
320                                     nextNode});
321                             actions.add(new SetVlanId(tag));
322                         } else {
323                             log.debug("No tag assigned to switch {}", nextNode);
324                         }
325                     }
326                 }
327             }
328             if (outPort != null) {
329                 actions.add(new Output(outPort));
330             }
331             if (!inPort.getType().equals(NodeConnectorIDType.ALL)) {
332                 // include input port in the flow match field
333                 match.setField(MatchType.IN_PORT, inPort);
334
335                 if (topologyManager.isInternal(inPort)) {
336                     log.debug("inPort {}/{} is internal uplink port", currNode,
337                             inPort);
338                 } else {
339                     log.debug("inPort {}/{} is host facing port", currNode,
340                             inPort);
341                 }
342
343                 // for incoming network link; if the VLAN tag is defined, include it for incoming flow matching
344                 if (topologyManager.isInternal(inPort)) {
345                     // TODO: Replace this with SAL equivalent
346                     //short tag = container.getTag((Long)currNode.getNodeID());
347                     short tag = 0;
348                     if (tag != 0) {
349                         log.debug("adding MATCH VLAN {} for traffic entering" +
350                                 "  {}/{}",
351                                 new Object[] {tag, currNode, inPort});
352                         match.setField(MatchType.DL_VLAN, tag);
353                     } else {
354                         log.debug("No tag assigned to switch {}", currNode);
355                     }
356                 }
357             }
358             // Make sure the priority for IP switch entries is
359             // set to a level just above default drop entries
360             Flow flow = new Flow(match, actions);
361             flow.setIdleTimeout((short) 0);
362             flow.setHardTimeout((short) 0);
363             flow.setPriority(DEFAULT_IPSWITCH_PRIORITY);
364
365             String policyName = host.getNetworkAddress().getHostAddress()
366                     + "/32";
367             String flowName = "["
368                     + (!inPort.getType().equals(NodeConnectorIDType.ALL) ?
369                        (inPort.getID()).toString()
370                        + "," : "")
371                     + host.getNetworkAddress().getHostAddress() + "/32 on N "
372                     + currNode + "]";
373             FlowEntry po = new FlowEntry(policyName, flowName, flow, currNode);
374
375             /* Now save the rule in the DB rule, so on updates from topology we
376              * can selectively */
377             pos.put(inPort, po);
378             this.rulesDB.put(key, pos);
379             if (!inPort.getType().equals(NodeConnectorIDType.ALL)) {
380                 log.debug("Adding Match(inPort = {} , DIP = {})" +
381                         " Action(outPort= {}) to node {}",
382                         new Object[] { inPort,
383                         host.getNetworkAddress().getHostAddress(),
384                         outPort, currNode});
385                 if ((removed_po != null)
386                         && (!po.getFlow().getMatch().equals(
387                                 removed_po.getFlow().getMatch()))) {
388                     log.debug("Old Flow match: {}, New Flow match: {}",
389                             removed_po.getFlow().getMatch(), po.getFlow()
390                                     .getMatch());
391                     addTobePrunedPolicy(currNode, removed_po, po);
392                 }
393
394             } else {
395                 log.debug("Adding policyMatch(DIP = {}) Action(outPort= {}) " +
396                         "to node {}", new Object[] {
397                         host.getNetworkAddress().getHostAddress(), outPort,
398                         currNode});
399             }
400         }
401     }
402
403     /**
404      * Calculate the per-Host rules to be installed in the rulesDB,
405      * and that will later on be installed in HW, this routine will
406      * implicitly calculate the shortest path tree among the switch
407      * to which the host is attached and all the other switches in the
408      * network and will automatically create all the rules that allow
409      * a /32 destination IP based forwarding, as in traditional IP
410      * networks.
411      *
412      * @param host Host for which we are going to prepare the rules in the rulesDB
413      *
414      * @return A set of switches touched by the calculation
415      */
416     private Set<Node> preparePerHostRules(HostNodeConnector host) {
417         if (host == null) {
418             return null;
419         }
420
421         //TODO: race condition! unset* functions can make these null.
422         if (this.routing == null) {
423             return null;
424         }
425         if (this.switchManager == null) {
426             return null;
427         }
428         if (this.rulesDB == null) {
429             return null;
430         }
431
432         Node rootNode = host.getnodeconnectorNode();
433         Set<Node> nodes = this.switchManager.getNodes();
434         Set<Node> switchesToProgram = new HashSet<Node>();
435         HostNodePair key;
436         HashMap<NodeConnector, FlowEntry> pos;
437         FlowEntry po;
438
439         // for all nodes in the system
440         for (Node node : nodes) {
441             if (node.equals(rootNode)) {
442                 // We skip it because for the node with host attached
443                 // we will process in every case even if there are no
444                 // routes
445                 continue;
446             }
447             List<Edge> links;
448             Path res = this.routing.getRoute(node, rootNode);
449             if ((res == null) || ((links = res.getEdges()) == null)) {
450                 // No route from node to rootNode can be found, back out any
451                 // existing forwarding rules if they exist.
452                 log.debug("NO Route/Path between SW[{}] --> SW[{}] cleaning " +
453                         "potentially existing entries", node, rootNode);
454                 key = new HostNodePair(host, node);
455                 pos = this.rulesDB.get(key);
456                 if (pos != null) {
457                     for (Map.Entry<NodeConnector, FlowEntry> e : pos.entrySet()) {
458                         po = e.getValue();
459                         if (po != null) {
460                             // uninstall any existing rules we put in the
461                             // ForwardingRulesManager
462                             this.frm.uninstallFlowEntry(po);
463                         }
464                     }
465                     this.rulesDB.remove(key);
466                 }
467                 continue;
468             }
469
470             log.debug("Route between SW[{}] --> SW[{}]", node, rootNode);
471             Node currNode = node;
472             key = new HostNodePair(host, currNode);
473
474             // for each link in the route from here to there
475             for (Edge link : links) {
476                 if (link == null) {
477                     log.error("Could not retrieve the Link");
478                     // TODO: should we keep going?
479                     continue;
480                 }
481
482                 log.debug(link.toString());
483
484                 // Index all the switches to be programmed
485                 updatePerHostRuleInSW(host, currNode, rootNode, link, key);
486                 if ((this.rulesDB.get(key)) != null) {
487                     /* Calling updatePerHostRuleInSW() doesn't guarantee that
488                      * rules will be added in currNode (e.g, there is only one
489                      * link from currNode to rootNode This check makes sure that
490                      * there are some rules in the rulesDB for the given key
491                      * prior to adding switch to switchesToProgram
492                      */
493                     switchesToProgram.add(currNode);
494                 }
495                 currNode = link.getHeadNodeConnector().getNode();
496                 key = new HostNodePair(host, currNode);
497             }
498         }
499
500         // This rule will be added no matter if any topology is built
501         // or no, it serve as a way to handle the case of a node with
502         // multiple hosts attached to it but not yet connected to the
503         // rest of the world
504         switchesToProgram.add(rootNode);
505         updatePerHostRuleInSW(host, rootNode, rootNode, null,
506                               new HostNodePair(host, rootNode));
507
508         //      log.debug("Getting out at the end!");
509         return switchesToProgram;
510     }
511
512     /**
513      * Calculate the per-Host rules to be installed in the rulesDB
514      * from a specific switch when a host facing port comes up.
515      * These rules will later on be installed in HW. This routine
516      * will implicitly calculate the shortest path from the switch
517      * where the port has come up to the switch where host is ,
518      * attached and will automatically create all the rules that allow
519      * a /32 destination IP based forwarding, as in traditional IP
520      * networks.
521      *
522      * @param host Host for which we are going to prepare the rules in the rulesDB
523      * @param swId Switch ID where the port has come up
524      *
525      * @return A set of switches touched by the calculation
526      */
527     private Set<Node> preparePerHostPerSwitchRules(HostNodeConnector host,
528             Node node, NodeConnector swport) {
529         if ((host == null) || (node == null)) {
530             return null;
531         }
532         if (this.routing == null) {
533             return null;
534         }
535         if (this.switchManager == null) {
536             return null;
537         }
538         if (this.rulesDB == null) {
539             return null;
540         }
541
542         Node rootNode = host.getnodeconnectorNode();
543         Set<Node> switchesToProgram = new HashSet<Node>();
544         HostNodePair key;
545         Map<NodeConnector, FlowEntry> pos;
546         FlowEntry po;
547         List<Edge> links;
548
549         Path res = this.routing.getRoute(node, rootNode);
550         if ((res == null) || ((links = res.getEdges()) == null)) {
551             // the routing service doesn't know how to get there from here
552             log.debug("NO Route/Path between SW[{}] --> SW[{}] cleaning " +
553                     "potentially existing entries", node, rootNode);
554             key = new HostNodePair(host, node);
555             pos = this.rulesDB.get(key);
556             if (pos != null) {
557                 for (Map.Entry<NodeConnector, FlowEntry> e : pos.entrySet()) {
558                     po = e.getValue();
559                     if (po != null) {
560                         //Uninstall the policy
561                         this.frm.uninstallFlowEntry(po);
562                     }
563                 }
564                 this.rulesDB.remove(key);
565             }
566             return null;
567         }
568
569         log.debug("Route between SW[{}] --> SW[{}]", node, rootNode);
570         Integer curr;
571         Node currNode = node;
572         key = new HostNodePair(host, currNode);
573         Edge link;
574         for (curr = 0; curr < links.size(); curr++) {
575             link = links.get(curr);
576             if (link == null) {
577                 log.error("Could not retrieve the Link");
578                 continue;
579             }
580
581             log.debug("Link [{}/{}] --> [{}/{}]", new Object[] {
582                     currNode, link.getHeadNodeConnector(),
583                     link.getHeadNodeConnector().getNode(),
584                     link.getTailNodeConnector()});
585
586             // Index all the switches to be programmed
587             switchesToProgram.add(currNode);
588             updatePerHostRuleInSW(host, currNode, rootNode, link, key);
589             break; // come out of the loop for port up case, interested only in programming one switch
590         }
591
592         // This rule will be added no matter if any topology is built
593         // or no, it serve as a way to handle the case of a node with
594         // multiple hosts attached to it but not yet connected to the
595         // rest of the world
596         // switchesToProgram.add(rootNode);
597         //updatePerHostRuleInSW(host, rootNode,
598         //                                        rootNode, null,
599         //                                        new HostNodePair(host, rootNode),ports);
600
601         //      log.debug("Getting out at the end!");
602         return switchesToProgram;
603     }
604
605     /**
606      * Routine that fetch the per-Host rules from the rulesDB and
607      * install in HW, the one having the same match rules will be
608      * overwritten silently.
609      *
610      * @param host host for which we want to install in HW the per-Host rules
611      * @param switchesToProgram list of switches to be programmed in
612      * HW, usually are them all, but better to be explicit, that list
613      * may change with time based on new switch addition/removal
614      *
615      * @return a return code that convey the programming status of the HW
616      */
617     private RulesProgrammingReturnCode installPerHostRules(
618             HostNodeConnector host, Set<Node> switchesToProgram) {
619         RulesProgrammingReturnCode retCode = RulesProgrammingReturnCode.SUCCESS;
620         if (host == null || switchesToProgram == null) {
621             return RulesProgrammingReturnCode.FAILED_WRONG_PARAMS;
622         }
623         Map<NodeConnector, FlowEntry> pos;
624         FlowEntry po;
625         // Now program every single switch
626         log.debug("Inside installPerHostRules");
627         for (Node swId : switchesToProgram) {
628             HostNodePair key = new HostNodePair(host, swId);
629             pos = this.rulesDB.get(key);
630             if (pos == null) {
631                 continue;
632             }
633             for (Map.Entry<NodeConnector, FlowEntry> e : pos.entrySet()) {
634                 po = e.getValue();
635                 if (po != null) {
636                     // Populate the Policy field now
637                     Status poStatus = this.frm.modifyOrAddFlowEntry(po);
638                     if (!poStatus.isSuccess()) {
639                         log.error("Failed to install policy: "
640                                 + po.getGroupName() + " ("
641                                 + poStatus.getDescription() + ")");
642
643                         retCode = RulesProgrammingReturnCode.FAILED_FEW_SWITCHES;
644                         // Remove the entry from the DB, it was not installed!
645                         this.rulesDB.remove(key);
646                     } else {
647                         log.debug("Successfully installed policy "
648                                 + po.toString() + " on switch " + swId);
649                     }
650                 } else {
651                     log.error("Cannot find a policy for SW:({}) Host: ({})",
652                               swId, host);
653                     /* // Now dump every single rule */
654                     /* for (HostNodePair dumpkey : this.rulesDB.keySet()) { */
655                     /*  po = this.rulesDB.get(dumpkey); */
656                     /*  log.debug("Dumping entry H{" + dumpkey.getHost() + "} S{" + dumpkey.getSwitchId() + "} = {" + (po == null ? "null policy" : po)); */
657                     /* } */
658                 }
659             }
660         }
661         log.debug("Leaving installPerHostRules");
662         return retCode;
663     }
664
665     /**
666      * Cleanup all the host rules for a given host
667      *
668      * @param host Host for which the host rules need to be cleaned
669      * up, the host could be null in that case it match all the hosts
670      *
671      * @return a return code that convey the programming status of the HW
672      */
673     private RulesProgrammingReturnCode uninstallPerHostRules(
674             HostNodeConnector host) {
675         RulesProgrammingReturnCode retCode = RulesProgrammingReturnCode.SUCCESS;
676         Map<NodeConnector, FlowEntry> pos;
677         FlowEntry po;
678         // Now program every single switch
679         for (HostNodePair key : this.rulesDB.keySet()) {
680             if (host == null || key.getHost().equals(host)) {
681                 pos = this.rulesDB.get(key);
682                 for (Map.Entry<NodeConnector, FlowEntry> e : pos.entrySet()) {
683                     po = e.getValue();
684                     if (po != null) {
685                         // Uninstall the policy
686                         this.frm.uninstallFlowEntry(po);
687                     }
688                 }
689                 this.rulesDB.remove(key);
690             }
691         }
692         return retCode;
693     }
694
695     /**
696      * Cleanup all the host rules for a given node, triggered when the
697      * switch disconnects, so there is no reason for Hw cleanup
698      * because it's disconnected anyhow
699      * TBD - Revisit above stmt in light of CSCus88743
700      * @param targetNode Node for which we want to do cleanup
701      *
702      */
703     private void uninstallPerNodeRules(Node targetNode) {
704         //RulesProgrammingReturnCode retCode = RulesProgrammingReturnCode.SUCCESS;
705         Map<NodeConnector, FlowEntry> pos;
706         FlowEntry po;
707
708         // Now program every single switch
709         for (HostNodePair key : this.rulesDB.keySet()) {
710             Node node = key.getNode();
711             if (targetNode == null || node.equals(targetNode)) {
712                 log.debug("Work on {} host {}", node, key.getHost());
713                 pos = this.rulesDB.get(key);
714                 for (Map.Entry<NodeConnector, FlowEntry> e : pos.entrySet()) {
715                     po = e.getValue();
716                     if (po != null) {
717                         // Uninstall the policy
718                         this.frm.uninstallFlowEntry(po);
719                     }
720                 }
721                 log.debug("Remove {}", key);
722                 this.rulesDB.remove(key);
723             }
724         }
725     }
726
727     /**
728      * Cleanup all the host rules currently present in the rulesDB
729      *
730      * @return a return code that convey the programming status of the HW
731      */
732     private RulesProgrammingReturnCode uninstallPerHostRules() {
733         return uninstallPerHostRules(null);
734     }
735
736     @Override
737     public void recalculateDone() {
738         if (this.hostTracker == null) {
739             //Not yet ready to process all the updates
740             //TODO: we should make sure that this call is executed eventually
741             return;
742         }
743         Set<HostNodeConnector> allHosts = this.hostTracker.getAllHosts();
744         for (HostNodeConnector host : allHosts) {
745             Set<Node> switches = preparePerHostRules(host);
746             if (switches != null) {
747                 // This will refresh existing rules, by overwriting
748                 // the previous ones
749                 installPerHostRules(host, switches);
750                 pruneExcessRules(switches);
751             }
752         }
753     }
754
755     void addTobePrunedPolicy(Node swId, FlowEntry po, FlowEntry new_po) {
756         List<FlowEntry> pl = tobePrunedPos.get(swId);
757         if (pl == null) {
758             pl = new LinkedList<FlowEntry>();
759             tobePrunedPos.put(swId, pl);
760         }
761         pl.add(po);
762         log.debug("Adding Pruned Policy for SwId: {}", swId);
763         log.debug("Old Policy: {}", po);
764         log.debug("New Policy: {}", new_po);
765     }
766
767     private void pruneExcessRules(Set<Node> switches) {
768         for (Node swId : switches) {
769             List<FlowEntry> pl = tobePrunedPos.get(swId);
770             if (pl != null) {
771                 log
772                         .debug(
773                                 "Policies for Switch: {} in the list to be deleted: {}",
774                                 swId, pl);
775                 Iterator<FlowEntry> plIter = pl.iterator();
776                 //for (Policy po: pl) {
777                 while (plIter.hasNext()) {
778                     FlowEntry po = plIter.next();
779                     log.error("Removing Policy, Switch: {} Policy: {}", swId,
780                             po);
781                     this.frm.uninstallFlowEntry(po);
782                     plIter.remove();
783                 }
784             }
785             // tobePrunedPos.remove(swId);
786         }
787     }
788
789     /**
790      * A Host facing port has come up in a container. Add rules on the switch where this
791      * port has come up for all the known hosts to the controller.
792      * @param swId switch id of the port where port came up
793      * @param swPort port which came up
794      */
795     private void updateRulesforHIFup(Node node, NodeConnector swPort) {
796         if (this.hostTracker == null) {
797             //Not yet ready to process all the updates
798             return;
799         }
800         log.debug("Host Facing Port in a container came up, install the rules for all hosts from this port !");
801         Set<HostNodeConnector> allHosts = this.hostTracker.getAllHosts();
802         for (HostNodeConnector host : allHosts) {
803             if (node.equals(host.getnodeconnectorNode())) {
804                 /*
805                  * This host resides behind the same switch and port for which a port up
806                  * message is received. Ideally this should not happen, but if it does,
807                  * don't program any rules for this host
808                  */
809                 continue;
810             }
811             Set<Node> switches = preparePerHostPerSwitchRules(host, node,
812                     swPort);
813             if (switches != null) {
814                 // This will refresh existing rules, by overwriting
815                 // the previous ones
816                 installPerHostRules(host, switches);
817             }
818         }
819
820     }
821
822     @Override
823     public void notifyHTClient(HostNodeConnector host) {
824         if (host == null) {
825             return;
826         }
827         Set<Node> switches = preparePerHostRules(host);
828         if (switches != null) {
829             installPerHostRules(host, switches);
830         }
831     }
832
833     @Override
834     public void notifyHTClientHostRemoved(HostNodeConnector host) {
835         if (host == null) {
836             return;
837         }
838         uninstallPerHostRules(host);
839     }
840
841     @Override
842     public void notifyNode(Node node, UpdateType type,
843             Map<String, Property> propMap) {
844         if (node == null) {
845             return;
846         }
847
848         switch (type) {
849         case REMOVED:
850             log.debug("Node {} gone, doing a cleanup", node);
851             uninstallPerNodeRules(node);
852             break;
853         default:
854             break;
855         }
856     }
857
858     @Override
859     public void notifyNodeConnector(NodeConnector nodeConnector,
860             UpdateType type, Map<String, Property> propMap) {
861         if (nodeConnector == null) {
862             return;
863         }
864
865         boolean up = false;
866         switch (type) {
867         case ADDED:
868             up = true;
869             break;
870         case REMOVED:
871             break;
872         case CHANGED:
873             State state = (State) propMap.get(State.StatePropName);
874             if ((state != null) && (state.getValue() == State.EDGE_UP)) {
875                 up = true;
876             }
877             break;
878         default:
879             return;
880         }
881
882         if (up) {
883             handleNodeConnectorStatusUp(nodeConnector);
884         } else {
885             handleNodeConnectorStatusDown(nodeConnector);
886         }
887     }
888
889     private void handleNodeConnectorStatusUp(NodeConnector nodeConnector) {
890         if (topologyManager == null) {
891             log.debug("topologyManager is not set yet");
892             return;
893         }
894
895         if (topologyManager.isInternal(nodeConnector)) {
896             log.debug("{} is not a host facing link", nodeConnector);
897             return;
898         }
899
900         log.debug("{} is up", nodeConnector);
901         updateRulesforHIFup(nodeConnector.getNode(), nodeConnector);
902     }
903
904     private void handleNodeConnectorStatusDown(NodeConnector nodeConnector) {
905         log.debug("{} is down", nodeConnector);
906     }
907
908     void setClusterContainerService(IClusterContainerServices s) {
909         log.debug("Cluster Service set");
910         this.clusterContainerService = s;
911     }
912
913     void unsetClusterContainerService(IClusterContainerServices s) {
914         if (this.clusterContainerService == s) {
915             log.debug("Cluster Service removed!");
916             this.clusterContainerService = null;
917         }
918     }
919
920     /**
921      * Function called by the dependency manager when all the required
922      * dependencies are satisfied
923      *
924      */
925     void init() {
926         startUp();
927     }
928
929     /**
930      * Function called by the dependency manager when at least one
931      * dependency become unsatisfied or when the component is shutting
932      * down because for example bundle is being stopped.
933      *
934      */
935     void destroy() {
936     }
937
938     /**
939      * Function called by dependency manager after "init ()" is called
940      * and after the services provided by the class are registered in
941      * the service registry
942      *
943      */
944     void start() {
945     }
946
947     /**
948      * Function called by the dependency manager before the services
949      * exported by the component are unregistered, this will be
950      * followed by a "destroy ()" calls
951      *
952      */
953     void stop() {
954     }
955
956     public void setSwitchManager(ISwitchManager switchManager) {
957         this.switchManager = switchManager;
958     }
959
960     public void unsetSwitchManager(ISwitchManager switchManager) {
961         if (this.switchManager == switchManager) {
962             this.switchManager = null;
963         }
964     }
965 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.