opendaylight/statisticsmanager/implementation/src/main/java/org/opendaylight/controller/statisticsmanager/internal/StatisticsManager.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.statisticsmanager.internal;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16
  17 import org.opendaylight.controller.forwardingrulesmanager.FlowEntry;
  18 import org.opendaylight.controller.sal.core.Node;
  19 import org.opendaylight.controller.sal.core.NodeConnector;
  20 import org.opendaylight.controller.sal.core.NodeTable;
  21 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  22 import org.opendaylight.controller.sal.reader.FlowOnNode;
  23 import org.opendaylight.controller.sal.reader.IReadService;
  24 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics;
  25 import org.opendaylight.controller.sal.reader.NodeDescription;
  26 import org.opendaylight.controller.sal.reader.NodeTableStatistics;
  27 import org.opendaylight.controller.statisticsmanager.IStatisticsManager;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 /**
  32  * The class which implements the methods for retrieving
  33  * the network nodes statistics.
  34  */
  35 public class StatisticsManager implements IStatisticsManager {
  36     private static final Logger log = LoggerFactory
  37             .getLogger(StatisticsManager.class);
  38     private IReadService reader;
  39
  40     public StatisticsManager() {
  41
  42     }
  43
  44     /**
  45      * Function called by the dependency manager when all the required
  46      * dependencies are satisfied
  47      *
  48      */
  49     void init() {
  50         log.debug("INIT called!");
  51     }
  52
  53     /**
  54      * Function called by the dependency manager when at least one
  55      * dependency become unsatisfied or when the component is shutting
  56      * down because for example bundle is being stopped.
  57      *
  58      */
  59     void destroy() {
  60         log.debug("DESTROY called!");
  61     }
  62
  63     /**
  64      * Function called by dependency manager after "init ()" is called
  65      * and after the services provided by the class are registered in
  66      * the service registry
  67      *
  68      */
  69     void start() {
  70         log.debug("START called!");
  71     }
  72
  73     /**
  74      * Function called by the dependency manager before the services
  75      * exported by the component are unregistered, this will be
  76      * followed by a "destroy ()" calls
  77      *
  78      */
  79     void stop() {
  80         log.debug("STOP called!");
  81     }
  82
  83     public void setReaderService(IReadService service) {
  84         log.debug("Got inventory service set request {}", service);
  85         this.reader = service;
  86     }
  87
  88     public void unsetReaderService(IReadService service) {
  89         log.debug("Got a service UNset request");
  90         this.reader = null;
  91     }
  92
  93     @Override
  94     public List<FlowOnNode> getFlows(Node node) {
  95         return reader.readAllFlows(node);
  96     }
  97
  98     @Override
  99     public Map<Node, List<FlowOnNode>> getFlowStatisticsForFlowList(
 100             List<FlowEntry> flowList) {
 101         Map<Node, List<FlowOnNode>> map = new HashMap<Node, List<FlowOnNode>>();
 102         if (flowList != null) {
 103             for (FlowEntry entry : flowList) {
 104                 Node node = entry.getNode();
 105                 Flow flow = entry.getFlow();
 106                 List<FlowOnNode> list = (map.containsKey(node)) ? map.get(node)
 107                         : new ArrayList<FlowOnNode>();
 108                 list.add(reader.readFlow(node, flow));
 109                 map.put(node, list);
 110             }
 111         }
 112         return map;
 113     }
 114
 115     @Override
 116     public int getFlowsNumber(Node node) {
 117         return reader.readAllFlows(node).size();
 118     }
 119
 120     @Override
 121     public NodeDescription getNodeDescription(Node node) {
 122         return reader.readDescription(node);
 123     }
 124
 125     @Override
 126     public NodeConnectorStatistics getNodeConnectorStatistics(
 127             NodeConnector nodeConnector) {
 128         return reader.readNodeConnector(nodeConnector);
 129     }
 130
 131     @Override
 132     public List<NodeConnectorStatistics> getNodeConnectorStatistics(Node node) {
 133         return reader.readNodeConnectors(node);
 134     }
 135
 136     @Override
 137     public NodeTableStatistics getNodeTableStatistics(NodeTable nodeTable) {
 138         return reader.readNodeTable(nodeTable);
 139     }
 140
 141     @Override
 142     public List<NodeTableStatistics> getNodeTableStatistics(Node node){
 143         return reader.readNodeTable(node);
 144     }
 145 }