Adding first fallback provider for flow rule subsystem.
Fixing onos-check-apps.
Change-Id: Ic8c2bac4403bb7a49813826262706e857932b6c0
diff --git a/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleDriverProvider.java b/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleDriverProvider.java
new file mode 100644
index 0000000..4d2eaf7
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleDriverProvider.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2014-2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.net.flow.impl;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.LinkedListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.flow.CompletedBatchOperation;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.FlowRuleBatchEntry;
+import org.onosproject.net.flow.FlowRuleBatchOperation;
+import org.onosproject.net.flow.FlowRuleProgrammable;
+import org.onosproject.net.flow.FlowRuleProvider;
+import org.onosproject.net.flow.FlowRuleProviderService;
+import org.onosproject.net.provider.AbstractProvider;
+import org.onosproject.net.provider.ProviderId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import static com.google.common.collect.ImmutableSet.copyOf;
+import static org.onosproject.net.flow.FlowRuleBatchEntry.FlowRuleOperation.*;
+
+/**
+ * Driver-based flow rule provider.
+ */
+class FlowRuleDriverProvider extends AbstractProvider implements FlowRuleProvider {
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ // Perhaps to be extracted for better reuse as we deal with other.
+ public static final String SCHEME = "default";
+ public static final String PROVIDER_NAME = "org.onosproject.provider";
+
+ FlowRuleProviderService providerService;
+ private DeviceService deviceService;
+ private MastershipService mastershipService;
+
+ private ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+ private ScheduledFuture<?> poller = null;
+
+ /**
+ * Creates a new fallback flow rule provider.
+ */
+ FlowRuleDriverProvider() {
+ super(new ProviderId(SCHEME, PROVIDER_NAME));
+ }
+
+ /**
+ * Initializes the provider with necessary supporting services.
+ *
+ * @param providerService flow rule provider service
+ * @param deviceService device service
+ * @param mastershipService mastership service
+ * @param pollFrequency flow entry poll frequency
+ */
+ void init(FlowRuleProviderService providerService,
+ DeviceService deviceService, MastershipService mastershipService,
+ int pollFrequency) {
+ this.providerService = providerService;
+ this.deviceService = deviceService;
+ this.mastershipService = mastershipService;
+
+ if (poller != null && !poller.isCancelled()) {
+ poller.cancel(false);
+ }
+
+ poller = executor.scheduleAtFixedRate(this::pollFlowEntries, pollFrequency,
+ pollFrequency, TimeUnit.SECONDS);
+ }
+
+ @Override
+ public void applyFlowRule(FlowRule... flowRules) {
+ rulesByDevice(flowRules).asMap().forEach(this::applyFlowRules);
+ }
+
+ @Override
+ public void removeFlowRule(FlowRule... flowRules) {
+ rulesByDevice(flowRules).asMap().forEach(this::removeFlowRules);
+ }
+
+ @Override
+ public void removeRulesById(ApplicationId id, FlowRule... flowRules) {
+ removeFlowRule(flowRules);
+ }
+
+ @Override
+ public void executeBatch(FlowRuleBatchOperation batch) {
+ ImmutableList.Builder<FlowRule> toAdd = ImmutableList.builder();
+ ImmutableList.Builder<FlowRule> toRemove = ImmutableList.builder();
+ for (FlowRuleBatchEntry fbe : batch.getOperations()) {
+ if (fbe.operator() == ADD || fbe.operator() == MODIFY) {
+ toAdd.add(fbe.target());
+ } else if (fbe.operator() == REMOVE) {
+ toRemove.add(fbe.target());
+ }
+ }
+
+ ImmutableList<FlowRule> rulesToAdd = toAdd.build();
+ ImmutableList<FlowRule> rulesToRemove = toRemove.build();
+
+ Collection<FlowRule> added = applyFlowRules(batch.deviceId(), rulesToAdd);
+ Collection<FlowRule> removed = removeFlowRules(batch.deviceId(), rulesToRemove);
+
+ Set<FlowRule> failedRules = Sets.union(Sets.difference(copyOf(rulesToAdd), copyOf(added)),
+ Sets.difference(copyOf(rulesToRemove), copyOf(removed)));
+ CompletedBatchOperation status =
+ new CompletedBatchOperation(failedRules.isEmpty(), failedRules, batch.deviceId());
+ providerService.batchOperationCompleted(batch.id(), status);
+ }
+
+ private Multimap<DeviceId, FlowRule> rulesByDevice(FlowRule[] flowRules) {
+ // Sort the flow rules by device id
+ Multimap<DeviceId, FlowRule> rulesByDevice = LinkedListMultimap.create();
+ for (FlowRule rule : flowRules) {
+ rulesByDevice.put(rule.deviceId(), rule);
+ }
+ return rulesByDevice;
+ }
+
+ private Collection<FlowRule> applyFlowRules(DeviceId deviceId, Collection<FlowRule> flowRules) {
+ FlowRuleProgrammable programmer = getFlowRuleProgrammable(deviceId);
+ return programmer != null ? programmer.applyFlowRules(flowRules) : ImmutableList.of();
+ }
+
+ private Collection<FlowRule> removeFlowRules(DeviceId deviceId, Collection<FlowRule> flowRules) {
+ FlowRuleProgrammable programmer = getFlowRuleProgrammable(deviceId);
+ return programmer != null ? programmer.removeFlowRules(flowRules) : ImmutableList.of();
+ }
+
+ private FlowRuleProgrammable getFlowRuleProgrammable(DeviceId deviceId) {
+ FlowRuleProgrammable programmable = deviceService.getDevice(deviceId).as(FlowRuleProgrammable.class);
+ if (programmable == null) {
+ log.warn("Device {} is not flow rule programmable");
+ }
+ return programmable;
+ }
+
+
+ private void pollFlowEntries() {
+ deviceService.getAvailableDevices().forEach(device -> {
+ if (mastershipService.isLocalMaster(device.id()) && device.is(FlowRuleProgrammable.class)) {
+ providerService.pushFlowMetrics(device.id(),
+ device.as(FlowRuleProgrammable.class).getFlowEntries());
+ }
+ });
+ }
+
+}
diff --git a/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleManager.java b/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleManager.java
index 9162ff6..93ddf1a 100644
--- a/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleManager.java
+++ b/core/net/src/main/java/org/onosproject/net/flow/impl/FlowRuleManager.java
@@ -21,7 +21,6 @@
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
-
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
@@ -31,14 +30,14 @@
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.cfg.ComponentConfigService;
-import org.onosproject.net.device.DeviceEvent;
-import org.onosproject.net.device.DeviceListener;
-import org.onosproject.net.provider.AbstractListenerProviderRegistry;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.core.IdGenerator;
+import org.onosproject.mastership.MastershipService;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.flow.CompletedBatchOperation;
import org.onosproject.net.flow.DefaultFlowEntry;
@@ -60,6 +59,7 @@
import org.onosproject.net.flow.FlowRuleStore;
import org.onosproject.net.flow.FlowRuleStoreDelegate;
import org.onosproject.net.flow.TableStatisticsEntry;
+import org.onosproject.net.provider.AbstractListenerProviderRegistry;
import org.onosproject.net.provider.AbstractProviderService;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
@@ -76,12 +76,14 @@
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Strings.isNullOrEmpty;
+import static org.onlab.util.Tools.get;
import static org.onlab.util.Tools.groupedThreads;
import static org.onosproject.net.flow.FlowRuleEvent.Type.RULE_ADD_REQUESTED;
import static org.onosproject.net.flow.FlowRuleEvent.Type.RULE_REMOVE_REQUESTED;
import static org.onosproject.security.AppGuard.checkPermission;
+import static org.onosproject.security.AppPermission.Type.FLOWRULE_READ;
+import static org.onosproject.security.AppPermission.Type.FLOWRULE_WRITE;
import static org.slf4j.LoggerFactory.getLogger;
-import static org.onosproject.security.AppPermission.Type.*;
@@ -95,6 +97,8 @@
FlowRuleProvider, FlowRuleProviderService>
implements FlowRuleService, FlowRuleProviderRegistry {
+ private final Logger log = getLogger(getClass());
+
public static final String FLOW_RULE_NULL = "FlowRule cannot be null";
private static final boolean ALLOW_EXTRANEOUS_RULES = false;
@@ -106,11 +110,16 @@
label = "Purge entries associated with a device when the device goes offline")
private boolean purgeOnDisconnection = false;
- private final Logger log = getLogger(getClass());
+ private static final int DEFAULT_POLL_FREQUENCY = 30;
+ @Property(name = "fallbackFlowPollFrequency", intValue = DEFAULT_POLL_FREQUENCY,
+ label = "Frequency (in seconds) for polling flow statistics via fallback provider")
+ private int fallbackFlowPollFrequency = DEFAULT_POLL_FREQUENCY;
private final FlowRuleStoreDelegate delegate = new InternalStoreDelegate();
private final DeviceListener deviceListener = new InternalDeviceListener();
+ private final FlowRuleDriverProvider defaultProvider = new FlowRuleDriverProvider();
+
protected ExecutorService deviceInstallers =
Executors.newFixedThreadPool(32, groupedThreads("onos/flowservice", "device-installer-%d"));
@@ -132,16 +141,19 @@
protected CoreService coreService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected MastershipService mastershipService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ComponentConfigService cfgService;
@Activate
public void activate(ComponentContext context) {
+ modified(context);
store.setDelegate(delegate);
eventDispatcher.addSink(FlowRuleEvent.class, listenerRegistry);
deviceService.addListener(deviceListener);
cfgService.registerProperties(getClass());
idGenerator = coreService.getIdGenerator(FLOW_OP_TOPIC);
- modified(context);
log.info("Started");
}
@@ -160,6 +172,13 @@
if (context != null) {
readComponentConfiguration(context);
}
+ defaultProvider.init(new InternalFlowRuleProviderService(defaultProvider),
+ deviceService, mastershipService, fallbackFlowPollFrequency);
+ }
+
+ @Override
+ protected FlowRuleProvider defaultProvider() {
+ return defaultProvider;
}
/**
@@ -190,6 +209,13 @@
log.info("Configured. PurgeOnDisconnection is {}",
purgeOnDisconnection ? "enabled" : "disabled");
}
+
+ String s = get(properties, "fallbackFlowPollFrequency");
+ try {
+ fallbackFlowPollFrequency = isNullOrEmpty(s) ? DEFAULT_POLL_FREQUENCY : Integer.parseInt(s);
+ } catch (NumberFormatException e) {
+ fallbackFlowPollFrequency = DEFAULT_POLL_FREQUENCY;
+ }
}
/**
@@ -201,15 +227,13 @@
*/
private static Boolean isPropertyEnabled(Dictionary<?, ?> properties,
String propertyName) {
- Boolean value = null;
try {
String s = (String) properties.get(propertyName);
- value = isNullOrEmpty(s) ? null : s.trim().equals("true");
+ return isNullOrEmpty(s) ? null : s.trim().equals("true");
} catch (ClassCastException e) {
// No propertyName defined.
- value = null;
+ return null;
}
- return value;
}
@Override
@@ -229,8 +253,8 @@
checkPermission(FLOWRULE_WRITE);
FlowRuleOperations.Builder builder = FlowRuleOperations.builder();
- for (int i = 0; i < flowRules.length; i++) {
- builder.add(flowRules[i]);
+ for (FlowRule flowRule : flowRules) {
+ builder.add(flowRule);
}
apply(builder.build());
}
@@ -240,8 +264,8 @@
checkPermission(FLOWRULE_WRITE);
FlowRuleOperations.Builder builder = FlowRuleOperations.builder();
- for (int i = 0; i < flowRules.length; i++) {
- builder.remove(flowRules[i]);
+ for (FlowRule flowRule : flowRules) {
+ builder.remove(flowRule);
}
apply(builder.build());
}
@@ -419,15 +443,9 @@
//lastSeen.put(storedRule, currentTime);
}
Long last = lastSeen.get(storedRule);
- if (last == null) {
- // concurrently removed? let the liveness check fail
- return false;
- }
- if ((currentTime - last) <= timeout) {
- return true;
- }
- return false;
+ // concurrently removed? let the liveness check fail
+ return last != null && (currentTime - last) <= timeout;
}
@Override
@@ -466,7 +484,6 @@
}
} catch (Exception e) {
log.debug("Can't process added or extra rule {}", e.getMessage());
- continue;
}
}
@@ -479,7 +496,6 @@
flowMissing(rule);
} catch (Exception e) {
log.debug("Can't add missing flow rule:", e);
- continue;
}
}
}