Revert "Checkstyle enforcer"
[controller.git] / opendaylight / protocol_plugins / openflow / src / main / java / org / opendaylight / controller / protocol_plugin / openflow / internal / ReadServiceFilter.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.protocol_plugin.openflow.internal;
11
12 import java.util.ArrayList;
13 import java.util.HashMap;
14 import java.util.HashSet;
15 import java.util.List;
16 import java.util.Map;
17 import java.util.Set;
18
19 import org.opendaylight.controller.protocol_plugin.openflow.IOFStatisticsManager;
20 import org.opendaylight.controller.protocol_plugin.openflow.IPluginReadServiceFilter;
21 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
22 import org.openflow.protocol.OFMatch;
23 import org.openflow.protocol.statistics.OFPortStatisticsReply;
24 import org.openflow.protocol.statistics.OFStatistics;
25 import org.openflow.protocol.statistics.OFStatisticsType;
26 import org.slf4j.Logger;
27 import org.slf4j.LoggerFactory;
28
29 import org.opendaylight.controller.sal.action.Action;
30 import org.opendaylight.controller.sal.action.ActionType;
31 import org.opendaylight.controller.sal.action.Output;
32 import org.opendaylight.controller.sal.core.ContainerFlow;
33 import org.opendaylight.controller.sal.core.IContainerListener;
34 import org.opendaylight.controller.sal.core.Node;
35 import org.opendaylight.controller.sal.core.NodeConnector;
36 import org.opendaylight.controller.sal.core.NodeTable;
37 import org.opendaylight.controller.sal.core.UpdateType;
38 import org.opendaylight.controller.sal.flowprogrammer.Flow;
39 import org.opendaylight.controller.sal.match.Match;
40 import org.opendaylight.controller.sal.match.MatchType;
41 import org.opendaylight.controller.sal.reader.FlowOnNode;
42 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics;
43 import org.opendaylight.controller.sal.reader.NodeDescription;
44 import org.opendaylight.controller.sal.reader.NodeTableStatistics;
45 import org.opendaylight.controller.sal.utils.GlobalConstants;
46 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
47 import org.opendaylight.controller.sal.utils.NodeCreator;
48 import org.opendaylight.controller.sal.utils.NodeTableCreator;
49 import org.openflow.protocol.statistics.OFTableStatistics;
50 /**
51  * Read Service shim layer which is in charge of filtering the flow statistics
52  * based on container. It is a Global instance.
53  *
54  *
55  *
56  */
57 public class ReadServiceFilter implements IPluginReadServiceFilter,
58         IContainerListener {
59     private static final Logger logger = LoggerFactory
60             .getLogger(ReadServiceFilter.class);
61     private IController controller = null;
62     private IOFStatisticsManager statsMgr = null;
63     private Map<String, Set<NodeConnector>> containerToNc;
64     private Map<String, Set<NodeTable>> containerToNt;
65
66     public void setController(IController core) {
67         this.controller = core;
68     }
69
70     public void unsetController(IController core) {
71         if (this.controller == core) {
72             this.controller = null;
73         }
74     }
75
76     /**
77      * Function called by the dependency manager when all the required
78      * dependencies are satisfied
79      *
80      */
81     void init() {
82         containerToNc = new HashMap<String, Set<NodeConnector>>();
83         containerToNt = new HashMap<String, Set<NodeTable>>();
84     }
85
86     /**
87      * Function called by the dependency manager when at least one
88      * dependency become unsatisfied or when the component is shutting
89      * down because for example bundle is being stopped.
90      *
91      */
92     void destroy() {
93     }
94
95     /**
96      * Function called by dependency manager after "init ()" is called
97      * and after the services provided by the class are registered in
98      * the service registry
99      *
100      */
101     void start() {
102     }
103
104     /**
105      * Function called by the dependency manager before the services
106      * exported by the component are unregistered, this will be
107      * followed by a "destroy ()" calls
108      *
109      */
110     void stop() {
111     }
112
113     public void setService(IOFStatisticsManager service) {
114         this.statsMgr = service;
115     }
116
117     public void unsetService(IOFStatisticsManager service) {
118         this.statsMgr = null;
119     }
120
121     @Override
122     public FlowOnNode readFlow(String container, Node node, Flow flow,
123             boolean cached) {
124
125         if (controller == null) {
126             // Avoid to provide cached statistics if controller went down.
127             // They are not valid anymore anyway
128             logger.error("Internal plugin error");
129             return null;
130         }
131
132         long sid = (Long) node.getID();
133         OFMatch ofMatch = new FlowConverter(flow).getOFMatch();
134         List<OFStatistics> ofList = (cached == true) ? statsMgr
135                 .getOFFlowStatistics(sid, ofMatch) : statsMgr.queryStatistics(
136                 sid, OFStatisticsType.FLOW, ofMatch);
137
138         /*
139          * Convert and filter the statistics per container
140          */
141         List<FlowOnNode> flowOnNodeList = new FlowStatisticsConverter(ofList)
142                 .getFlowOnNodeList(node);
143         List<FlowOnNode> filteredList = filterFlowListPerContainer(container,
144                 node, flowOnNodeList);
145
146         return (filteredList == null || filteredList.isEmpty()) ? null
147                 : filteredList.get(0);
148     }
149
150     @Override
151     public List<FlowOnNode> readAllFlow(String container, Node node,
152             boolean cached) {
153
154         long sid = (Long) node.getID();
155         List<OFStatistics> ofList = (cached == true) ? statsMgr
156                 .getOFFlowStatistics(sid) : statsMgr.queryStatistics(sid,
157                 OFStatisticsType.FLOW, null);
158
159         /*
160          * Convert and filter the statistics per container
161          */
162         List<FlowOnNode> flowOnNodeList = new FlowStatisticsConverter(ofList)
163                 .getFlowOnNodeList(node);
164         List<FlowOnNode> filteredList = filterFlowListPerContainer(container,
165                 node, flowOnNodeList);
166
167         return (filteredList == null) ? null : filteredList;
168
169     }
170
171     @Override
172     public NodeDescription readDescription(Node node, boolean cached) {
173
174         if (controller == null) {
175             logger.error("Internal plugin error");
176             return null;
177         }
178
179         long sid = (Long) node.getID();
180         List<OFStatistics> ofList = (cached == true) ? statsMgr
181                 .getOFDescStatistics(sid) : statsMgr.queryStatistics(sid,
182                         OFStatisticsType.DESC, null);
183
184                 return new DescStatisticsConverter(ofList).getHwDescription();
185     }
186
187     /**
188      * Filters a list of FlowOnNode elements based on the container
189      *
190      * @param container
191      * @param nodeId
192      * @param list
193      * @return
194      */
195     public List<FlowOnNode> filterFlowListPerContainer(String container,
196             Node nodeId, List<FlowOnNode> list) {
197         if (list == null) {
198             return null;
199         }
200
201         // Create new filtered list of flows
202         List<FlowOnNode> newList = new ArrayList<FlowOnNode>();
203
204         for (FlowOnNode target : list) {
205             // Check whether the described flow (match + actions) belongs to this container
206             if (flowBelongToContainer(container, nodeId, target.getFlow())) {
207                 newList.add(target);
208             }
209         }
210
211         return newList;
212     }
213
214     /**
215      * Filters a list of FlowOnNode elements based on the container
216      *
217      * @param container
218      * @param nodeId
219      * @param list
220      * @return
221      */
222     public List<OFStatistics> filterPortListPerContainer(String container,
223             long switchId, List<OFStatistics> list) {
224         if (list == null) {
225             return null;
226         }
227
228         // Create new filtered list of flows
229         List<OFStatistics> newList = new ArrayList<OFStatistics>();
230
231         for (OFStatistics stat : list) {
232             OFPortStatisticsReply target = (OFPortStatisticsReply) stat;
233             NodeConnector nc = NodeConnectorCreator.createOFNodeConnector(
234                     target.getPortNumber(), NodeCreator.createOFNode(switchId));
235             if (containerOwnsNodeConnector(container, nc)) {
236                 newList.add(target);
237             }
238         }
239
240         return newList;
241     }
242
243
244     public List<OFStatistics> filterTableListPerContainer(
245             String container, long switchId, List<OFStatistics> list) {
246         if (list == null) {
247             return null;
248         }
249
250         // Create new filtered list of node tables
251         List<OFStatistics> newList = new ArrayList<OFStatistics>();
252
253         for (OFStatistics stat : list) {
254             OFTableStatistics target = (OFTableStatistics) stat;
255             NodeTable nt = NodeTableCreator.createOFNodeTable(
256                     target.getTableId(), NodeCreator.createOFNode(switchId));
257             if (containerOwnsNodeTable(container, nt)) {
258                 newList.add(target);
259             }
260         }
261
262         return newList;
263     }
264
265     /**
266      * Returns whether the specified flow (flow match + actions)
267      * belongs to the container
268      *
269      * @param container
270      * @param node
271      * @param flow
272      * @return true if it belongs
273      */
274     public boolean flowBelongToContainer(String container, Node node, Flow flow) {
275         // All flows belong to the default container
276         if (container.equals(GlobalConstants.DEFAULT.toString())) {
277             return true;
278         }
279         return (flowPortsBelongToContainer(container, node, flow)
280                 && flowVlanBelongsToContainer(container, node, flow) && flowSpecAllowsFlow(
281                         container, flow.getMatch()));
282     }
283
284     /**
285      * Returns whether the passed NodeConnector belongs to the container
286      *
287      * @param container container name
288      * @param p         node connector to test
289      * @return          true if belongs false otherwise
290      */
291     public boolean containerOwnsNodeConnector(String container, NodeConnector p) {
292         // All node connectors belong to the default container
293         if (container.equals(GlobalConstants.DEFAULT.toString())) {
294             return true;
295         }
296         Set<NodeConnector> portSet = containerToNc.get(container);
297         return (portSet == null) ? false : portSet.contains(p);
298     }
299
300     /**
301      * Returns whether the passed NodeConnector belongs to the container
302      *
303      * @param container container name
304      * @param table             node table to test
305      * @return          true if belongs false otherwise
306      */
307     public boolean containerOwnsNodeTable(String container, NodeTable table) {
308         // All node table belong to the default container
309         if (container.equals(GlobalConstants.DEFAULT.toString())) {
310             return true;
311         }
312         Set<NodeTable> tableSet = containerToNt.get(container);
313         return (tableSet == null) ? false : tableSet.contains(table);
314     }
315
316     /**
317      * Returns whether the container flowspec allows the passed flow
318      *
319      * @param container
320      * @param match
321      * @return
322      */
323     private boolean flowSpecAllowsFlow(String container, Match match) {
324         return true; // Always true for now
325     }
326
327     /**
328      * Check whether the vlan field in the flow match is the same
329      * of the static vlan configured for the container
330      *
331      * @param container
332      * @param node
333      * @param flow
334      * @return
335      */
336     private boolean flowVlanBelongsToContainer(String container, Node node,
337             Flow flow) {
338         return true; // Always true for now
339     }
340
341     /**
342      * Check whether the ports in the flow match and flow actions for
343      * the specified node belong to the container
344      *
345      * @param container
346      * @param node
347      * @param flow
348      * @return
349      */
350     private boolean flowPortsBelongToContainer(String container, Node node,
351             Flow flow) {
352         Match m = flow.getMatch();
353         if (m.isPresent(MatchType.IN_PORT)) {
354             NodeConnector inPort = (NodeConnector) m
355                     .getField(MatchType.IN_PORT).getValue();
356
357             // If the incoming port is specified, check if it belongs to
358             if (!containerOwnsNodeConnector(container, inPort)) {
359                 return false;
360             }
361         }
362
363         // If an outgoing port is specified, it must belong to this container
364         for (Action action : flow.getActions()) {
365             if (action.getType() == ActionType.OUTPUT) {
366                 NodeConnector outPort = (NodeConnector) ((Output) action)
367                         .getPort();
368                 if (!containerOwnsNodeConnector(container, outPort)) {
369                     return false;
370                 }
371             }
372         }
373         return true;
374     }
375
376     @Override
377     public void containerFlowUpdated(String containerName,
378             ContainerFlow previousFlow, ContainerFlow currentFlow, UpdateType t) {
379
380     }
381
382     @Override
383     public void nodeConnectorUpdated(String containerName, NodeConnector p,
384             UpdateType type) {
385         Set<NodeConnector> target = null;
386
387         switch (type) {
388         case ADDED:
389             if (!containerToNc.containsKey(containerName)) {
390                 containerToNc.put(containerName, new HashSet<NodeConnector>());
391             }
392             containerToNc.get(containerName).add(p);
393             break;
394         case CHANGED:
395             break;
396         case REMOVED:
397             target = containerToNc.get(containerName);
398             if (target != null) {
399                 target.remove(p);
400             }
401             break;
402         default:
403         }
404     }
405
406     @Override
407     public void tagUpdated(String containerName, Node n, short oldTag,
408             short newTag, UpdateType t) {
409         // Not interested in this event
410     }
411
412     @Override
413     public void containerModeUpdated(UpdateType t) {
414         // do nothing
415     }
416
417     @Override
418     public NodeConnectorStatistics readNodeConnector(String containerName,
419             NodeConnector connector, boolean cached) {
420         if (!containerOwnsNodeConnector(containerName, connector)) {
421             return null;
422         }
423         Node node = connector.getNode();
424         long sid = (Long) node.getID();
425         short portId = (Short) connector.getID();
426         List<OFStatistics> ofList = (cached == true) ? statsMgr
427                 .getOFPortStatistics(sid, portId) : statsMgr.queryStatistics(
428                         sid, OFStatisticsType.PORT, portId);
429
430                 List<NodeConnectorStatistics> ncStatistics = new PortStatisticsConverter(
431                         sid, ofList).getNodeConnectorStatsList();
432                 return (ncStatistics.isEmpty()) ? new NodeConnectorStatistics()
433                 : ncStatistics.get(0);
434     }
435
436     @Override
437     public List<NodeConnectorStatistics> readAllNodeConnector(
438             String containerName, Node node, boolean cached) {
439
440         long sid = (Long) node.getID();
441         List<OFStatistics> ofList = (cached == true) ? statsMgr
442                 .getOFPortStatistics(sid) : statsMgr.queryStatistics(sid,
443                         OFStatisticsType.FLOW, null);
444
445                 List<OFStatistics> filteredList = filterPortListPerContainer(
446                         containerName, sid, ofList);
447
448                 return new PortStatisticsConverter(sid, filteredList)
449                 .getNodeConnectorStatsList();
450     }
451
452     @Override
453     public long getTransmitRate(String containerName, NodeConnector connector) {
454         if (!containerOwnsNodeConnector(containerName, connector)) {
455             return 0;
456         }
457
458         long switchId = (Long) connector.getNode().getID();
459         short port = (Short) connector.getID();
460
461         return statsMgr.getTransmitRate(switchId, port);
462     }
463
464     @Override
465     public NodeTableStatistics readNodeTable(String containerName,
466             NodeTable table, boolean cached) {
467         if (!containerOwnsNodeTable(containerName, table)) {
468             return null;
469         }
470         Node node = table.getNode();
471         long sid = (Long) node.getID();
472         Byte tableId = (Byte) table.getID();
473         List<OFStatistics> ofList = (cached == true) ? statsMgr
474                 .getOFTableStatistics(sid, tableId) : statsMgr.queryStatistics(
475                         sid, OFStatisticsType.TABLE, tableId);
476
477                 List<NodeTableStatistics> ntStatistics = new TableStatisticsConverter(
478                         sid, ofList).getNodeTableStatsList();
479
480                 return (ntStatistics.isEmpty()) ? new NodeTableStatistics()
481                 : ntStatistics.get(0);
482     }
483
484     @Override
485     public List<NodeTableStatistics> readAllNodeTable(String containerName,
486             Node node, boolean cached) {
487         long sid = (Long) node.getID();
488         List<OFStatistics> ofList = (cached == true) ? statsMgr
489                 .getOFTableStatistics(sid) : statsMgr.queryStatistics(sid,
490                         OFStatisticsType.FLOW, null);
491
492                 List<OFStatistics> filteredList = filterTableListPerContainer(
493                         containerName, sid, ofList);
494
495                 return new TableStatisticsConverter(sid, filteredList)
496                 .getNodeTableStatsList();
497     }
498
499 }

©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.