OpenFlowRuleProvider is now configurable with respect to flowPollFrequency.

Change-Id: I3a559a9cd65df1ae56d80017696452788fc08d91

OpenFlowRuleProvider is now configurable with respect to flowPollFrequency.
Change-Id: I3a559a9cd65df1ae56d80017696452788fc08d91
Thomas Vachuska · Gerrit Code Review
Commit 75aaa675fbb210d96485003b747f5d8d3732e77f 75aaa675 1 parent 11ff870f
Showing 5 changed files with 165 additions and 102 deletions
core/api/src/main/java/org/onosproject/net/flow/FlowRuleProvider.java
core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
providers/openflow/flow/pom.xml
providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/FlowStatsCollector.java
providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/OpenFlowRuleProvider.java
--- a/core/api/src/main/java/org/onosproject/net/flow/FlowRuleProvider.java
View file @75aaa67
+++ b/core/api/src/main/java/org/onosproject/net/flow/FlowRuleProvider.java
View file @75aaa67
@@ -23,8 +23,6 @@ import org.onosproject.net.provider.Provider;
  */
 public interface FlowRuleProvider extends Provider {
-    static final int POLL_INTERVAL = 10;
-
     /**
      * Instructs the provider to apply the specified flow rules to their
      * respective devices.
--- a/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
View file @75aaa67
+++ b/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
View file @75aaa67
@@ -16,7 +16,6 @@
 package org.onosproject.net.statistic;
 import com.google.common.base.MoreObjects;
-import org.onosproject.net.flow.FlowRuleProvider;
 /**
  * Implementation of a load.
@@ -29,6 +28,11 @@ public class DefaultLoad implements Load {
     private final long time;
     /**
+     * Indicates the flow statistics poll interval in seconds.
+     */
+    private static int pollInterval = 10;
+
+     /**
      * Creates an invalid load.
      */
     public DefaultLoad() {
@@ -50,9 +54,19 @@ public class DefaultLoad implements Load {
         this.isValid = true;
     }
+    /**
+     * Sets the poll interval in seconds. Used solely for the purpose of
+     * computing the load.
+     *
+     * @param newPollInterval poll interval duration in seconds
+     */
+    public static void setPollInterval(int newPollInterval) {
+        pollInterval = newPollInterval;
+    }
+
     @Override
     public long rate() {
-        return (current - previous) / FlowRuleProvider.POLL_INTERVAL;
+        return (current - previous) / pollInterval;
     }
     @Override
--- a/providers/openflow/flow/pom.xml
View file @75aaa67
+++ b/providers/openflow/flow/pom.xml
View file @75aaa67
@@ -31,4 +31,10 @@
     <description>ONOS OpenFlow protocol flow provider</description>
+    <dependencies>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+        </dependency>
+    </dependencies>
 </project>
--- a/providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/FlowStatsCollector.java
View file @75aaa67
+++ b/providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/FlowStatsCollector.java
View file @75aaa67
@@ -15,87 +15,86 @@
  */
 package org.onosproject.provider.of.flow.impl;
-import static org.slf4j.LoggerFactory.getLogger;
+import org.onlab.util.SharedExecutors;
-
-import java.util.concurrent.TimeUnit;
-
-import org.jboss.netty.util.HashedWheelTimer;
-import org.jboss.netty.util.Timeout;
-import org.jboss.netty.util.TimerTask;
 import org.onosproject.openflow.controller.OpenFlowSwitch;
 import org.onosproject.openflow.controller.RoleState;
-import org.onlab.util.Timer;
 import org.projectfloodlight.openflow.protocol.OFFlowStatsRequest;
 import org.projectfloodlight.openflow.types.OFPort;
 import org.projectfloodlight.openflow.types.TableId;
 import org.slf4j.Logger;
-public class FlowStatsCollector implements TimerTask {
+import java.util.Timer;
+import java.util.TimerTask;
-    private final Logger log = getLogger(getClass());
+import static org.slf4j.LoggerFactory.getLogger;
-
-    private final HashedWheelTimer timer = Timer.getTimer();
-    private final OpenFlowSwitch sw;
-    private final int refreshInterval;
-    private Timeout timeout;
+/**
+ * Collects flow statistics for the specified switch.
+ */
+class FlowStatsCollector {
-    private boolean stopTimer = false;;
+    private final Logger log = getLogger(getClass());
-    public FlowStatsCollector(OpenFlowSwitch sw, int refreshInterval) {
+    public static final int SECONDS = 1000;
-        this.sw = sw;
-        this.refreshInterval = refreshInterval;
-    }
-    @Override
+    private final OpenFlowSwitch sw;
-    public void run(Timeout timeout) throws Exception {
+    private Timer timer;
-        log.trace("Collecting stats for {}", this.sw.getStringId());
+    private TimerTask task;
-        sendFlowStatistics();
+    private int pollInterval;
-        if (!this.stopTimer) {
+    /**
-            log.trace("Scheduling stats collection in {} seconds for {}",
+     * Creates a new collector for the given switch and poll frequency.
-                    this.refreshInterval, this.sw.getStringId());
+     *
-            timeout.getTimer().newTimeout(this, refreshInterval,
+     * @param timer        timer to use for scheduling
-                    TimeUnit.SECONDS);
+     * @param sw           switch to pull
+     * @param pollInterval poll frequency in seconds
+     */
+    FlowStatsCollector(Timer timer, OpenFlowSwitch sw, int pollInterval) {
+        this.timer = timer;
+        this.sw = sw;
+        this.pollInterval = pollInterval;
     }
-
+    /**
+     * Adjusts poll frequency.
+     *
+     * @param pollInterval poll frequency in seconds
+     */
+    synchronized void adjustPollInterval(int pollInterval) {
+        this.pollInterval = pollInterval;
+        task.cancel();
+        task = new InternalTimerTask();
+        timer.scheduleAtFixedRate(task, pollInterval * SECONDS, pollInterval * 1000);
     }
-    private void sendFlowStatistics() {
+    private class InternalTimerTask extends TimerTask {
-        if (log.isTraceEnabled()) {
+        @Override
-            log.trace("sendFlowStatistics {}:{}", sw.getStringId(), sw.getRole());
+        public void run() {
-        }
+            if (sw.getRole() == RoleState.MASTER) {
-        if (sw.getRole() != RoleState.MASTER) {
+                log.trace("Collecting stats for {}", sw.getStringId());
-            // Switch not master.
-            return;
-        }
                 OFFlowStatsRequest request = sw.factory().buildFlowStatsRequest()
                         .setMatch(sw.factory().matchWildcardAll())
                         .setTableId(TableId.ALL)
                         .setOutPort(OFPort.NO_MASK)
                         .build();
-
+                sw.sendMsg(request);
-        this.sw.sendMsg(request);
+            }
-
+        }
     }
-    public void start() {
+    public synchronized void start() {
-
+        // Initially start polling quickly. Then drop down to configured value
-        /*
+        log.debug("Starting Stats collection thread for {}", sw.getStringId());
-         * Initially start polling quickly. Then drop down to configured value
+        task = new InternalTimerTask();
-         */
+        SharedExecutors.getTimer().scheduleAtFixedRate(task, 1 * SECONDS,
-        log.info("Starting Stats collection thread for {}",
+                                                       pollInterval * SECONDS);
-                this.sw.getStringId());
-        timeout = timer.newTimeout(this, 1, TimeUnit.SECONDS);
     }
-    public void stop() {
+    public synchronized void stop() {
-        log.info("Stopping Stats collection thread for {}",
+        log.debug("Stopping Stats collection thread for {}", sw.getStringId());
-                this.sw.getStringId());
+        task.cancel();
-        this.stopTimer = true;
+        task = null;
-        timeout.cancel();
     }
 }
--- a/providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/OpenFlowRuleProvider.java
View file @75aaa67
+++ b/providers/openflow/flow/src/main/java/org/onosproject/provider/of/flow/impl/OpenFlowRuleProvider.java
View file @75aaa67
@@ -15,21 +15,20 @@
  */
 package org.onosproject.provider.of.flow.impl;
-import static org.slf4j.LoggerFactory.getLogger;
+import com.google.common.cache.Cache;
-
+import com.google.common.cache.CacheBuilder;
-import java.util.Collections;
+import com.google.common.cache.RemovalCause;
-import java.util.List;
+import com.google.common.cache.RemovalNotification;
-import java.util.Map;
+import com.google.common.collect.Maps;
-import java.util.Optional;
+import com.google.common.collect.Sets;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Modified;
+import org.apache.felix.scr.annotations.Property;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.onosproject.cfg.ComponentConfigService;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.flow.CompletedBatchOperation;
@@ -43,6 +42,7 @@ import org.onosproject.net.flow.FlowRuleProviderRegistry;
 import org.onosproject.net.flow.FlowRuleProviderService;
 import org.onosproject.net.provider.AbstractProvider;
 import org.onosproject.net.provider.ProviderId;
+import org.onosproject.net.statistic.DefaultLoad;
 import org.onosproject.openflow.controller.Dpid;
 import org.onosproject.openflow.controller.OpenFlowController;
 import org.onosproject.openflow.controller.OpenFlowEventListener;
@@ -50,6 +50,7 @@ import org.onosproject.openflow.controller.OpenFlowSwitch;
 import org.onosproject.openflow.controller.OpenFlowSwitchListener;
 import org.onosproject.openflow.controller.RoleState;
 import org.onosproject.openflow.controller.ThirdPartyMessage;
+import org.osgi.service.component.ComponentContext;
 import org.projectfloodlight.openflow.protocol.OFBarrierRequest;
 import org.projectfloodlight.openflow.protocol.OFErrorMsg;
 import org.projectfloodlight.openflow.protocol.OFErrorType;
@@ -63,12 +64,19 @@ import org.projectfloodlight.openflow.protocol.OFStatsType;
 import org.projectfloodlight.openflow.protocol.errormsg.OFFlowModFailedErrorMsg;
 import org.slf4j.Logger;
-import com.google.common.cache.Cache;
+import java.util.Collections;
-import com.google.common.cache.CacheBuilder;
+import java.util.Dictionary;
-import com.google.common.cache.RemovalCause;
+import java.util.List;
-import com.google.common.cache.RemovalNotification;
+import java.util.Map;
-import com.google.common.collect.Maps;
+import java.util.Optional;
-import com.google.common.collect.Sets;
+import java.util.Set;
+import java.util.Timer;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Strings.isNullOrEmpty;
+import static org.onlab.util.Tools.get;
+import static org.slf4j.LoggerFactory.getLogger;
 /**
  * Provider which uses an OpenFlow controller to detect network end-station
@@ -86,12 +94,21 @@ public class OpenFlowRuleProvider extends AbstractProvider
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected OpenFlowController controller;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected ComponentConfigService cfgService;
+
+    private static final int DEFAULT_POLL_FREQUENCY = 10;
+    @Property(name = "flowPollFrequency", intValue = DEFAULT_POLL_FREQUENCY,
+            label = "Frequency (in seconds) for polling flow statistics")
+    private int flowPollFrequency = DEFAULT_POLL_FREQUENCY;
+
     private FlowRuleProviderService providerService;
     private final InternalFlowProvider listener = new InternalFlowProvider();
     private Cache<Long, InternalCacheEntry> pendingBatches;
+    private final Timer timer = new Timer("onos-openflow-collector");
     private final Map<Dpid, FlowStatsCollector> collectors = Maps.newHashMap();
     /**
@@ -102,40 +119,77 @@ public class OpenFlowRuleProvider extends AbstractProvider
     }
     @Activate
-    public void activate() {
+    public void activate(ComponentContext context) {
+        cfgService.registerProperties(getClass());
         providerService = providerRegistry.register(this);
         controller.addListener(listener);
         controller.addEventListener(listener);
-        pendingBatches = CacheBuilder
+        pendingBatches = createBatchCache();
-                .newBuilder()
+        createCollectors();
+
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate(ComponentContext context) {
+        cfgService.unregisterProperties(getClass(), false);
+        stopCollectors();
+        providerRegistry.unregister(this);
+        providerService = null;
+
+        log.info("Stopped");
+    }
+
+    @Modified
+    public void modified(ComponentContext context) {
+        Dictionary<?, ?> properties = context.getProperties();
+        int newFlowPollFrequency;
+        try {
+            String s = get(properties, "flowPollFrequency");
+            newFlowPollFrequency = isNullOrEmpty(s) ? flowPollFrequency : Integer.parseInt(s.trim());
+
+        } catch (NumberFormatException | ClassCastException e) {
+            newFlowPollFrequency = flowPollFrequency;
+        }
+
+        if (newFlowPollFrequency != flowPollFrequency) {
+            flowPollFrequency = newFlowPollFrequency;
+            adjustRate();
+        }
+
+        log.info("Settings: flowPollFrequency={}", flowPollFrequency);
+    }
+
+    private Cache<Long, InternalCacheEntry> createBatchCache() {
+        return CacheBuilder.newBuilder()
                 .expireAfterWrite(10, TimeUnit.SECONDS)
                 .removalListener((RemovalNotification<Long, InternalCacheEntry> notification) -> {
                     if (notification.getCause() == RemovalCause.EXPIRED) {
-                                         providerService
+                        providerService.batchOperationCompleted(notification.getKey(),
-                                                 .batchOperationCompleted(notification
+                                                                notification.getValue().failedCompletion());
-                                                                                  .getKey(),
-                                                                          notification
-                                                                                  .getValue()
-                                                                                  .failedCompletion());
                     }
                 }).build();
+    }
-        for (OpenFlowSwitch sw : controller.getSwitches()) {
+    private void createCollectors() {
-            FlowStatsCollector fsc = new FlowStatsCollector(sw, POLL_INTERVAL);
+        controller.getSwitches().forEach(this::createCollector);
+    }
+
+    private void createCollector(OpenFlowSwitch sw) {
+        FlowStatsCollector fsc = new FlowStatsCollector(timer, sw, flowPollFrequency);
         fsc.start();
         collectors.put(new Dpid(sw.getId()), fsc);
     }
-        log.info("Started");
+    private void stopCollectors() {
+        collectors.values().forEach(FlowStatsCollector::stop);
+        collectors.clear();
     }
-    @Deactivate
+    private void adjustRate() {
-    public void deactivate() {
+        DefaultLoad.setPollInterval(flowPollFrequency);
-        providerRegistry.unregister(this);
+        collectors.values().forEach(fsc -> fsc.adjustPollInterval(flowPollFrequency));
-        providerService = null;
-
-        log.info("Stopped");
     }
     @Override
@@ -236,12 +290,7 @@ public class OpenFlowRuleProvider extends AbstractProvider
         @Override
         public void switchAdded(Dpid dpid) {
-            FlowStatsCollector fsc = new FlowStatsCollector(
+            createCollector(controller.getSwitch(dpid));
-                                                            controller
-                                                                    .getSwitch(dpid),
-                                                            POLL_INTERVAL);
-            fsc.start();
-            collectors.put(dpid, fsc);
         }
         @Override
@@ -343,15 +392,13 @@ public class OpenFlowRuleProvider extends AbstractProvider
                     .collect(Collectors.toList());
             providerService.pushFlowMetrics(did, flowEntries);
-
         }
-
     }
     /**
      * The internal cache entry holding the original request as well as
      * accumulating the any failures along the way.
-     *
+     * <p/>
      * If this entry is evicted from the cache then the entire operation is
      * considered failed. Otherwise, only the failures reported by the device
      * will be propagated up.
@@ -400,7 +447,6 @@ public class OpenFlowRuleProvider extends AbstractProvider
                             .unmodifiableSet(failures),
                     operation.deviceId());
         }
-
     }
 }