[ONOS-4164] Failed path info store
Change-Id: I8e16493ce479d2489b16fc76b56f55455927cb56
diff --git a/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/DistributedPceStoreTest.java b/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/DistributedPceStoreTest.java
index a64db83..e1ca650 100644
--- a/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/DistributedPceStoreTest.java
+++ b/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/DistributedPceStoreTest.java
@@ -29,6 +29,7 @@
import org.junit.BeforeClass;
import org.junit.Test;
+import org.onlab.util.DataRateUnit;
import org.onosproject.incubator.net.resource.label.DefaultLabelResource;
import org.onosproject.incubator.net.resource.label.LabelResource;
import org.onosproject.incubator.net.resource.label.LabelResourceId;
@@ -38,9 +39,12 @@
import org.onosproject.net.DefaultLink;
import org.onosproject.net.DeviceId;
import org.onosproject.net.ElementId;
+import org.onosproject.net.intent.Constraint;
+import org.onosproject.net.intent.constraint.BandwidthConstraint;
import org.onosproject.net.Link;
import org.onosproject.net.PortNumber;
import org.onosproject.net.resource.ResourceConsumer;
+import org.onosproject.pce.pceservice.LspType;
import org.onosproject.pce.pceservice.TunnelConsumerId;
import org.onosproject.pce.pcestore.api.LspLocalLabelInfo;
import org.onosproject.net.provider.ProviderId;
@@ -82,6 +86,10 @@
private TunnelId tunnelId4 = TunnelId.valueOf("4");
private PceccTunnelInfo pceccTunnelInfo1;
private PceccTunnelInfo pceccTunnelInfo2;
+ private PcePathInfo failedPathInfo1;
+ private PcePathInfo failedPathInfo2;
+ private PcePathInfo failedPathInfo3;
+ private PcePathInfo failedPathInfo4;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
@@ -150,6 +158,50 @@
lspLocalLabelInfoList2.add(lspLocalLabel2);
pceccTunnelInfo2 = new PceccTunnelInfo(lspLocalLabelInfoList2, tunnelConsumerId2);
+
+ // Creates failedPathInfo1
+ DeviceId src1 = DeviceId.deviceId("foo1");
+ DeviceId dst1 = DeviceId.deviceId("goo1");
+ String name1 = "pcc1";
+ LspType lspType1 = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints1 = new LinkedList<>();
+ Constraint bandwidth1 = BandwidthConstraint.of(200, DataRateUnit.BPS);
+ constraints1.add(bandwidth1);
+
+ failedPathInfo1 = new PcePathInfo(src1, dst1, name1, constraints1, lspType1);
+
+ // Creates failedPathInfo2
+ DeviceId src2 = DeviceId.deviceId("foo2");
+ DeviceId dst2 = DeviceId.deviceId("goo2");
+ String name2 = "pcc2";
+ LspType lspType2 = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints2 = new LinkedList<>();
+ Constraint bandwidth2 = BandwidthConstraint.of(400, DataRateUnit.BPS);
+ constraints2.add(bandwidth2);
+
+ failedPathInfo2 = new PcePathInfo(src2, dst2, name2, constraints2, lspType2);
+
+ // Creates failedPathInfo3
+ DeviceId src3 = DeviceId.deviceId("foo3");
+ DeviceId dst3 = DeviceId.deviceId("goo3");
+ String name3 = "pcc3";
+ LspType lspType3 = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints3 = new LinkedList<>();
+ Constraint bandwidth3 = BandwidthConstraint.of(500, DataRateUnit.BPS);
+ constraints3.add(bandwidth3);
+
+ failedPathInfo3 = new PcePathInfo(src3, dst3, name3, constraints3, lspType3);
+
+ // Creates failedPathInfo4
+ DeviceId src4 = DeviceId.deviceId("foo4");
+ DeviceId dst4 = DeviceId.deviceId("goo4");
+ String name4 = "pcc4";
+ LspType lspType4 = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints4 = new LinkedList<>();
+ Constraint bandwidth4 = BandwidthConstraint.of(600, DataRateUnit.BPS);
+ constraints4.add(bandwidth4);
+
+ failedPathInfo4 = new PcePathInfo(src4, dst4, name4, constraints4, lspType4);
}
@After
@@ -211,6 +263,22 @@
}
/**
+ * Checks the operation of addFailedPathInfo() method.
+ */
+ @Test
+ public void testAddFailedPathInfo() {
+ // initialization
+ distrPceStore.storageService = new TestStorageService();
+ distrPceStore.activate();
+
+ // PcePathInfo with pce path input information
+ distrPceStore.addFailedPathInfo(failedPathInfo1);
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo1), is(true));
+ distrPceStore.addFailedPathInfo(failedPathInfo2);
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo2), is(true));
+ }
+
+ /**
* Checks the operation of existsGlobalNodeLabel() method.
*/
@Test
@@ -248,6 +316,19 @@
}
/**
+ * Checks the operation of existsFailedPathInfo() method.
+ */
+ @Test
+ public void testExistsFailedPathInfo() {
+ testAddFailedPathInfo();
+
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo1), is(true));
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo2), is(true));
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo3), is(false));
+ assertThat(distrPceStore.existsFailedPathInfo(failedPathInfo4), is(false));
+ }
+
+ /**
* Checks the operation of getGlobalNodeLabelCount() method.
*/
@Test
@@ -278,6 +359,16 @@
}
/**
+ * Checks the operation of getFailedPathInfoCount() method.
+ */
+ @Test
+ public void testGetFailedPathInfoCount() {
+ testAddFailedPathInfo();
+
+ assertThat(distrPceStore.getFailedPathInfoCount(), is(2));
+ }
+
+ /**
* Checks the operation of getGlobalNodeLabels() method.
*/
@Test
@@ -317,6 +408,18 @@
}
/**
+ * Checks the operation of getFailedPathInfos() method.
+ */
+ @Test
+ public void testGetFailedPathInfos() {
+ testAddFailedPathInfo();
+
+ Iterable<PcePathInfo> failedPathInfoSet = distrPceStore.getFailedPathInfos();
+ assertThat(failedPathInfoSet, is(notNullValue()));
+ assertThat(failedPathInfoSet.iterator().hasNext(), is(true));
+ }
+
+ /**
* Checks the operation of getGlobalNodeLabel() method.
*/
@Test
@@ -451,4 +554,17 @@
assertThat(distrPceStore.removeTunnelInfo(tunnelId1), is(true));
assertThat(distrPceStore.removeTunnelInfo(tunnelId2), is(true));
}
+
+ /**
+ * Checks the operation of removeFailedPathInfo() method.
+ */
+ @Test
+ public void testRemoveFailedPathInfo() {
+ testAddFailedPathInfo();
+
+ assertThat(distrPceStore.removeFailedPathInfo(failedPathInfo1), is(true));
+ assertThat(distrPceStore.removeFailedPathInfo(failedPathInfo2), is(true));
+ assertThat(distrPceStore.removeFailedPathInfo(failedPathInfo3), is(false));
+ assertThat(distrPceStore.removeFailedPathInfo(failedPathInfo4), is(false));
+ }
}
diff --git a/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/PcePathInfoTest.java b/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/PcePathInfoTest.java
new file mode 100644
index 0000000..09b60ab
--- /dev/null
+++ b/apps/pce/app/src/test/java/org/onosproject/pce/pcestore/PcePathInfoTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2016-present 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.pce.pcestore;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import com.google.common.testing.EqualsTester;
+
+import java.util.List;
+import java.util.LinkedList;
+
+import org.junit.Test;
+import org.onlab.util.DataRateUnit;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.intent.Constraint;
+import org.onosproject.net.intent.constraint.BandwidthConstraint;
+import org.onosproject.pce.pceservice.LspType;
+
+/**
+ * Unit tests for PcePathInfo class.
+ */
+public class PcePathInfoTest {
+
+ /**
+ * Checks the operation of equals() methods.
+ */
+ @Test
+ public void testEquals() {
+ // create same two objects.
+ DeviceId src1 = DeviceId.deviceId("foo1");
+ DeviceId dst1 = DeviceId.deviceId("goo1");
+ String name1 = "pcc1";
+ LspType lspType1 = LspType.WITH_SIGNALLING;
+ List<Constraint> constraints1 = new LinkedList<>();
+ Constraint bandwidth11 = BandwidthConstraint.of(100, DataRateUnit.BPS);
+ constraints1.add(bandwidth11);
+ Constraint bandwidth12 = BandwidthConstraint.of(200, DataRateUnit.BPS);
+ constraints1.add(bandwidth12);
+ Constraint bandwidth13 = BandwidthConstraint.of(300, DataRateUnit.BPS);
+ constraints1.add(bandwidth13);
+
+ PcePathInfo pathInfo1 = new PcePathInfo(src1, dst1, name1, constraints1, lspType1);
+
+ // create same object as above object
+ PcePathInfo samePathInfo1 = new PcePathInfo(src1, dst1, name1, constraints1, lspType1);
+
+ // Create different object.
+ DeviceId src2 = DeviceId.deviceId("foo2");
+ DeviceId dst2 = DeviceId.deviceId("goo2");
+ String name2 = "pcc2";
+ LspType lspType2 = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints2 = new LinkedList<>();
+ Constraint bandwidth21 = BandwidthConstraint.of(400, DataRateUnit.BPS);
+ constraints2.add(bandwidth21);
+ Constraint bandwidth22 = BandwidthConstraint.of(800, DataRateUnit.BPS);
+ constraints2.add(bandwidth22);
+
+ PcePathInfo pathInfo2 = new PcePathInfo(src2, dst2, name2, constraints2, lspType2);
+
+ new EqualsTester().addEqualityGroup(pathInfo1, samePathInfo1)
+ .addEqualityGroup(pathInfo2)
+ .testEquals();
+ }
+
+ /**
+ * Checks the construction of a PcePathInfo object.
+ */
+ @Test
+ public void testConstruction() {
+ DeviceId src = DeviceId.deviceId("foo2");
+ DeviceId dst = DeviceId.deviceId("goo2");
+ String name = "pcc2";
+ LspType lspType = LspType.SR_WITHOUT_SIGNALLING;
+ List<Constraint> constraints = new LinkedList<>();
+ Constraint bandwidth1 = BandwidthConstraint.of(100, DataRateUnit.BPS);
+ constraints.add(bandwidth1);
+ Constraint bandwidth2 = BandwidthConstraint.of(200, DataRateUnit.BPS);
+ constraints.add(bandwidth2);
+ Constraint bandwidth3 = BandwidthConstraint.of(300, DataRateUnit.BPS);
+ constraints.add(bandwidth3);
+
+ PcePathInfo pathInfo = new PcePathInfo(src, dst, name, constraints, lspType);
+
+ assertThat(src, is(pathInfo.src()));
+ assertThat(dst, is(pathInfo.dst()));
+ assertThat(name, is(pathInfo.name()));
+ assertThat(constraints, is(pathInfo.constraints()));
+ assertThat(lspType, is(pathInfo.lspType()));
+ }
+}
diff --git a/apps/pce/app/src/test/java/org/onosproject/pce/util/PceStoreAdapter.java b/apps/pce/app/src/test/java/org/onosproject/pce/util/PceStoreAdapter.java
new file mode 100644
index 0000000..beaf8ae
--- /dev/null
+++ b/apps/pce/app/src/test/java/org/onosproject/pce/util/PceStoreAdapter.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2016-present 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.pce.util;
+
+import com.google.common.collect.ImmutableSet;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.onosproject.incubator.net.resource.label.LabelResourceId;
+import org.onosproject.incubator.net.tunnel.TunnelId;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.net.resource.ResourceConsumer;
+import org.onosproject.pce.pcestore.PceccTunnelInfo;
+import org.onosproject.pce.pcestore.PcePathInfo;
+import org.onosproject.pce.pcestore.api.LspLocalLabelInfo;
+import org.onosproject.pce.pcestore.api.PceStore;
+
+/**
+ * Provides test implementation of PceStore.
+ */
+public class PceStoreAdapter implements PceStore {
+
+ // Mapping device with global node label
+ private ConcurrentMap<DeviceId, LabelResourceId> globalNodeLabelMap = new ConcurrentHashMap<>();
+
+ // Mapping link with adjacency label
+ private ConcurrentMap<Link, LabelResourceId> adjLabelMap = new ConcurrentHashMap<>();
+
+ // Mapping tunnel with device local info with tunnel consumer id
+ private ConcurrentMap<TunnelId, PceccTunnelInfo> tunnelInfoMap = new ConcurrentHashMap<>();
+
+ // Set of Path info
+ private Set<PcePathInfo> failedPathInfoSet = new HashSet<>();
+
+ @Override
+ public boolean existsGlobalNodeLabel(DeviceId id) {
+ return globalNodeLabelMap.containsKey(id);
+ }
+
+ @Override
+ public boolean existsAdjLabel(Link link) {
+ return adjLabelMap.containsKey(link);
+ }
+
+ @Override
+ public boolean existsTunnelInfo(TunnelId tunnelId) {
+ return tunnelInfoMap.containsKey(tunnelId);
+ }
+
+ @Override
+ public boolean existsFailedPathInfo(PcePathInfo pathInfo) {
+ return failedPathInfoSet.contains(pathInfo);
+ }
+
+ @Override
+ public int getGlobalNodeLabelCount() {
+ return globalNodeLabelMap.size();
+ }
+
+ @Override
+ public int getAdjLabelCount() {
+ return adjLabelMap.size();
+ }
+
+ @Override
+ public int getTunnelInfoCount() {
+ return tunnelInfoMap.size();
+ }
+
+ @Override
+ public int getFailedPathInfoCount() {
+ return failedPathInfoSet.size();
+ }
+
+ @Override
+ public Map<DeviceId, LabelResourceId> getGlobalNodeLabels() {
+ return globalNodeLabelMap.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> (LabelResourceId) e.getValue()));
+ }
+
+ @Override
+ public Map<Link, LabelResourceId> getAdjLabels() {
+ return adjLabelMap.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> (LabelResourceId) e.getValue()));
+ }
+
+ @Override
+ public Map<TunnelId, PceccTunnelInfo> getTunnelInfos() {
+ return tunnelInfoMap.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> (PceccTunnelInfo) e.getValue()));
+ }
+
+ @Override
+ public Iterable<PcePathInfo> getFailedPathInfos() {
+ return ImmutableSet.copyOf(failedPathInfoSet);
+ }
+
+ @Override
+ public LabelResourceId getGlobalNodeLabel(DeviceId id) {
+ return globalNodeLabelMap.get(id);
+ }
+
+ @Override
+ public LabelResourceId getAdjLabel(Link link) {
+ return adjLabelMap.get(link);
+ }
+
+ @Override
+ public PceccTunnelInfo getTunnelInfo(TunnelId tunnelId) {
+ return tunnelInfoMap.get(tunnelId);
+ }
+
+ @Override
+ public void addGlobalNodeLabel(DeviceId deviceId, LabelResourceId labelId) {
+ globalNodeLabelMap.put(deviceId, labelId);
+ }
+
+ @Override
+ public void addAdjLabel(Link link, LabelResourceId labelId) {
+ adjLabelMap.put(link, labelId);
+ }
+
+ @Override
+ public void addTunnelInfo(TunnelId tunnelId, PceccTunnelInfo pceccTunnelInfo) {
+ tunnelInfoMap.put(tunnelId, pceccTunnelInfo);
+ }
+
+ @Override
+ public void addFailedPathInfo(PcePathInfo pathInfo) {
+ failedPathInfoSet.add(pathInfo);
+ }
+
+ @Override
+ public boolean updateTunnelInfo(TunnelId tunnelId, List<LspLocalLabelInfo> lspLocalLabelInfoList) {
+ if (!tunnelInfoMap.containsKey((tunnelId))) {
+ return false;
+ }
+
+ PceccTunnelInfo labelStoreInfo = tunnelInfoMap.get(tunnelId);
+ labelStoreInfo.lspLocalLabelInfoList(lspLocalLabelInfoList);
+ tunnelInfoMap.put(tunnelId, labelStoreInfo);
+ return true;
+ }
+
+ @Override
+ public boolean updateTunnelInfo(TunnelId tunnelId, ResourceConsumer tunnelConsumerId) {
+ if (!tunnelInfoMap.containsKey((tunnelId))) {
+ return false;
+ }
+
+ PceccTunnelInfo tunnelInfo = tunnelInfoMap.get(tunnelId);
+ tunnelInfo.tunnelConsumerId(tunnelConsumerId);
+ tunnelInfoMap.put(tunnelId, tunnelInfo);
+ return true;
+ }
+
+ @Override
+ public boolean removeGlobalNodeLabel(DeviceId id) {
+ globalNodeLabelMap.remove(id);
+ if (globalNodeLabelMap.containsKey(id)) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removeAdjLabel(Link link) {
+ adjLabelMap.remove(link);
+ if (adjLabelMap.containsKey(link)) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removeTunnelInfo(TunnelId tunnelId) {
+ tunnelInfoMap.remove(tunnelId);
+ if (tunnelInfoMap.containsKey(tunnelId)) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removeFailedPathInfo(PcePathInfo pathInfo) {
+ if (failedPathInfoSet.remove(pathInfo)) {
+ return false;
+ }
+ return true;
+ }
+}