Unit Tests for Bandwidth and Lambda allocations
These tests are for checking the valid path calculation logic
in the intent compilers and the PathIntent installer.
Change-Id: I2986729ae27202a2f42a71e64a53026383ddfb0b
diff --git a/core/api/src/test/java/org/onlab/onos/net/NetTestTools.java b/core/api/src/test/java/org/onlab/onos/net/NetTestTools.java
index 8d2a61b..5f8920b 100644
--- a/core/api/src/test/java/org/onlab/onos/net/NetTestTools.java
+++ b/core/api/src/test/java/org/onlab/onos/net/NetTestTools.java
@@ -15,6 +15,8 @@
*/
package org.onlab.onos.net;
+import org.onlab.onos.TestApplicationId;
+import org.onlab.onos.core.ApplicationId;
import org.onlab.onos.net.provider.ProviderId;
import org.onlab.packet.ChassisId;
import org.onlab.packet.IpAddress;
@@ -39,6 +41,7 @@
}
public static final ProviderId PID = new ProviderId("of", "foo");
+ public static final ApplicationId APP_ID = new TestApplicationId("foo");
// Short-hand for producing a device id from a string
public static DeviceId did(String id) {
diff --git a/core/net/src/main/java/org/onlab/onos/net/intent/impl/PathIntentInstaller.java b/core/net/src/main/java/org/onlab/onos/net/intent/impl/PathIntentInstaller.java
index 461f670..9c196a2 100644
--- a/core/net/src/main/java/org/onlab/onos/net/intent/impl/PathIntentInstaller.java
+++ b/core/net/src/main/java/org/onlab/onos/net/intent/impl/PathIntentInstaller.java
@@ -67,7 +67,7 @@
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected LinkResourceService resourceService;
- private ApplicationId appId;
+ protected ApplicationId appId;
@Activate
public void activate() {
diff --git a/core/net/src/test/java/org/onlab/onos/net/intent/IntentTestsMocks.java b/core/net/src/test/java/org/onlab/onos/net/intent/IntentTestsMocks.java
index 6331706..e0fe09e 100644
--- a/core/net/src/test/java/org/onlab/onos/net/intent/IntentTestsMocks.java
+++ b/core/net/src/test/java/org/onlab/onos/net/intent/IntentTestsMocks.java
@@ -16,23 +16,39 @@
package org.onlab.onos.net.intent;
import static org.onlab.onos.net.NetTestTools.createPath;
+import static org.onlab.onos.net.NetTestTools.link;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
+import java.util.LinkedList;
import java.util.List;
import java.util.Set;
+import org.onlab.onos.net.DeviceId;
import org.onlab.onos.net.ElementId;
+import org.onlab.onos.net.Link;
import org.onlab.onos.net.Path;
import org.onlab.onos.net.flow.TrafficSelector;
import org.onlab.onos.net.flow.TrafficTreatment;
import org.onlab.onos.net.flow.criteria.Criterion;
import org.onlab.onos.net.flow.criteria.Criterion.Type;
import org.onlab.onos.net.flow.instructions.Instruction;
+import org.onlab.onos.net.resource.BandwidthResourceRequest;
+import org.onlab.onos.net.resource.LambdaResourceRequest;
+import org.onlab.onos.net.resource.LinkResourceAllocations;
+import org.onlab.onos.net.resource.LinkResourceRequest;
+import org.onlab.onos.net.resource.LinkResourceService;
+import org.onlab.onos.net.resource.ResourceAllocation;
+import org.onlab.onos.net.resource.ResourceRequest;
+import org.onlab.onos.net.resource.ResourceType;
+import org.onlab.onos.net.topology.DefaultTopologyEdge;
+import org.onlab.onos.net.topology.DefaultTopologyVertex;
import org.onlab.onos.net.topology.LinkWeight;
import org.onlab.onos.net.topology.PathService;
+import org.onlab.onos.net.topology.TopologyVertex;
/**
* Common mocks used by the intent framework tests.
@@ -101,7 +117,158 @@
@Override
public Set<Path> getPaths(ElementId src, ElementId dst, LinkWeight weight) {
- return getPaths(src, dst);
+ final Set<Path> paths = getPaths(src, dst);
+
+ for (Path path : paths) {
+ final DeviceId srcDevice = path.src().deviceId();
+ final DeviceId dstDevice = path.dst().deviceId();
+ final TopologyVertex srcVertex = new DefaultTopologyVertex(srcDevice);
+ final TopologyVertex dstVertex = new DefaultTopologyVertex(dstDevice);
+ final Link link = link(src.toString(), 1, dst.toString(), 1);
+
+ final double weightValue = weight.weight(new DefaultTopologyEdge(srcVertex, dstVertex, link));
+ if (weightValue < 0) {
+ return new HashSet<>();
+ }
+ }
+ return paths;
}
}
+
+ public static class MockLinkResourceAllocations implements LinkResourceAllocations {
+ @Override
+ public Set<ResourceAllocation> getResourceAllocation(Link link) {
+ return null;
+ }
+
+ @Override
+ public IntentId intendId() {
+ return null;
+ }
+
+ @Override
+ public Collection<Link> links() {
+ return null;
+ }
+
+ @Override
+ public Set<ResourceRequest> resources() {
+ return null;
+ }
+
+ @Override
+ public ResourceType type() {
+ return null;
+ }
+ }
+
+ public static class MockedAllocationFailure extends RuntimeException { }
+
+ public static class MockResourceService implements LinkResourceService {
+
+ double availableBandwidth = -1.0;
+ int availableLambda = -1;
+
+ /**
+ * Allocates a resource service that will allow bandwidth allocations
+ * up to a limit.
+ *
+ * @param bandwidth available bandwidth limit
+ * @return resource manager for bandwidth requests
+ */
+ public static MockResourceService makeBandwidthResourceService(double bandwidth) {
+ final MockResourceService result = new MockResourceService();
+ result.availableBandwidth = bandwidth;
+ return result;
+ }
+
+ /**
+ * Allocates a resource service that will allow lambda allocations.
+ *
+ * @param lambda Lambda to return for allocation requests. Currently unused
+ * @return resource manager for lambda requests
+ */
+ public static MockResourceService makeLambdaResourceService(int lambda) {
+ final MockResourceService result = new MockResourceService();
+ result.availableLambda = lambda;
+ return result;
+ }
+
+ public void setAvailableBandwidth(double availableBandwidth) {
+ this.availableBandwidth = availableBandwidth;
+ }
+
+ public void setAvailableLambda(int availableLambda) {
+ this.availableLambda = availableLambda;
+ }
+
+
+ @Override
+ public LinkResourceAllocations requestResources(LinkResourceRequest req) {
+ int lambda = -1;
+ double bandwidth = -1.0;
+
+ for (ResourceRequest resourceRequest : req.resources()) {
+ if (resourceRequest.type() == ResourceType.BANDWIDTH) {
+ final BandwidthResourceRequest brr = (BandwidthResourceRequest) resourceRequest;
+ bandwidth = brr.bandwidth().toDouble();
+ } else if (resourceRequest.type() == ResourceType.LAMBDA) {
+ lambda = 1;
+ }
+ }
+
+ if (availableBandwidth < bandwidth) {
+ throw new MockedAllocationFailure();
+ }
+ if (lambda > 0 && availableLambda == 0) {
+ throw new MockedAllocationFailure();
+ }
+
+ return new IntentTestsMocks.MockLinkResourceAllocations();
+ }
+
+ @Override
+ public void releaseResources(LinkResourceAllocations allocations) {
+ // Mock
+ }
+
+ @Override
+ public LinkResourceAllocations updateResources(LinkResourceRequest req,
+ LinkResourceAllocations oldAllocations) {
+ return null;
+ }
+
+ @Override
+ public Iterable<LinkResourceAllocations> getAllocations() {
+ return null;
+ }
+
+ @Override
+ public Iterable<LinkResourceAllocations> getAllocations(Link link) {
+ return null;
+ }
+
+ @Override
+ public LinkResourceAllocations getAllocations(IntentId intentId) {
+ return null;
+ }
+
+ @Override
+ public Iterable<ResourceRequest> getAvailableResources(Link link) {
+ final List<ResourceRequest> result = new LinkedList<>();
+ if (availableBandwidth > 0.0) {
+ result.add(new BandwidthResourceRequest(availableBandwidth));
+ }
+ if (availableLambda > 0) {
+ result.add(new LambdaResourceRequest());
+ }
+ return result;
+ }
+
+ @Override
+ public ResourceRequest getAvailableResources(Link link, LinkResourceAllocations allocations) {
+ return null;
+ }
+ }
+
}
diff --git a/core/net/src/test/java/org/onlab/onos/net/intent/impl/PathConstraintCalculationTest.java b/core/net/src/test/java/org/onlab/onos/net/intent/impl/PathConstraintCalculationTest.java
new file mode 100644
index 0000000..3e8e7c1
--- /dev/null
+++ b/core/net/src/test/java/org/onlab/onos/net/intent/impl/PathConstraintCalculationTest.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright 2014 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.onlab.onos.net.intent.impl;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.onlab.onos.net.flow.FlowRuleBatchOperation;
+import org.onlab.onos.net.flow.TrafficSelector;
+import org.onlab.onos.net.flow.TrafficTreatment;
+import org.onlab.onos.net.intent.Constraint;
+import org.onlab.onos.net.intent.Intent;
+import org.onlab.onos.net.intent.IntentTestsMocks;
+import org.onlab.onos.net.intent.PathIntent;
+import org.onlab.onos.net.intent.PointToPointIntent;
+import org.onlab.onos.net.intent.constraint.BandwidthConstraint;
+import org.onlab.onos.net.intent.constraint.LambdaConstraint;
+import org.onlab.onos.net.resource.Bandwidth;
+import org.onlab.onos.net.resource.Lambda;
+import org.onlab.onos.net.resource.LinkResourceService;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.fail;
+import static org.onlab.onos.net.NetTestTools.APP_ID;
+import static org.onlab.onos.net.NetTestTools.connectPoint;
+
+/**
+ * Unit tests for calculating paths for intents with constraints.
+ */
+
+public class PathConstraintCalculationTest {
+
+ /**
+ * Creates a point to point intent compiler for a three switch linear
+ * topology.
+ *
+ * @param resourceService service to use for resource allocation requests
+ * @return point to point compiler
+ */
+ private PointToPointIntentCompiler makeCompiler(LinkResourceService resourceService) {
+ final String[] hops = {"s1", "s2", "s3"};
+ final PointToPointIntentCompiler compiler = new PointToPointIntentCompiler();
+ compiler.resourceService = resourceService;
+ compiler.pathService = new IntentTestsMocks.MockPathService(hops);
+ return compiler;
+ }
+
+ /**
+ * Creates an intent with a given constraint and compiles it. The compiler
+ * will throw PathNotFoundException if the allocations cannot be satisfied.
+ *
+ * @param constraint constraint to apply to the created intent
+ * @param resourceService service to use for resource allocation requests
+ * @return List of compiled intents
+ */
+ private List<Intent> compileIntent(Constraint constraint,
+ LinkResourceService resourceService) {
+ final List<Constraint> constraints = new LinkedList<>();
+ constraints.add(constraint);
+ final TrafficSelector selector = new IntentTestsMocks.MockSelector();
+ final TrafficTreatment treatment = new IntentTestsMocks.MockTreatment();
+
+ final PointToPointIntent intent =
+ new PointToPointIntent(APP_ID,
+ selector,
+ treatment,
+ connectPoint("s1", 1),
+ connectPoint("s3", 1),
+ constraints);
+ final PointToPointIntentCompiler compiler = makeCompiler(resourceService);
+
+ return compiler.compile(intent);
+ }
+
+ /**
+ * Installs a compiled path intent and returns the flow rules it generates.
+ *
+ * @param compiledIntents list of compiled intents
+ * @param resourceService service to use for resource allocation requests
+ * @return
+ */
+ private List<FlowRuleBatchOperation> installIntents(List<Intent> compiledIntents,
+ LinkResourceService resourceService) {
+ final PathIntent path = (PathIntent) compiledIntents.get(0);
+
+ final PathIntentInstaller installer = new PathIntentInstaller();
+ installer.resourceService = resourceService;
+ installer.appId = APP_ID;
+ return installer.install(path);
+ }
+
+ /**
+ * Tests that requests with sufficient available bandwidth succeed.
+ */
+ @Test
+ public void testBandwidthConstrainedIntentSuccess() {
+
+ final LinkResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+ final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+ final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+ }
+
+ /**
+ * Tests that requests with insufficient available bandwidth fail.
+ */
+ @Test
+ public void testBandwidthConstrainedIntentFailure() {
+
+ final LinkResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeBandwidthResourceService(10.0);
+ final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+ try {
+ compileIntent(constraint, resourceService);
+ fail("Point to Point compilation with insufficient bandwidth does "
+ + "not throw exception.");
+ } catch (PathNotFoundException noPath) {
+ assertThat(noPath.getMessage(), containsString("No packet path"));
+ }
+ }
+
+ /**
+ * Tests that requests for available lambdas are successful.
+ */
+ @Test
+ public void testLambdaConstrainedIntentSuccess() {
+
+ final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+ final LinkResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+
+ final List<Intent> compiledIntents =
+ compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+ }
+
+ /**
+ * Tests that requests for lambdas when there are no available lambdas
+ * fail.
+ */
+ @Test
+ public void testLambdaConstrainedIntentFailure() {
+
+ final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+ final LinkResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeBandwidthResourceService(10.0);
+ try {
+ compileIntent(constraint, resourceService);
+ fail("Point to Point compilation with no available lambda does "
+ + "not throw exception.");
+ } catch (PathNotFoundException noPath) {
+ assertThat(noPath.getMessage(), containsString("No packet path"));
+ }
+ }
+
+ /**
+ * Tests that installation of bandwidth constrained path intents are
+ * successful.
+ */
+ @Test
+ public void testInstallBandwidthConstrainedIntentSuccess() {
+
+ final IntentTestsMocks.MockResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+ final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+ final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+
+ final List<FlowRuleBatchOperation> flowOperations =
+ installIntents(compiledIntents, resourceService);
+
+ assertThat(flowOperations, notNullValue());
+ assertThat(flowOperations, hasSize(1));
+ }
+
+ /**
+ * Tests that installation of bandwidth constrained path intents fail
+ * if there are no available resources.
+ */
+ @Test
+ public void testInstallBandwidthConstrainedIntentFailure() {
+
+ final IntentTestsMocks.MockResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+ final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+ final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+
+ // Make it look like the available bandwidth was consumed
+ resourceService.setAvailableBandwidth(1.0);
+
+ try {
+ installIntents(compiledIntents, resourceService);
+ fail("Bandwidth request with no available bandwidth did not fail.");
+ } catch (IntentTestsMocks.MockedAllocationFailure failure) {
+ assertThat(failure,
+ instanceOf(IntentTestsMocks.MockedAllocationFailure.class));
+ }
+ }
+
+ /**
+ * Tests that installation of lambda constrained path intents are
+ * successful.
+ */
+ @Test
+ public void testInstallLambdaConstrainedIntentSuccess() {
+
+ final IntentTestsMocks.MockResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+ final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+
+ final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+
+ final List<FlowRuleBatchOperation> flowOperations =
+ installIntents(compiledIntents, resourceService);
+
+ assertThat(flowOperations, notNullValue());
+ assertThat(flowOperations, hasSize(1));
+ }
+
+ /**
+ * Tests that installation of lambda constrained path intents fail
+ * if there are no available resources.
+ */
+ @Test
+ public void testInstallLambdaConstrainedIntentFailure() {
+
+ final IntentTestsMocks.MockResourceService resourceService =
+ IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+ final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+
+ final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+ assertThat(compiledIntents, notNullValue());
+ assertThat(compiledIntents, hasSize(1));
+
+ // Make it look like the available lambda was consumed
+ resourceService.setAvailableLambda(0);
+
+ try {
+ installIntents(compiledIntents, resourceService);
+ fail("Lambda request with no available lambda did not fail.");
+ } catch (IntentTestsMocks.MockedAllocationFailure failure) {
+ assertThat(failure,
+ instanceOf(IntentTestsMocks.MockedAllocationFailure.class));
+ }
+ }
+
+}