[ONOS-1284][ONOS-1869]the implementation of tunnel subsystem.It includes
test
commands, store, service. the store use eventually consistent.
Change-Id: Id54224ff65f3f2fa0a1d7adb072a2fe664987d18
diff --git a/core/net/src/main/java/org/onosproject/net/tunnel/impl/TunnelManager.java b/core/net/src/main/java/org/onosproject/net/tunnel/impl/TunnelManager.java
index 563651c..47e5311 100644
--- a/core/net/src/main/java/org/onosproject/net/tunnel/impl/TunnelManager.java
+++ b/core/net/src/main/java/org/onosproject/net/tunnel/impl/TunnelManager.java
@@ -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.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 @@
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,73 +79,221 @@
@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
+ 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 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) {
+ 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 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) {
+ return store.borrowTunnel(consumerId, tunnelId, annotations);
+ }
+
+ @Override
+ public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
+ TunnelName tunnelName,
+ Annotations... annotations) {
+ return store.borrowTunnel(consumerId, tunnelName, annotations);
+ }
+
+ @Override
+ public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
+ 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) {
+ 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) {
+ return store.returnTunnel(consumerId, tunnelId, annotations);
+ }
+
+ @Override
+ public boolean returnTunnel(ApplicationId consumerId,
+ TunnelName tunnelName,
+ Annotations... annotations) {
+ return store.returnTunnel(consumerId, tunnelName, annotations);
+ }
+
+ @Override
+ public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
+ 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) {
+ return store.returnTunnel(consumerId, src, dst, annotations);
+ }
+
+ @Override
+ public Tunnel queryTunnel(TunnelId tunnelId) {
+ return store.queryTunnel(tunnelId);
+ }
+
+ @Override
+ public Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId consumerId) {
+ return store.queryTunnelSubscription(consumerId);
+ }
+
+ @Override
+ public Collection<Tunnel> queryTunnel(Type type) {
+ return store.queryTunnel(type);
+ }
+
+ @Override
+ public Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst) {
+ return store.queryTunnel(src, dst);
+ }
+
+ @Override
+ public int tunnelCount() {
+ return store.tunnelCount();
+ }
+
+ @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
-
+ listenerRegistry.addListener(listener);
}
@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
-
- }
+ listenerRegistry.removeListener(listener);
}
private class InternalTunnelProviderService
@@ -156,25 +301,47 @@
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;
+ 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) {
- // TODO Auto-generated method stub
-
+ 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) {
- // TODO Auto-generated method stub
-
+ 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());
+ }
}
}
@@ -182,129 +349,9 @@
private class InternalStoreDelegate implements TunnelStoreDelegate {
@Override
public void notify(TunnelEvent event) {
- // TODO Auto-generated method stub
if (event != null) {
eventDispatcher.post(event);
}
}
}
-
- @Override
- public void removeTunnel(TunnelId tunnelId) {
- // TODO Auto-generated method stub
-
- }
-
- @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
-
- }
-
- @Override
- public void updateTunnel(Tunnel tunnel, Path path) {
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public Tunnel borrowTunnel(ApplicationId consumerId, TunnelId tunnelId,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
- TunnelName tunnelName,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
- TunnelEndPoint src,
- TunnelEndPoint dst,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
- TunnelEndPoint src,
- TunnelEndPoint dst, Type type,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public boolean returnTunnel(ApplicationId consumerId, TunnelId tunnelId,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public boolean returnTunnel(ApplicationId consumerId,
- TunnelName tunnelName, Annotations... annotations) {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
- TunnelEndPoint dst, Type type,
- Annotations... annotations) {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
- TunnelEndPoint dst, Annotations... annotations) {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public Tunnel queryTunnel(TunnelId tunnelId) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId consumerId) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<Tunnel> queryTunnel(Type type) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public int tunnelCount() {
- // TODO Auto-generated method stub
- return 0;
- }
-
}
diff --git a/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/DistributedTunnelStore.java b/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/DistributedTunnelStore.java
new file mode 100644
index 0000000..6082842
--- /dev/null
+++ b/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/DistributedTunnelStore.java
@@ -0,0 +1,503 @@
+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();
+ }
+ }
+
+}
diff --git a/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/package-info.java b/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/package-info.java
new file mode 100644
index 0000000..44ce0fe
--- /dev/null
+++ b/core/store/dist/src/main/java/org/onosproject/store/tunnel/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * 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;