홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
jcc
Committed by Brian O'Connor
d8697235 1 parent 4a20a5f2

[ONOS-1284][ONOS-1869]the implementation of tunnel subsystem.It includes 

test
commands, store, service. the store use eventually consistent.

Change-Id: Id54224ff65f3f2fa0a1d7adb072a2fe664987d18
Inline Side-by-side
Showing 17 changed files with 1821 additions and 154 deletions
/*
* 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.cli.net;
import java.util.Collection;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplicationId;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelService;
/**
* Borrows all tunnels between specific source tunnel end point and specific
* destination tunnel end point. Supports for IP address and optical as tunnel end point now. It's used by consumers.
*/
@Command(scope = "onos", name = "borrow-tunnels",
description = "Borrows all tunnels between specific source tunnel end point"
+ " and specific destination tunnel end point."
+ " Supports for IP address and optical as tunnel end point now. It's used by consumers.")
public class BorrowTunnelCommand extends AbstractShellCommand {
@Argument(index = 0, name = "consumerId", description = "consumer id means application id.",
required = true, multiValued = false)
String consumerId = null;
@Argument(index = 1, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 2, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 3, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
private static final String FMT = "src=%s, dst=%s,"
+ "type=%s, state=%s, producerName=%s, tunnelName=%s,"
+ "groupId=%s";
@Override
protected void execute() {
TunnelService service = get(TunnelService.class);
ApplicationId appId = new DefaultApplicationId(1, consumerId);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
if ("MPLS".equals(type) || "VLAN".equals(type) || "VXLAN".equals(type)
|| "GRE".equals(type)) {
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type) || "OCH".equals(type)) {
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
Collection<Tunnel> tunnelSet = service.borrowTunnel(appId, srcPoint, dstPoint);
for (Tunnel tunnel : tunnelSet) {
print(FMT, tunnel.src(), tunnel.dst(), tunnel.type(),
tunnel.state(), tunnel.providerId(), tunnel.tunnelName(),
tunnel.groupId());
}
}
}
/*
* 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.cli.net;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.TunnelAdminService;
import org.onosproject.net.tunnel.TunnelEndPoint;
/**
* Supports for deleting all tunnels by using IP address and optical as tunnel
* end point now. It's used by consumers.
*/
@Command(scope = "onos", name = "delete-tunnels", description = "Supports for deleting all tunnels by using IP address"
+ " and optical as tunnel end point now. It's used by consumers.")
public class DeleteTunnelCommand extends AbstractShellCommand {
static String applicationId = "DEFAULT_APP_ID";
@Argument(index = 0, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 1, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 2, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
@Override
protected void execute() {
TunnelAdminService adminService = get(TunnelAdminService.class);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
if ("MPLS".equals(type) || "VLAN".equals(type) || "VXLAN".equals(type) || "GRE".equals(type)) {
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type) || "OCH".equals(type)) {
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
adminService.removeTunnels(srcPoint, dstPoint, producerName);
}
}
/*
* 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.cli.net;
import java.util.Collection;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelService;
/**
* Supports for querying all tunnels by using IP address and optical as tunnel
* end point now. It's used by consumers.
*/
@Command(scope = "onos", name = "query-tunnels", description = "Supports for querying all tunnels by using IP address"
+ " and optical as tunnel end point now."
+ " It's used by consumers.")
public class QueryTunnelCommand extends AbstractShellCommand {
@Argument(index = 0, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 1, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 2, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
private static final String FMT = "src=%s, dst=%s,"
+ "type=%s, state=%s, producerName=%s, tunnelName=%s,"
+ "groupId=%s";
@Override
protected void execute() {
TunnelService service = get(TunnelService.class);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
if ("MPLS".equals(type) || "VLAN".equals(type) || "VXLAN".equals(type)
|| "GRE".equals(type)) {
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type) || "OCH".equals(type)) {
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
Collection<Tunnel> tunnelSet = service.queryTunnel(srcPoint, dstPoint);
for (Tunnel tunnel : tunnelSet) {
print(FMT, tunnel.src().toString(), tunnel.dst().toString(), tunnel.type(),
tunnel.state(), tunnel.providerId(), tunnel.tunnelName(),
tunnel.groupId());
}
}
}
/*
* 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.cli.net;
import java.util.Collection;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplicationId;
import org.onosproject.net.tunnel.TunnelService;
import org.onosproject.net.tunnel.TunnelSubscription;
/**
* Query all tunnel subscriptions of consumer by consumer id.
* It's used by consumers.
*/
@Command(scope = "onos", name = "query-tunnel-subscriptions",
description = "Query all request orders of consumer by consumer id. It's used by consumers.")
public class QueryTunnelSubscriptionCommand extends AbstractShellCommand {
@Argument(index = 0, name = "consumerId",
description = "consumer id means provider id",
required = true, multiValued = false)
String consumerId = null;
private static final String FMT = "appId=%s, src=%s, dst=%s,"
+ "type=%s, tunnelId=%s";
@Override
protected void execute() {
TunnelService service = get(TunnelService.class);
ApplicationId applicationId = new DefaultApplicationId(1, consumerId);
Collection<TunnelSubscription> tunnelSet = service.queryTunnelSubscription(applicationId);
for (TunnelSubscription order : tunnelSet) {
print(FMT, order.consumerId(), order.src(), order.dst(),
order.type(), order.tunnelId());
}
}
}
/*
* 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.cli.net;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplicationId;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelService;
/**
* Returns all tunnels between specific source tunnel end point and specific
* destination tunnel end point. Supports for IP address and optical as tunnel
* end point now. It's used by consumers.
*/
@Command(scope = "onos", name = "return-tunnels",
description = "Returns all tunnels between specific source tunnel end point and specific "
+ " destination tunnel end point. Supports for IP address and optical as tunnel end point now."
+ " It's used by consumers.")
public class ReturnTunnelCommand extends AbstractShellCommand {
@Argument(index = 0, name = "consumerId", description = "consumer id means application id.",
required = true, multiValued = false)
String consumerId = null;
@Argument(index = 1, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 2, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 3, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
@Override
protected void execute() {
TunnelService service = get(TunnelService.class);
ApplicationId appId = new DefaultApplicationId(1, consumerId);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
if ("MPLS".equals(type) || "VLAN".equals(type) || "VXLAN".equals(type)
|| "GRE".equals(type)) {
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type) || "OCH".equals(type)) {
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
service.returnTunnel(appId, srcPoint, dstPoint);
}
}
......@@ -367,6 +367,22 @@
<command>
<action class="org.onosproject.cli.net.ApplyLabelResourceCommand"/>
</command>
<!-- tunnel commands -->
<command>
<action class="org.onosproject.cli.net.DeleteTunnelCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.BorrowTunnelCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.ReturnTunnelCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.QueryTunnelCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.QueryTunnelSubscriptionCommand"/>
</command>
</command-bundle>
<bean id="permAppNameCompleter" class="org.onosproject.cli.security.PermissionApplicationNameCompleter"/>
......
......@@ -15,11 +15,11 @@
*/
package org.onosproject.net.tunnel.impl;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.slf4j.LoggerFactory.getLogger;
import java.util.Collection;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
......@@ -28,16 +28,14 @@ import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.event.EventDeliveryService;
import org.onosproject.event.ListenerRegistry;
import org.onosproject.net.Annotations;
import org.onosproject.net.Path;
import org.onosproject.net.link.LinkEvent;
import org.onosproject.net.link.LinkListener;
import org.onosproject.net.provider.AbstractProviderRegistry;
import org.onosproject.net.provider.AbstractProviderService;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultTunnel;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.Tunnel.Type;
import org.onosproject.net.tunnel.TunnelAdminService;
......@@ -73,8 +71,7 @@ public class TunnelManager
listenerRegistry = new ListenerRegistry<>();
private final TunnelStoreDelegate delegate = new InternalStoreDelegate();
private final InternalTunnelListener tunnelListener = new InternalTunnelListener();
private InternalLinkListener linkListener = new InternalLinkListener();
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected TunnelStore store;
......@@ -82,229 +79,279 @@ public class TunnelManager
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected EventDeliveryService eventDispatcher;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected CoreService coreService;
private ExecutorService futureService;
@Activate
public void activate() {
// TODO Auto-generated method stub
store.setDelegate(delegate);
eventDispatcher.addSink(TunnelEvent.class, listenerRegistry);
log.info("Started");
}
@Deactivate
public void deactivate() {
// TODO Auto-generated method stub
store.unsetDelegate(delegate);
eventDispatcher.removeSink(TunnelEvent.class);
log.info("Stopped");
}
@Override
protected TunnelProviderService createProviderService(TunnelProvider provider) {
// TODO Auto-generated method stub
return new InternalTunnelProviderService(provider);
}
@Override
public TunnelProviderService register(TunnelProvider provider) {
// TODO Auto-generated method stub
return null;
}
@Override
public void unregister(TunnelProvider provider) {
// TODO Auto-generated method stub
}
@Override
public Set<ProviderId> getProviders() {
// TODO Auto-generated method stub
return null;
}
@Override
public void addListener(TunnelListener listener) {
// TODO Auto-generated method stub
}
@Override
public void removeListener(TunnelListener listener) {
// TODO Auto-generated method stub
}
private class InternalTunnelListener implements TunnelListener {
@Override
public void event(TunnelEvent event) {
// TODO Auto-generated method stub
}
}
private class InternalLinkListener implements LinkListener {
@Override
public void event(LinkEvent event) {
// TODO Auto-generated method stub
}
}
private class InternalTunnelProviderService
extends AbstractProviderService<TunnelProvider>
implements TunnelProviderService {
protected InternalTunnelProviderService(TunnelProvider provider) {
super(provider);
// TODO Auto-generated constructor stub
}
@Override
public TunnelId tunnelAdded(TunnelDescription tunnel) {
// TODO Auto-generated method stub
return null;
}
@Override
public void tunnelUpdated(TunnelDescription tunnel) {
// TODO Auto-generated method stub
}
@Override
public void tunnelRemoved(TunnelDescription tunnel) {
// TODO Auto-generated method stub
}
}
private class InternalStoreDelegate implements TunnelStoreDelegate {
@Override
public void notify(TunnelEvent event) {
// TODO Auto-generated method stub
if (event != null) {
eventDispatcher.post(event);
public void removeTunnel(TunnelId tunnelId) {
checkNotNull(tunnelId, TUNNNEL_ID_NULL);
store.deleteTunnel(tunnelId);
Tunnel tunnel = store.queryTunnel(tunnelId);
if (tunnel.providerId() != null) {
TunnelProvider provider = getProvider(tunnel.providerId());
if (provider != null) {
provider.releaseTunnel(tunnel);
}
} else {
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.releaseTunnel(tunnel);
}
}
}
@Override
public void removeTunnel(TunnelId tunnelId) {
// TODO Auto-generated method stub
public void updateTunnel(Tunnel tunnel, Path path) {
store.createOrUpdateTunnel(tunnel);
if (tunnel.providerId() != null) {
TunnelProvider provider = getProvider(tunnel.providerId());
if (provider != null) {
provider.updateTunnel(tunnel, path);
}
} else {
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.updateTunnel(tunnel, path);
}
}
}
@Override
public void removeTunnels(TunnelEndPoint src, TunnelEndPoint dst,
ProviderId producerName) {
// TODO Auto-generated method stub
}
@Override
public void removeTunnels(TunnelEndPoint src, TunnelEndPoint dst,
Type type, ProviderId producerName) {
// TODO Auto-generated method stub
store.deleteTunnel(src, dst, producerName);
Collection<Tunnel> setTunnels = store.queryTunnel(src, dst);
for (Tunnel tunnel : setTunnels) {
if (producerName != null
&& !tunnel.providerId().equals(producerName)) {
continue;
}
if (tunnel.providerId() != null) {
TunnelProvider provider = getProvider(tunnel.providerId());
if (provider != null) {
provider.releaseTunnel(tunnel);
}
} else {
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.releaseTunnel(tunnel);
}
}
}
}
@Override
public void updateTunnel(Tunnel tunnel, Path path) {
// TODO Auto-generated method stub
public void removeTunnels(TunnelEndPoint src, TunnelEndPoint dst, Type type,
ProviderId producerName) {
store.deleteTunnel(src, dst, type, producerName);
Collection<Tunnel> setTunnels = store.queryTunnel(src, dst);
for (Tunnel tunnel : setTunnels) {
if (producerName != null
&& !tunnel.providerId().equals(producerName)
|| !type.equals(tunnel.type())) {
continue;
}
if (tunnel.providerId() != null) {
TunnelProvider provider = getProvider(tunnel.providerId());
if (provider != null) {
provider.releaseTunnel(tunnel);
}
} else {
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.releaseTunnel(tunnel);
}
}
}
}
@Override
public Tunnel borrowTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations) {
// TODO Auto-generated method stub
return null;
Annotations... annotations) {
return store.borrowTunnel(consumerId, tunnelId, annotations);
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
TunnelName tunnelName,
Annotations... annotations) {
// TODO Auto-generated method stub
return null;
TunnelName tunnelName,
Annotations... annotations) {
return store.borrowTunnel(consumerId, tunnelName, annotations);
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
TunnelEndPoint src,
TunnelEndPoint dst,
Annotations... annotations) {
// TODO Auto-generated method stub
return null;
TunnelEndPoint src, TunnelEndPoint dst,
Annotations... annotations) {
Collection<Tunnel> tunnels = store.borrowTunnel(consumerId, src,
dst, annotations);
if (tunnels == null || tunnels.size() == 0) {
Tunnel tunnel = new DefaultTunnel(null, src, dst, null, null, null,
null, null, annotations);
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.setupTunnel(tunnel, null);
}
}
return tunnels;
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations) {
// TODO Auto-generated method stub
return null;
TunnelEndPoint src, TunnelEndPoint dst,
Type type, Annotations... annotations) {
Collection<Tunnel> tunnels = store.borrowTunnel(consumerId, src,
dst, type,
annotations);
if (tunnels == null || tunnels.size() == 0) {
Tunnel tunnel = new DefaultTunnel(null, src, dst, type, null, null,
null, null, annotations);
Set<ProviderId> ids = getProviders();
for (ProviderId providerId : ids) {
TunnelProvider provider = getProvider(providerId);
provider.setupTunnel(tunnel, null);
}
}
return tunnels;
}
@Override
public boolean returnTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations) {
// TODO Auto-generated method stub
return false;
public boolean returnTunnel(ApplicationId consumerId,
TunnelId tunnelId, Annotations... annotations) {
return store.returnTunnel(consumerId, tunnelId, annotations);
}
@Override
public boolean returnTunnel(ApplicationId consumerId,
TunnelName tunnelName, Annotations... annotations) {
// TODO Auto-generated method stub
return false;
TunnelName tunnelName,
Annotations... annotations) {
return store.returnTunnel(consumerId, tunnelName, annotations);
}
@Override
public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations) {
// TODO Auto-generated method stub
return false;
TunnelEndPoint dst, Type type,
Annotations... annotations) {
return store.returnTunnel(consumerId, src, dst, type, annotations);
}
@Override
public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations) {
// TODO Auto-generated method stub
return false;
TunnelEndPoint dst, Annotations... annotations) {
return store.returnTunnel(consumerId, src, dst, annotations);
}
@Override
public Tunnel queryTunnel(TunnelId tunnelId) {
// TODO Auto-generated method stub
return null;
return store.queryTunnel(tunnelId);
}
@Override
public Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId consumerId) {
// TODO Auto-generated method stub
return null;
return store.queryTunnelSubscription(consumerId);
}
@Override
public Collection<Tunnel> queryTunnel(Type type) {
// TODO Auto-generated method stub
return null;
return store.queryTunnel(type);
}
@Override
public Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst) {
// TODO Auto-generated method stub
return null;
return store.queryTunnel(src, dst);
}
@Override
public int tunnelCount() {
// TODO Auto-generated method stub
return 0;
return store.tunnelCount();
}
@Override
protected TunnelProviderService createProviderService(TunnelProvider provider) {
return new InternalTunnelProviderService(provider);
}
@Override
public void addListener(TunnelListener listener) {
listenerRegistry.addListener(listener);
}
@Override
public void removeListener(TunnelListener listener) {
listenerRegistry.removeListener(listener);
}
private class InternalTunnelProviderService
extends AbstractProviderService<TunnelProvider>
implements TunnelProviderService {
protected InternalTunnelProviderService(TunnelProvider provider) {
super(provider);
}
@Override
public TunnelId tunnelAdded(TunnelDescription tunnel) {
Tunnel storedTunnel = new DefaultTunnel(provider().id(),
tunnel.src(), tunnel.dst(),
tunnel.type(),
tunnel.groupId(),
tunnel.id(),
tunnel.tunnelName(),
tunnel.annotations());
return store.createOrUpdateTunnel(storedTunnel);
}
@Override
public void tunnelUpdated(TunnelDescription tunnel) {
Tunnel storedTunnel = new DefaultTunnel(provider().id(),
tunnel.src(), tunnel.dst(),
tunnel.type(),
tunnel.groupId(),
tunnel.id(),
tunnel.tunnelName(),
tunnel.annotations());
store.createOrUpdateTunnel(storedTunnel);
}
@Override
public void tunnelRemoved(TunnelDescription tunnel) {
if (tunnel.id() != null) {
store.deleteTunnel(tunnel.id());
}
if (tunnel.src() != null && tunnel.dst() != null
&& tunnel.type() != null) {
store.deleteTunnel(tunnel.src(), tunnel.dst(), tunnel.type(),
provider().id());
}
if (tunnel.src() != null && tunnel.dst() != null
&& tunnel.type() == null) {
store.deleteTunnel(tunnel.src(), tunnel.dst(), provider().id());
}
}
}
private class InternalStoreDelegate implements TunnelStoreDelegate {
@Override
public void notify(TunnelEvent event) {
if (event != null) {
eventDispatcher.post(event);
}
}
}
}
......
package org.onosproject.store.tunnel.impl;
import static org.slf4j.LoggerFactory.getLogger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
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.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onlab.util.KryoNamespace;
import org.onosproject.cluster.ClusterService;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.core.IdGenerator;
import org.onosproject.net.Annotations;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultTunnel;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.Tunnel.Type;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelEvent;
import org.onosproject.net.tunnel.TunnelId;
import org.onosproject.net.tunnel.TunnelName;
import org.onosproject.net.tunnel.TunnelStore;
import org.onosproject.net.tunnel.TunnelStoreDelegate;
import org.onosproject.net.tunnel.TunnelSubscription;
import org.onosproject.store.AbstractStore;
import org.onosproject.store.app.GossipApplicationStore.InternalState;
import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
import org.onosproject.store.serializers.KryoNamespaces;
import org.onosproject.store.service.EventuallyConsistentMap;
import org.onosproject.store.service.MultiValuedTimestamp;
import org.onosproject.store.service.StorageService;
import org.onosproject.store.service.WallclockClockManager;
import org.slf4j.Logger;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
/**
* Manages inventory of tunnel in distributed data store that uses optimistic
* replication and gossip based techniques.
*/
@Component(immediate = true)
@Service
public class DistributedTunnelStore
extends AbstractStore<TunnelEvent, TunnelStoreDelegate>
implements TunnelStore {
private final Logger log = getLogger(getClass());
/**
* The topic used for obtaining globally unique ids.
*/
private String runnelOpTopoic = "tunnel-ops-ids";
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ClusterCommunicationService clusterCommunicator;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ClusterService clusterService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected CoreService coreService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected StorageService storageService;
// tunnel identity as map key in the store.
private EventuallyConsistentMap<TunnelId, Tunnel> tunnelIdAsKeyStore;
// tunnel name as map key in the store.
private EventuallyConsistentMap<TunnelName, Set<TunnelId>> tunnelNameAsKeyStore;
// maintains all the tunnels between source and destination.
private EventuallyConsistentMap<TunnelKey, Set<TunnelId>> srcAndDstKeyStore;
// maintains all the tunnels by tunnel type.
private EventuallyConsistentMap<Tunnel.Type, Set<TunnelId>> typeKeyStore;
// maintains records that app subscribes tunnel.
private EventuallyConsistentMap<ApplicationId, Set<TunnelSubscription>> orderRelationship;
private IdGenerator idGenerator;
@Activate
public void activate() {
KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
.register(KryoNamespaces.API)
.register(MultiValuedTimestamp.class)
.register(InternalState.class);
tunnelIdAsKeyStore = storageService
.<TunnelId, Tunnel>eventuallyConsistentMapBuilder()
.withName("all_tunnel").withSerializer(serializer)
.withClockService(new WallclockClockManager<>()).build();
tunnelNameAsKeyStore = storageService
.<TunnelName, Set<TunnelId>>eventuallyConsistentMapBuilder()
.withName("tunnel_name_tunnel").withSerializer(serializer)
.withClockService(new WallclockClockManager<>()).build();
srcAndDstKeyStore = storageService
.<TunnelKey, Set<TunnelId>>eventuallyConsistentMapBuilder()
.withName("src_dst_tunnel").withSerializer(serializer)
.withClockService(new WallclockClockManager<>()).build();
typeKeyStore = storageService
.<Tunnel.Type, Set<TunnelId>>eventuallyConsistentMapBuilder()
.withName("type_tunnel").withSerializer(serializer)
.withClockService(new WallclockClockManager<>()).build();
idGenerator = coreService.getIdGenerator(runnelOpTopoic);
log.info("Started");
}
@Deactivate
public void deactivate() {
tunnelIdAsKeyStore.destroy();
srcAndDstKeyStore.destroy();
typeKeyStore.destroy();
tunnelNameAsKeyStore.destroy();
log.info("Stopped");
}
@Override
public TunnelId createOrUpdateTunnel(Tunnel tunnel) {
// tunnelIdAsKeyStore.
if (tunnel.tunnelId() != null && !"".equals(tunnel.tunnelId())) {
Tunnel old = tunnelIdAsKeyStore.get(tunnel.tunnelId());
if (old == null) {
log.info("This tunnel[" + tunnel.tunnelId() + "] is not available.");
return tunnel.tunnelId();
}
Tunnel newT = new DefaultTunnel(tunnel.providerId(), tunnel.src(),
tunnel.dst(), tunnel.type(),
tunnel.state(), tunnel.groupId(),
old.tunnelId(),
tunnel.tunnelName(),
tunnel.annotations());
tunnelIdAsKeyStore.remove(tunnel.tunnelId());
tunnelIdAsKeyStore.put(tunnel.tunnelId(), newT);
TunnelEvent event = new TunnelEvent(
TunnelEvent.Type.TUNNEL_UPDATED,
tunnel);
notifyDelegate(event);
return tunnel.tunnelId();
} else {
TunnelId tunnelId = TunnelId.valueOf(idGenerator.getNewId());
Tunnel newT = new DefaultTunnel(tunnel.providerId(), tunnel.src(),
tunnel.dst(), tunnel.type(),
tunnel.state(), tunnel.groupId(),
tunnelId,
tunnel.tunnelName(),
tunnel.annotations());
TunnelKey key = TunnelKey.tunnelKey(tunnel.src(), tunnel.dst());
tunnelIdAsKeyStore.put(tunnelId, newT);
Set<TunnelId> tunnelnameSet = tunnelNameAsKeyStore.get(tunnel
.tunnelName());
if (tunnelnameSet == null) {
tunnelnameSet = new HashSet<TunnelId>();
}
tunnelnameSet.add(tunnelId);
tunnelNameAsKeyStore.put(tunnel
.tunnelName(), tunnelnameSet);
Set<TunnelId> srcAndDstKeySet = srcAndDstKeyStore.get(key);
if (srcAndDstKeySet == null) {
srcAndDstKeySet = new HashSet<TunnelId>();
}
srcAndDstKeySet.add(tunnelId);
srcAndDstKeyStore.put(key, srcAndDstKeySet);
Set<TunnelId> typeKeySet = typeKeyStore.get(tunnel.type());
if (typeKeySet == null) {
typeKeySet = new HashSet<TunnelId>();
}
typeKeySet.add(tunnelId);
typeKeyStore.put(tunnel.type(), typeKeySet);
TunnelEvent event = new TunnelEvent(TunnelEvent.Type.TUNNEL_ADDED,
tunnel);
notifyDelegate(event);
return tunnelId;
}
}
@Override
public void deleteTunnel(TunnelId tunnelId) {
Tunnel deletedTunnel = tunnelIdAsKeyStore.get(tunnelId);
if (deletedTunnel == null) {
return;
}
tunnelNameAsKeyStore.get(deletedTunnel.tunnelName()).remove(tunnelId);
tunnelIdAsKeyStore.remove(tunnelId);
TunnelKey key = new TunnelKey(deletedTunnel.src(), deletedTunnel.dst());
srcAndDstKeyStore.get(key).remove(tunnelId);
typeKeyStore.get(deletedTunnel.type()).remove(tunnelId);
TunnelEvent event = new TunnelEvent(TunnelEvent.Type.TUNNEL_REMOVED,
deletedTunnel);
notifyDelegate(event);
}
@Override
public void deleteTunnel(TunnelEndPoint src, TunnelEndPoint dst,
ProviderId producerName) {
TunnelKey key = TunnelKey.tunnelKey(src, dst);
Set<TunnelId> idSet = srcAndDstKeyStore.get(key);
if (idSet == null) {
return;
}
Tunnel deletedTunnel = null;
TunnelEvent event = null;
List<TunnelEvent> ls = new ArrayList<TunnelEvent>();
for (TunnelId id : idSet) {
deletedTunnel = tunnelIdAsKeyStore.get(id);
event = new TunnelEvent(TunnelEvent.Type.TUNNEL_REMOVED,
deletedTunnel);
ls.add(event);
if (producerName.equals(deletedTunnel.providerId())) {
tunnelIdAsKeyStore.remove(deletedTunnel.tunnelId());
tunnelNameAsKeyStore.get(deletedTunnel.tunnelName())
.remove(deletedTunnel.tunnelId());
srcAndDstKeyStore.get(key).remove(deletedTunnel.tunnelId());
typeKeyStore.get(deletedTunnel.type())
.remove(deletedTunnel.tunnelId());
}
}
notifyDelegate(ls);
}
@Override
public void deleteTunnel(TunnelEndPoint src, TunnelEndPoint dst, Type type,
ProviderId producerName) {
TunnelKey key = TunnelKey.tunnelKey(src, dst);
Set<TunnelId> idSet = srcAndDstKeyStore.get(key);
if (idSet == null) {
return;
}
Tunnel deletedTunnel = null;
TunnelEvent event = null;
List<TunnelEvent> ls = new ArrayList<TunnelEvent>();
for (TunnelId id : idSet) {
deletedTunnel = tunnelIdAsKeyStore.get(id);
event = new TunnelEvent(TunnelEvent.Type.TUNNEL_REMOVED,
deletedTunnel);
ls.add(event);
if (producerName.equals(deletedTunnel.providerId())
&& type.equals(deletedTunnel.type())) {
tunnelIdAsKeyStore.remove(deletedTunnel.tunnelId());
tunnelNameAsKeyStore.get(deletedTunnel.tunnelName())
.remove(deletedTunnel.tunnelId());
srcAndDstKeyStore.get(key).remove(deletedTunnel.tunnelId());
typeKeyStore.get(deletedTunnel.type())
.remove(deletedTunnel.tunnelId());
}
}
notifyDelegate(ls);
}
@Override
public Tunnel borrowTunnel(ApplicationId appId, TunnelId tunnelId,
Annotations... annotations) {
Set<TunnelSubscription> orderSet = orderRelationship.get(appId);
if (orderSet == null) {
orderSet = new HashSet<TunnelSubscription>();
}
TunnelSubscription order = new TunnelSubscription(appId, null, null, tunnelId, null, null,
annotations);
Tunnel result = tunnelIdAsKeyStore.get(tunnelId);
if (result != null || Tunnel.State.INACTIVE.equals(result.state())) {
return null;
}
orderSet.add(order);
orderRelationship.put(appId, orderSet);
return result;
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId appId,
TunnelEndPoint src,
TunnelEndPoint dst,
Annotations... annotations) {
Set<TunnelSubscription> orderSet = orderRelationship.get(appId);
if (orderSet == null) {
orderSet = new HashSet<TunnelSubscription>();
}
TunnelSubscription order = new TunnelSubscription(appId, src, dst, null, null, null, annotations);
boolean isExist = orderSet.contains(order);
if (!isExist) {
orderSet.add(order);
}
orderRelationship.put(appId, orderSet);
TunnelKey key = TunnelKey.tunnelKey(src, dst);
Set<TunnelId> idSet = srcAndDstKeyStore.get(key);
if (idSet == null || idSet.size() == 0) {
return Collections.emptySet();
}
Collection<Tunnel> tunnelSet = new HashSet<Tunnel>();
for (TunnelId tunnelId : idSet) {
Tunnel result = tunnelIdAsKeyStore.get(tunnelId);
if (Tunnel.State.ACTIVE.equals(result.state())) {
tunnelSet.add(result);
}
}
return tunnelSet;
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId appId,
TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations) {
Set<TunnelSubscription> orderSet = orderRelationship.get(appId);
if (orderSet == null) {
orderSet = new HashSet<TunnelSubscription>();
}
TunnelSubscription order = new TunnelSubscription(appId, src, dst, null, type, null, annotations);
boolean isExist = orderSet.contains(order);
if (!isExist) {
orderSet.add(order);
}
orderRelationship.put(appId, orderSet);
TunnelKey key = TunnelKey.tunnelKey(src, dst);
Set<TunnelId> idSet = srcAndDstKeyStore.get(key);
if (idSet == null || idSet.size() == 0) {
return Collections.emptySet();
}
Collection<Tunnel> tunnelSet = new HashSet<Tunnel>();
for (TunnelId tunnelId : idSet) {
Tunnel result = tunnelIdAsKeyStore.get(tunnelId);
if (type.equals(result.type())
&& Tunnel.State.ACTIVE.equals(result.state())) {
tunnelSet.add(result);
}
}
return tunnelSet;
}
@Override
public Collection<Tunnel> borrowTunnel(ApplicationId appId,
TunnelName tunnelName,
Annotations... annotations) {
Set<TunnelSubscription> orderSet = orderRelationship.get(appId);
if (orderSet == null) {
orderSet = new HashSet<TunnelSubscription>();
}
TunnelSubscription order = new TunnelSubscription(appId, null, null, null, null, tunnelName,
annotations);
boolean isExist = orderSet.contains(order);
if (!isExist) {
orderSet.add(order);
}
orderRelationship.put(appId, orderSet);
Set<TunnelId> idSet = tunnelNameAsKeyStore.get(tunnelName);
if (idSet == null || idSet.size() == 0) {
return Collections.emptySet();
}
Collection<Tunnel> tunnelSet = new HashSet<Tunnel>();
for (TunnelId tunnelId : idSet) {
Tunnel result = tunnelIdAsKeyStore.get(tunnelId);
if (Tunnel.State.ACTIVE.equals(result.state())) {
tunnelSet.add(result);
}
}
return tunnelSet;
}
@Override
public boolean returnTunnel(ApplicationId appId, TunnelName tunnelName,
Annotations... annotations) {
TunnelSubscription order = new TunnelSubscription(appId, null, null, null, null, tunnelName,
annotations);
return deleteOrder(order);
}
@Override
public boolean returnTunnel(ApplicationId appId, TunnelId tunnelId,
Annotations... annotations) {
TunnelSubscription order = new TunnelSubscription(appId, null, null, tunnelId, null, null,
annotations);
return deleteOrder(order);
}
@Override
public boolean returnTunnel(ApplicationId appId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations) {
TunnelSubscription order = new TunnelSubscription(appId, src, dst, null, type, null, annotations);
return deleteOrder(order);
}
@Override
public boolean returnTunnel(ApplicationId appId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations) {
TunnelSubscription order = new TunnelSubscription(appId, src, dst, null, null, null, annotations);
return deleteOrder(order);
}
private boolean deleteOrder(TunnelSubscription order) {
Set<TunnelSubscription> orderSet = orderRelationship.get(order.consumerId());
if (orderSet == null) {
return true;
}
if (orderSet.contains(order)) {
orderSet.remove(order);
return true;
}
return false;
}
@Override
public Tunnel queryTunnel(TunnelId tunnelId) {
return tunnelIdAsKeyStore.get(tunnelId);
}
@Override
public Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId appId) {
return orderRelationship.get(appId) != null ? ImmutableSet.copyOf(orderRelationship
.get(appId)) : Collections.emptySet();
}
@Override
public Collection<Tunnel> queryTunnel(Type type) {
Collection<Tunnel> result = new HashSet<Tunnel>();
Set<TunnelId> tunnelIds = typeKeyStore.get(type);
if (tunnelIds == null) {
return Collections.emptySet();
}
for (TunnelId id : tunnelIds) {
result.add(tunnelIdAsKeyStore.get(id));
}
return result.size() == 0 ? Collections.emptySet() : ImmutableSet
.copyOf(result);
}
@Override
public Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst) {
Collection<Tunnel> result = new HashSet<Tunnel>();
TunnelKey key = TunnelKey.tunnelKey(src, dst);
Set<TunnelId> tunnelIds = srcAndDstKeyStore.get(key);
if (tunnelIds == null) {
return Collections.emptySet();
}
for (TunnelId id : tunnelIds) {
result.add(tunnelIdAsKeyStore.get(id));
}
return result.size() == 0 ? Collections.emptySet() : ImmutableSet
.copyOf(result);
}
@Override
public int tunnelCount() {
return tunnelIdAsKeyStore.size();
}
/**
* Uses source TunnelPoint and destination TunnelPoint as map key.
*/
private static final class TunnelKey {
private final TunnelEndPoint src;
private final TunnelEndPoint dst;
private TunnelKey(TunnelEndPoint src, TunnelEndPoint dst) {
this.src = src;
this.dst = dst;
}
/**
* create a map key.
*
* @param src
* @param dst
* @return a key using source ip and destination ip
*/
static TunnelKey tunnelKey(TunnelEndPoint src, TunnelEndPoint dst) {
return new TunnelKey(src, dst);
}
@Override
public int hashCode() {
return Objects.hash(src, dst);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof TunnelKey) {
final TunnelKey other = (TunnelKey) obj;
return Objects.equals(this.src, other.src)
&& Objects.equals(this.dst, other.dst);
}
return false;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass()).add("src", src)
.add("dst", dst).toString();
}
}
}
/*
* 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.
*/
/**
* Implementation of distributed tunnel store using p2p synchronization protocol.
*/
package org.onosproject.store.tunnel.impl;
......@@ -37,6 +37,7 @@
<module>host</module>
<module>netconf</module>
<module>null</module>
<module>tunnel</module>
</modules>
<dependencies>
......
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ 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.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.onosproject</groupId>
<artifactId>onos-providers</artifactId>
<version>1.2.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-tunnel-provider</artifactId>
<packaging>bundle</packaging>
<description>tunnel southbound providers</description>
<properties>
<onos.app.name>org.onosproject.tunnel</onos.app.name>
</properties>
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.compendium</artifactId>
</dependency>
<dependency>
<groupId>org.apache.karaf.shell</groupId>
<artifactId>org.apache.karaf.shell.console</artifactId>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-cli</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
<classifier>tests</classifier>
<scope>test</scope>
</dependency>
</dependencies>
</project>
/*
* 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.provider.tunnel;
import static org.slf4j.LoggerFactory.getLogger;
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.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onosproject.cfg.ComponentConfigService;
import org.onosproject.net.ElementId;
import org.onosproject.net.Path;
import org.onosproject.net.provider.AbstractProvider;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.TunnelDescription;
import org.onosproject.net.tunnel.TunnelId;
import org.onosproject.net.tunnel.TunnelProvider;
import org.onosproject.net.tunnel.TunnelProviderRegistry;
import org.onosproject.net.tunnel.TunnelProviderService;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
/**
* Provider of a fake network environment, i.e. devices, links, hosts, etc. To
* be used for benchmarking only.
*/
@Component(immediate = true)
@Service
public class DefaultTunnelProvider extends AbstractProvider
implements TunnelProvider {
private static final Logger log = getLogger(DefaultTunnelProvider.class);
static final String PROVIDER_ID = "org.onosproject.provider.tunnel.default";
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ComponentConfigService cfgService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected TunnelProviderRegistry tunnelProviderRegistry;
TunnelProviderService service;
/**
* Creates a Tunnel provider.
*/
public DefaultTunnelProvider() {
super(new ProviderId("default", PROVIDER_ID));
}
@Activate
public void activate(ComponentContext context) {
cfgService.registerProperties(getClass());
service = tunnelProviderRegistry.register(this);
log.info("Started");
}
@Deactivate
public void deactivate(ComponentContext context) {
cfgService.unregisterProperties(getClass(), false);
tunnelProviderRegistry.unregister(this);
log.info("Stopped");
}
@Override
public void setupTunnel(Tunnel tunnel, Path path) {
// TODO Auto-generated method stub
}
@Override
public void setupTunnel(ElementId srcElement, Tunnel tunnel, Path path) {
// TODO Auto-generated method stub
}
@Override
public void releaseTunnel(Tunnel tunnel) {
// TODO Auto-generated method stub
}
@Override
public void releaseTunnel(ElementId srcElement, Tunnel tunnel) {
// TODO Auto-generated method stub
}
@Override
public void updateTunnel(Tunnel tunnel, Path path) {
// TODO Auto-generated method stub
}
@Override
public void updateTunnel(ElementId srcElement, Tunnel tunnel, Path path) {
// TODO Auto-generated method stub
}
@Override
public TunnelId tunnelAdded(TunnelDescription tunnel) {
return service.tunnelAdded(tunnel);
}
@Override
public void tunnelRemoved(TunnelDescription tunnel) {
service.tunnelRemoved(tunnel);
}
@Override
public void tunnelUpdated(TunnelDescription tunnel) {
service.tunnelUpdated(tunnel);
}
}
/*
* 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.provider.tunnel.cli;
import static com.google.common.base.Preconditions.checkArgument;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.DefaultAnnotations;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.SparseAnnotations;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.DefaultTunnelDescription;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.TunnelDescription;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelId;
import org.onosproject.net.tunnel.TunnelName;
import org.onosproject.net.tunnel.TunnelProvider;
/**
* Supports for creating a tunnel by using IP address and optical as tunnel end
* point.
*/
@Command(scope = "onos", name = "create-tunnels",
description = "Supports for creating a tunnel by using IP address and optical as tunnel end point now.")
public class CreateTunnelCommand extends AbstractShellCommand {
@Argument(index = 0, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If creates a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 1, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If creates a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 2, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
@Argument(index = 3, name = "groupId",
description = "Group flow table id which a tunnel match up", required = true, multiValued = false)
String groupId = null;
@Argument(index = 4, name = "tunnelName",
description = "The name of tunnels", required = false, multiValued = false)
String tunnelName = null;
@Argument(index = 5, name = "bandWith",
description = "The bandWith attribute of tunnel", required = false, multiValued = false)
String bandWith = null;
private static final String FMT = "The tunnel identity is %s";
@Override
protected void execute() {
TunnelProvider service = get(TunnelProvider.class);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
Tunnel.Type trueType = null;
if ("MPLS".equals(type)) {
trueType = Tunnel.Type.MPLS;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("VLAN".equals(type)) {
trueType = Tunnel.Type.VLAN;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("VXLAN".equals(type)) {
trueType = Tunnel.Type.VXLAN;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("GRE".equals(type)) {
trueType = Tunnel.Type.GRE;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type)) {
trueType = Tunnel.Type.ODUK;
String[] srcArray = src.split("||");
checkArgument(srcArray.length < 2, "Illegal src formatter.");
String[] dstArray = dst.split("||");
checkArgument(dstArray.length < 2, "Illegal dst formatter.");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else if ("OCH".equals(type)) {
trueType = Tunnel.Type.OCH;
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
SparseAnnotations annotations = DefaultAnnotations
.builder()
.set("bandWith", bandWith == null && "".equals(bandWith) ? "0" : bandWith)
.build();
TunnelDescription tunnel = new DefaultTunnelDescription(
null,
srcPoint,
dstPoint,
trueType,
new DefaultGroupId(
Integer.valueOf(groupId)
.intValue()),
producerName,
TunnelName
.tunnelName(tunnelName),
annotations);
TunnelId tunnelId = service.tunnelAdded(tunnel);
print(FMT, tunnelId.id());
}
}
/*
* 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.tunnel.cli;
import java.util.Optional;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.IpAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.DefaultOpticalTunnelEndPoint;
import org.onosproject.net.tunnel.DefaultTunnelDescription;
import org.onosproject.net.tunnel.IpTunnelEndPoint;
import org.onosproject.net.tunnel.OpticalLogicId;
import org.onosproject.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.net.tunnel.Tunnel;
import org.onosproject.net.tunnel.TunnelDescription;
import org.onosproject.net.tunnel.TunnelEndPoint;
import org.onosproject.net.tunnel.TunnelProvider;
/**
* Supports for removing all tunnels by using IP address and optical as tunnel
* end point now. It's used by producers.
*/
@Command(scope = "onos", name = "remove-tunnels", description = "Supports for removing all tunnels by using IP address"
+ " and optical as tunnel end point now. It's used by producers.")
public class RemoveTunnelCommand extends AbstractShellCommand {
@Argument(index = 0, name = "src", description = "Source tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise src means IP address.", required = true, multiValued = false)
String src = null;
@Argument(index = 1, name = "dst", description = "Destination tunnel point."
+ " Only supports for IpTunnelEndPoint and OpticalTunnelEndPoint as end point now."
+ " If deletess a ODUK or OCH type tunnel, the formatter of this argument is DeviceId-PortNumber."
+ " Otherwise dst means IP address.", required = true, multiValued = false)
String dst = null;
@Argument(index = 2, name = "type", description = "The type of tunnels,"
+ " It includes MPLS, VLAN, VXLAN, GRE, ODUK, OCH", required = true, multiValued = false)
String type = null;
@Override
protected void execute() {
TunnelProvider service = get(TunnelProvider.class);
ProviderId producerName = new ProviderId("default",
"org.onosproject.provider.tunnel.default");
TunnelEndPoint srcPoint = null;
TunnelEndPoint dstPoint = null;
Tunnel.Type trueType = null;
if ("MPLS".equals(type)) {
trueType = Tunnel.Type.MPLS;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("VLAN".equals(type)) {
trueType = Tunnel.Type.VLAN;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("VXLAN".equals(type)) {
trueType = Tunnel.Type.VXLAN;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("GRE".equals(type)) {
trueType = Tunnel.Type.GRE;
srcPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(src));
dstPoint = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(dst));
} else if ("ODUK".equals(type)) {
trueType = Tunnel.Type.ODUK;
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else if ("OCH".equals(type)) {
trueType = Tunnel.Type.OCH;
String[] srcArray = src.split("-");
String[] dstArray = dst.split("-");
srcPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(srcArray[0])),
Optional.of(PortNumber
.portNumber(srcArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
dstPoint = new DefaultOpticalTunnelEndPoint(
producerName,
Optional.of(DeviceId
.deviceId(dstArray[0])),
Optional.of(PortNumber
.portNumber(dstArray[1])),
null,
OpticalTunnelEndPoint.Type.LAMBDA,
OpticalLogicId
.logicId(0),
true);
} else {
print("Illegal tunnel type. Please input MPLS, VLAN, VXLAN, GRE, ODUK or OCH.");
return;
}
TunnelDescription tunnel = new DefaultTunnelDescription(null, srcPoint,
dstPoint,
trueType, null,
producerName,
null);
service.tunnelRemoved(tunnel);
}
}
/*
* 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.
*/
/**
* Null provider CLI commands and completers.
*/
package org.onosproject.provider.tunnel.cli;
/*
* 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.
*/
/**
* Set of null south-bound providers which permit simulating a network
* topology using fake devices, links, hosts, etc.
*/
package org.onosproject.provider.tunnel;
<!--
~ 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.
-->
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<action class="org.onosproject.provider.tunnel.cli.CreateTunnelCommand"/>
</command>
<command>
<action class="org.onosproject.provider.tunnel.cli.RemoveTunnelCommand"/>
</command>
</command-bundle>
</blueprint>