From 2fff70fb65f0d1f815e6f51deac78ed58e39acfe Mon Sep 17 00:00:00 2001 From: chengfan Date: Mon, 24 Aug 2015 18:20:19 -0500 Subject: [PATCH] [ONOS-2233] Implement of Tunnel monitoring, measurement and observation 1. add a tunnel statistics interface. 2. add a pcep tunnel statistics interface. 3. add a tunnelStatsCollector to poll statistic request ,The polling interval can be configurable. 4. extend the pcepTunnelProvider to handle tunnel statistic message Change-Id: I1187d586a1833ca4bee55529a65cd61eff0e612d --- .../onosproject/pcep/api/PcepController.java | 7 + .../pcep/api/PcepTunnelListener.java | 9 + .../pcep/api/PcepTunnelStatistics.java | 65 +++++++ .../net/tunnel/DefaultTunnelStatistics.java | 168 ++++++++++++++++++ .../net/tunnel/TunnelStatistics.java | 2 +- providers/pcep/tunnel/pom.xml | 16 ++ .../pcep/tunnel/impl/PcepTunnelProvider.java | 86 ++++++++- .../tunnel/impl/TunnelStatsCollector.java | 104 +++++++++++ .../tunnel/impl/PcepControllerAdapter.java | 5 + .../impl/PcepReleaseTunnelProviderTest.java | 4 + .../impl/PcepSetupTunnelProviderTest.java | 4 + .../tunnel/impl/PcepTunnelProviderTest.java | 4 + .../impl/PcepUpdateTunnelProviderTest.java | 5 + .../tunnel/impl/TunnelServiceAdapter.java | 107 +++++++++++ 14 files changed, 582 insertions(+), 4 deletions(-) create mode 100644 apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelStatistics.java create mode 100644 incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/DefaultTunnelStatistics.java create mode 100644 providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java create mode 100644 providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/TunnelServiceAdapter.java diff --git a/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepController.java b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepController.java index 5b181c34d5..a14dcd123a 100644 --- a/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepController.java +++ b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepController.java @@ -112,4 +112,11 @@ public interface PcepController { */ Boolean updateTunnelBandwidth(String id, long bandwidth); + /** + * Send statistic request by tunnel id. + * + * @param pcepTunnelId PCEP tunnel id + */ + void getTunnelStatistics(String pcepTunnelId); + } diff --git a/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelListener.java b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelListener.java index 2c974a4435..8b64b92343 100644 --- a/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelListener.java +++ b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelListener.java @@ -28,4 +28,13 @@ public interface PcepTunnelListener { */ void handlePCEPTunnel(PcepTunnel tunnel); + /** + * Notify that get a tunnel statistic data from the network. + * + * @param tunnelStatistics tunnel statistic information. + */ + void handlePcepTunnelStatistics(PcepTunnelStatistics tunnelStatistics); + + + } diff --git a/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelStatistics.java b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelStatistics.java new file mode 100644 index 0000000000..20ed00e395 --- /dev/null +++ b/apps/pcep-api/src/main/java/org/onosproject/pcep/api/PcepTunnelStatistics.java @@ -0,0 +1,65 @@ +/* + * + * * Copyright 2015 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.pcep.api; + +import java.time.Duration; +import java.util.List; + +/** + * Statistics of a PCEP tunnel. + */ +public interface PcepTunnelStatistics { + + + /** + * Returns the id of PCEP tunnel. + * + * @return PCEP tunnel id + */ + long id(); + + + /** + * Returns the bandwidth utilization of a PCEP tunnel. + * + * @return PCEP bandwidth utilization + */ + double bandwidthUtilization(); + + /** + * Returns the flow loss rate of a tunnel. + * + * @return tunnel flow loss rate + */ + double packetLossRate(); + + /** + * Returns the end-to-end traffic flow delay of a tunnel. + * + * @return tunnel traffic flow delay + */ + Duration flowDelay(); + + /** + * Returns the alarms on a tunnel. + * + * @return tunnel alarms + */ + List alarms(); +} diff --git a/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/DefaultTunnelStatistics.java b/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/DefaultTunnelStatistics.java new file mode 100644 index 0000000000..6358ca92c8 --- /dev/null +++ b/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/DefaultTunnelStatistics.java @@ -0,0 +1,168 @@ +/* + * + * * Copyright 2015 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.incubator.net.tunnel; + +import java.time.Duration; +import java.util.List; + +/** + * Default implementation of immutable tunnel statistics. + */ +public final class DefaultTunnelStatistics implements TunnelStatistics { + private final TunnelId tunnelId; + private final double bwUtilization; + private final double packetLossRatio; + private final Duration flowDelay; + private final List alarms; + + private DefaultTunnelStatistics(TunnelId tunnelId, + double bwUtilization, + double packetLossRatio, + Duration flowDelay, + List alarms) { + this.tunnelId = tunnelId; + this.bwUtilization = bwUtilization; + this.packetLossRatio = packetLossRatio; + this.flowDelay = flowDelay; + this.alarms = alarms; + } + + private DefaultTunnelStatistics() { + this.tunnelId = null; + this.bwUtilization = 0; + this.packetLossRatio = 0; + this.flowDelay = null; + this.alarms = null; + } + + + @Override + public TunnelId id() { + return this.tunnelId; + } + + @Override + public double bandwidthUtilization() { + return this.bwUtilization; + } + + @Override + public double packetLossRate() { + return this.packetLossRatio; + } + + @Override + public Duration flowDelay() { + return this.flowDelay; + } + + + @Override + public List alarms() { + return this.alarms; + } + + /** + * Builder for tunnelStatistics. + */ + public static final class Builder { + TunnelId tunnelId; + double bwUtilization; + double packetLossRatio; + Duration flowDelay; + List alarms; + + public Builder() { + + } + + /** + * Set tunnel id. + * + * @param tunnelId tunnel id + * @return builder object + */ + public Builder setTunnelId(TunnelId tunnelId) { + this.tunnelId = tunnelId; + + return this; + } + + /** + * set bandwidth utilization. + * + * @param bwUtilization bandwidth utilization + * @return builder object + */ + public Builder setBwUtilization(double bwUtilization) { + this.bwUtilization = bwUtilization; + + return this; + } + + /** + * Set packet loss ratio. + * + * @param packetLossRatio packet loss ratio + * @return builder object + */ + public Builder setPacketLossRatio(double packetLossRatio) { + this.packetLossRatio = packetLossRatio; + + return this; + } + + /** + * Set flow delay. + * + * @param flowDelay flow delay + * @return builder object + */ + public Builder setFlowDelay(Duration flowDelay) { + this.flowDelay = flowDelay; + + return this; + } + + /** + * Set alarms. + * + * @param alarms alarms of a tunnel + * @return builder object + */ + public Builder setAlarms(List alarms) { + this.alarms = alarms; + + return this; + } + + /** + * Creates a TunnelStatistics object. + * + * @return DefaultTunnelStatistics + */ + public DefaultTunnelStatistics build() { + return new DefaultTunnelStatistics(tunnelId, + bwUtilization, + packetLossRatio, + flowDelay, + alarms); + } + } +} diff --git a/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/TunnelStatistics.java b/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/TunnelStatistics.java index 61c77d749d..650f994135 100644 --- a/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/TunnelStatistics.java +++ b/incubator/api/src/main/java/org/onosproject/incubator/net/tunnel/TunnelStatistics.java @@ -41,7 +41,7 @@ public interface TunnelStatistics { double bandwidthUtilization(); /** - * Returns the packet loss rate of a tunnel. + * Returns the packet loss ratio of a tunnel. * * @return tunnel packet loss ratio */ diff --git a/providers/pcep/tunnel/pom.xml b/providers/pcep/tunnel/pom.xml index ac9a17f75a..09efb8ae56 100644 --- a/providers/pcep/tunnel/pom.xml +++ b/providers/pcep/tunnel/pom.xml @@ -19,5 +19,21 @@ org.onosproject onos-pcep-controller-api + + org.osgi + org.osgi.compendium + + + org.onosproject + onos-api + tests + test + + + org.onosproject + onos-incubator-net + ${project.version} + test + \ No newline at end of file diff --git a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java index 152a388274..648e500b1a 100644 --- a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java +++ b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java @@ -16,7 +16,9 @@ package org.onosproject.provider.pcep.tunnel.impl; import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Strings.isNullOrEmpty; import static org.onosproject.net.DefaultAnnotations.EMPTY; +import static org.onlab.util.Tools.get; import static org.onosproject.net.DeviceId.deviceId; import static org.onosproject.net.PortNumber.portNumber; import static org.onosproject.pcep.api.PcepDpid.uri; @@ -24,24 +26,29 @@ import static org.slf4j.LoggerFactory.getLogger; import java.util.ArrayList; import java.util.Collections; +import java.util.Dictionary; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.Optional; +import com.google.common.collect.Maps; 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.Property; import org.apache.felix.scr.annotations.Reference; import org.apache.felix.scr.annotations.ReferenceCardinality; import org.apache.felix.scr.annotations.Service; import org.onlab.packet.IpAddress; +import org.onosproject.cfg.ComponentConfigService; import org.onosproject.core.DefaultGroupId; import org.onosproject.incubator.net.tunnel.DefaultOpticalTunnelEndPoint; import org.onosproject.incubator.net.tunnel.DefaultTunnel; import org.onosproject.incubator.net.tunnel.DefaultTunnelDescription; import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint; +import org.onosproject.incubator.net.tunnel.DefaultTunnelStatistics; import org.onosproject.incubator.net.tunnel.OpticalLogicId; import org.onosproject.incubator.net.tunnel.OpticalTunnelEndPoint; import org.onosproject.incubator.net.tunnel.Tunnel; @@ -52,6 +59,8 @@ import org.onosproject.incubator.net.tunnel.TunnelName; import org.onosproject.incubator.net.tunnel.TunnelProvider; import org.onosproject.incubator.net.tunnel.TunnelProviderRegistry; import org.onosproject.incubator.net.tunnel.TunnelProviderService; +import org.onosproject.incubator.net.tunnel.TunnelService; +import org.onosproject.incubator.net.tunnel.TunnelStatistics; import org.onosproject.net.ConnectPoint; import org.onosproject.net.DefaultAnnotations; import org.onosproject.net.DefaultLink; @@ -73,6 +82,8 @@ import org.onosproject.pcep.api.PcepTunnel; import org.onosproject.pcep.api.PcepTunnel.PATHTYPE; import org.onosproject.pcep.api.PcepTunnel.PathState; import org.onosproject.pcep.api.PcepTunnelListener; +import org.onosproject.pcep.api.PcepTunnelStatistics; +import org.osgi.service.component.annotations.Modified; import org.onosproject.pcep.controller.PccId; import org.onosproject.pcep.controller.PcepClient; import org.onosproject.pcep.controller.PcepClientController; @@ -99,8 +110,7 @@ import org.onosproject.pcepio.types.PcepValueType; import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv; import org.onosproject.pcepio.types.SymbolicPathNameTlv; import org.slf4j.Logger; - -import static org.onosproject.pcep.api.PcepDpid.*; +import org.osgi.service.component.ComponentContext; /** * Provider which uses an PCEP controller to detect, update, create network @@ -116,6 +126,11 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid private static final String BANDWIDTH_UINT = "kbps"; static final String PROVIDER_ID = "org.onosproject.provider.tunnel.pcep"; + static final int POLL_INTERVAL = 10; + @Property(name = "tunnelStatsPollFrequency", intValue = POLL_INTERVAL, + label = "Frequency (in seconds) for polling tunnel statistics") + private int tunnelStatsPollFrequency = POLL_INTERVAL; + private static final String TUNNLE_NOT_NULL = "Create failed,The given port may be wrong or has been occupied."; @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) @@ -126,9 +141,18 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) protected PcepClientController pcepClientController; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected TunnelService tunnelService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected ComponentConfigService cfgService; + TunnelProviderService service; HashMap tunnelMap = new HashMap(); + HashMap tunnelStatisticsMap = new HashMap<>(); + private HashMap collectors = Maps.newHashMap(); private InnerTunnelProvider listener = new InnerTunnelProvider(); @@ -144,10 +168,19 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid @Activate public void activate() { + cfgService.registerProperties(getClass()); service = tunnelProviderRegistry.register(this); controller.addTunnelListener(listener); pcepClientController.addListener(listener); pcepClientController.addEventListener(listener); + tunnelService.queryAllTunnels().forEach(tunnel -> { + String pcepTunnelId = getPCEPTunnelKey(tunnel.tunnelId()); + TunnelStatsCollector tsc = new TunnelStatsCollector(pcepTunnelId, tunnelStatsPollFrequency); + tsc.start(); + collectors.put(tunnel.tunnelId().id(), tsc); + + }); + log.info("Started"); } @@ -155,10 +188,31 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid public void deactivate() { tunnelProviderRegistry.unregister(this); controller.removeTunnelListener(listener); + collectors.values().forEach(TunnelStatsCollector::stop); pcepClientController.removeListener(listener); log.info("Stopped"); } + @Modified + public void modified(ComponentContext context) { + Dictionary properties = context.getProperties(); + int newTunnelStatsPollFrequency; + try { + String s = get(properties, "tunnelStatsPollFrequency"); + newTunnelStatsPollFrequency = isNullOrEmpty(s) ? tunnelStatsPollFrequency : Integer.parseInt(s.trim()); + + } catch (NumberFormatException | ClassCastException e) { + newTunnelStatsPollFrequency = tunnelStatsPollFrequency; + } + + if (newTunnelStatsPollFrequency != tunnelStatsPollFrequency) { + tunnelStatsPollFrequency = newTunnelStatsPollFrequency; + collectors.values().forEach(tsc -> tsc.adjustPollInterval(tunnelStatsPollFrequency)); + log.info("New setting: tunnelStatsPollFrequency={}", tunnelStatsPollFrequency); + } + + } + @Override public void setupTunnel(Tunnel tunnel, Path path) { if (tunnel.type() != Tunnel.Type.MPLS) { @@ -177,7 +231,7 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid if (!(pc instanceof PcepClient)) { log.error("There is no PCC connected with ip addresss {}" - + ((IpTunnelEndPoint) tunnel.src()).ip().toString()); + + ((IpTunnelEndPoint) tunnel.src()).ip().toString()); return; } pcepSetupTunnel(tunnel, path, pc); @@ -580,6 +634,21 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid } + /** + * Build a DefaultTunnelStatistics from a PcepTunnelStatistics. + * + * @param statistics statistics data from a PCEP tunnel + * @return TunnelStatistics + */ + private TunnelStatistics buildTunnelStatistics(PcepTunnelStatistics statistics) { + DefaultTunnelStatistics.Builder builder = new DefaultTunnelStatistics.Builder(); + DefaultTunnelStatistics tunnelStatistics = builder.setBwUtilization(statistics.bandwidthUtilization()) + .setPacketLossRatio(statistics.packetLossRate()) + .setFlowDelay(statistics.flowDelay()) + .setAlarms(statistics.alarms()) + .build(); + return tunnelStatistics; + } /** * Creates list of hops for ERO object from Path. * @@ -844,6 +913,8 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid } } + + private class InnerTunnelProvider implements PcepTunnelListener, PcepEventListener, PcepClientListener { @Override @@ -1141,6 +1212,15 @@ public class PcepTunnelProvider extends AbstractProvider implements TunnelProvid public void clientDisconnected(PccId pccId) { // TODO } + + + + @Override + public void handlePcepTunnelStatistics(PcepTunnelStatistics pcepTunnelStatistics) { + TunnelId id = getTunnelId(String.valueOf(pcepTunnelStatistics.id())); + TunnelStatistics tunnelStatistics = buildTunnelStatistics(pcepTunnelStatistics); + tunnelStatisticsMap.put(id, tunnelStatistics); + } } @Override diff --git a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java new file mode 100644 index 0000000000..39249c5c6e --- /dev/null +++ b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java @@ -0,0 +1,104 @@ +/* + * + * * Copyright 2014-2015 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.provider.pcep.tunnel.impl; + + +import org.apache.felix.scr.annotations.Reference; +import org.apache.felix.scr.annotations.ReferenceCardinality; +import org.jboss.netty.util.HashedWheelTimer; +import org.jboss.netty.util.Timeout; +import org.jboss.netty.util.TimerTask; +import org.onlab.util.Timer; +import org.onosproject.pcep.api.PcepController; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.TimeUnit; + +/* + * Sends Stats Request and collect the tunnel statistics with a time interval. + */ +public class TunnelStatsCollector implements TimerTask { + private final Logger log = LoggerFactory.getLogger(getClass()); + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected PcepController controller; + + private int refreshInterval; + private final HashedWheelTimer timer = Timer.getTimer(); + + private String pcepTunnelId; + private Timeout timeout; + private volatile boolean stopped; + + + /** + * Greate a tunnel status collector object. + * + * @param id tunnel whose status data will be collected + * @param refreshInterval time interval for collecting statistic + */ + public TunnelStatsCollector(String id, int refreshInterval) { + this.pcepTunnelId = id; + this.refreshInterval = refreshInterval; + } + + @Override + public void run(Timeout timeout) throws Exception { + if (stopped || timeout.isCancelled()) { + return; + } + log.trace("Collecting stats for {}", pcepTunnelId); + + sendTunnelStatistic(); + if (!stopped && !timeout.isCancelled()) { + log.trace("Scheduling stats collection in {} seconds for {}", + this.refreshInterval, pcepTunnelId); + timeout.getTimer().newTimeout(this, refreshInterval, TimeUnit.SECONDS); + } + + } + + private void sendTunnelStatistic() { + controller.getTunnelStatistics(pcepTunnelId); + + } + + synchronized void adjustPollInterval(int pollInterval) { + this.refreshInterval = pollInterval; + } + + /** + * Starts the collector. + */ + public synchronized void start() { + log.info("Starting Tunnel Stats collection thread for {}", pcepTunnelId); + stopped = false; + timeout = timer.newTimeout(this, 1, TimeUnit.SECONDS); + } + + /** + * Stops the collector. + */ + public synchronized void stop() { + log.info("Stopping Tunnel Stats collection thread for {}", pcepTunnelId); + stopped = true; + timeout.cancel(); + } +} diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepControllerAdapter.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepControllerAdapter.java index 6aa81f702b..6526611621 100644 --- a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepControllerAdapter.java +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepControllerAdapter.java @@ -77,4 +77,9 @@ public class PcepControllerAdapter implements PcepController { public Boolean updateTunnelBandwidth(String id, long bandwidth) { return null; } + + @Override + public void getTunnelStatistics(String pcepTunnelId) { + + } } diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepReleaseTunnelProviderTest.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepReleaseTunnelProviderTest.java index c728aad9cd..e386138189 100644 --- a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepReleaseTunnelProviderTest.java +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepReleaseTunnelProviderTest.java @@ -24,6 +24,7 @@ import java.util.List; import org.junit.After; import org.junit.Test; import org.onlab.packet.IpAddress; +import org.onosproject.cfg.ComponentConfigAdapter; import org.onosproject.core.DefaultGroupId; import org.onosproject.incubator.net.tunnel.DefaultTunnel; import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint; @@ -49,13 +50,16 @@ public class PcepReleaseTunnelProviderTest { private final PcepClientControllerAdapter controller = new PcepClientControllerAdapter(); private final PcepControllerAdapter ctl = new PcepControllerAdapter(); private final PcepTunnelApiMapper pcepTunnelAPIMapper = new PcepTunnelApiMapper(); + private final TunnelServiceAdapter tunnelService = new TunnelServiceAdapter(); @Test public void testCasePcepReleaseTunnel() { tunnelProvider.tunnelProviderRegistry = registry; tunnelProvider.pcepClientController = controller; tunnelProvider.controller = ctl; + tunnelProvider.tunnelService = tunnelService; tunnelProvider.pcepTunnelAPIMapper = pcepTunnelAPIMapper; + tunnelProvider.cfgService = new ComponentConfigAdapter(); tunnelProvider.activate(); Tunnel tunnel; diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepSetupTunnelProviderTest.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepSetupTunnelProviderTest.java index e419e22e99..ef4816ec31 100644 --- a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepSetupTunnelProviderTest.java +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepSetupTunnelProviderTest.java @@ -24,6 +24,7 @@ import java.util.List; import org.junit.After; import org.junit.Test; import org.onlab.packet.IpAddress; +import org.onosproject.cfg.ComponentConfigAdapter; import org.onosproject.core.DefaultGroupId; import org.onosproject.incubator.net.tunnel.DefaultTunnel; import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint; @@ -46,6 +47,7 @@ public class PcepSetupTunnelProviderTest { private final TunnelProviderRegistryAdapter registry = new TunnelProviderRegistryAdapter(); private final PcepClientControllerAdapter controller = new PcepClientControllerAdapter(); private final PcepControllerAdapter ctl = new PcepControllerAdapter(); + private final TunnelServiceAdapter tunnelService = new TunnelServiceAdapter(); @Test public void testCasePcepSetupTunnel() { @@ -53,6 +55,8 @@ public class PcepSetupTunnelProviderTest { tunnelProvider.tunnelProviderRegistry = registry; tunnelProvider.pcepClientController = controller; tunnelProvider.controller = ctl; + tunnelProvider.cfgService = new ComponentConfigAdapter(); + tunnelProvider.tunnelService = tunnelService; tunnelProvider.activate(); diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProviderTest.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProviderTest.java index 7a61bb2d8c..0fcd144766 100644 --- a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProviderTest.java +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProviderTest.java @@ -38,6 +38,7 @@ import org.onosproject.net.Link; import org.onosproject.net.Path; import org.onosproject.net.PortNumber; import org.onosproject.net.provider.ProviderId; +import org.onosproject.cfg.ComponentConfigAdapter; public class PcepTunnelProviderTest { @@ -46,6 +47,7 @@ public class PcepTunnelProviderTest { private final TunnelProviderRegistryAdapter registry = new TunnelProviderRegistryAdapter(); private final PcepClientControllerAdapter controller = new PcepClientControllerAdapter(); private final PcepControllerAdapter ctl = new PcepControllerAdapter(); + private final TunnelServiceAdapter tunnelService = new TunnelServiceAdapter(); @Test public void testCasePcepSetupTunnel() { @@ -53,6 +55,8 @@ public class PcepTunnelProviderTest { tunnelProvider.tunnelProviderRegistry = registry; tunnelProvider.pcepClientController = controller; tunnelProvider.controller = ctl; + tunnelProvider.cfgService = new ComponentConfigAdapter(); + tunnelProvider.tunnelService = tunnelService; tunnelProvider.activate(); Tunnel tunnel; diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepUpdateTunnelProviderTest.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepUpdateTunnelProviderTest.java index a27ba764c6..1bcf99dd2b 100644 --- a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepUpdateTunnelProviderTest.java +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/PcepUpdateTunnelProviderTest.java @@ -24,6 +24,7 @@ import java.util.List; import org.junit.After; import org.junit.Test; import org.onlab.packet.IpAddress; +import org.onosproject.cfg.ComponentConfigAdapter; import org.onosproject.core.DefaultGroupId; import org.onosproject.incubator.net.tunnel.DefaultTunnel; import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint; @@ -49,6 +50,8 @@ public class PcepUpdateTunnelProviderTest { private final PcepClientControllerAdapter controller = new PcepClientControllerAdapter(); private final PcepControllerAdapter ctl = new PcepControllerAdapter(); private final PcepTunnelApiMapper pcepTunnelAPIMapper = new PcepTunnelApiMapper(); + private final TunnelServiceAdapter tunnelService = new TunnelServiceAdapter(); + @Test public void testCasePcepUpdateTunnel() { @@ -56,6 +59,8 @@ public class PcepUpdateTunnelProviderTest { tunnelProvider.pcepClientController = controller; tunnelProvider.controller = ctl; tunnelProvider.pcepTunnelAPIMapper = pcepTunnelAPIMapper; + tunnelProvider.cfgService = new ComponentConfigAdapter(); + tunnelProvider.tunnelService = tunnelService; tunnelProvider.activate(); Tunnel tunnel; diff --git a/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/TunnelServiceAdapter.java b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/TunnelServiceAdapter.java new file mode 100644 index 0000000000..1dd77332bb --- /dev/null +++ b/providers/pcep/tunnel/src/test/java/org/onosproject/provider/pcep/tunnel/impl/TunnelServiceAdapter.java @@ -0,0 +1,107 @@ +package org.onosproject.provider.pcep.tunnel.impl; + +import org.onosproject.core.ApplicationId; +import org.onosproject.incubator.net.tunnel.Tunnel; +import org.onosproject.incubator.net.tunnel.TunnelEndPoint; +import org.onosproject.incubator.net.tunnel.TunnelId; +import org.onosproject.incubator.net.tunnel.TunnelListener; +import org.onosproject.incubator.net.tunnel.TunnelName; +import org.onosproject.incubator.net.tunnel.TunnelService; +import org.onosproject.incubator.net.tunnel.TunnelSubscription; +import org.onosproject.net.Annotations; +import org.onosproject.net.DeviceId; + +import java.util.Collection; +import java.util.Collections; + +public class TunnelServiceAdapter implements TunnelService { + @Override + public Tunnel borrowTunnel(ApplicationId consumerId, TunnelId tunnelId, Annotations... annotations) { + return null; + } + + @Override + public Collection borrowTunnel(ApplicationId consumerId, TunnelName tunnelName, + Annotations... annotations) { + return null; + } + + @Override + public Collection borrowTunnel(ApplicationId consumerId, TunnelEndPoint src, TunnelEndPoint dst, + Annotations... annotations) { + return null; + } + + @Override + public Collection borrowTunnel(ApplicationId consumerId, TunnelEndPoint src, TunnelEndPoint dst, + Tunnel.Type type, Annotations... annotations) { + return null; + } + + @Override + public boolean returnTunnel(ApplicationId consumerId, TunnelId tunnelId, Annotations... annotations) { + return false; + } + + @Override + public boolean returnTunnel(ApplicationId consumerId, TunnelName tunnelName, Annotations... annotations) { + return false; + } + + @Override + public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src, TunnelEndPoint dst, + Tunnel.Type type, Annotations... annotations) { + return false; + } + + @Override + public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src, TunnelEndPoint dst, + Annotations... annotations) { + return false; + } + + @Override + public Tunnel queryTunnel(TunnelId tunnelId) { + return null; + } + + @Override + public Collection queryTunnelSubscription(ApplicationId consumerId) { + return null; + } + + @Override + public Collection queryTunnel(Tunnel.Type type) { + return null; + } + + @Override + public Collection queryTunnel(TunnelEndPoint src, TunnelEndPoint dst) { + return null; + } + + @Override + public Collection queryAllTunnels() { + return Collections.emptyList(); + } + + @Override + public int tunnelCount() { + return 0; + } + + @Override + public Iterable getTunnels(DeviceId deviceId) { + return null; + } + + @Override + public void addListener(TunnelListener listener) { + + } + + @Override + public void removeListener(TunnelListener listener) { + + } +}