Moved the BGP Route Intent synchronization mechanism from the Router class
to the new class IntentSynchronizer.
Also, minor cleanup in some of the method names and access scope.
Change-Id: I38257cd1d9516ef3b3dd50f23c28015054c73d70
diff --git a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/IntentSynchronizer.java b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/IntentSynchronizer.java
new file mode 100644
index 0000000..bf7f141
--- /dev/null
+++ b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/IntentSynchronizer.java
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onlab.onos.sdnip;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Semaphore;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.onlab.onos.core.ApplicationId;
+import org.onlab.onos.net.flow.criteria.Criteria.IPCriterion;
+import org.onlab.onos.net.flow.criteria.Criterion;
+import org.onlab.onos.net.intent.Intent;
+import org.onlab.onos.net.intent.IntentService;
+import org.onlab.onos.net.intent.IntentState;
+import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
+import org.onlab.packet.Ip4Prefix;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Objects;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+
+public class IntentSynchronizer {
+ private static final Logger log =
+ LoggerFactory.getLogger(IntentSynchronizer.class);
+
+ private final ApplicationId appId;
+ private final IntentService intentService;
+ private final Map<Ip4Prefix, MultiPointToSinglePointIntent> pushedRouteIntents;
+
+ //
+ // State to deal with SDN-IP Leader election and pushing Intents
+ //
+ private final ExecutorService bgpIntentsSynchronizerExecutor;
+ private final Semaphore intentsSynchronizerSemaphore = new Semaphore(0);
+ private volatile boolean isElectedLeader = false;
+ private volatile boolean isActivatedLeader = false;
+
+ /**
+ * Class constructor.
+ *
+ * @param appId the Application ID
+ * @param intentService the intent service
+ */
+ IntentSynchronizer(ApplicationId appId, IntentService intentService) {
+ this.appId = appId;
+ this.intentService = intentService;
+ pushedRouteIntents = new ConcurrentHashMap<>();
+
+ bgpIntentsSynchronizerExecutor = Executors.newSingleThreadExecutor(
+ new ThreadFactoryBuilder()
+ .setNameFormat("bgp-intents-synchronizer-%d").build());
+ }
+
+ /**
+ * Starts the synchronizer.
+ */
+ public void start() {
+ bgpIntentsSynchronizerExecutor.execute(new Runnable() {
+ @Override
+ public void run() {
+ doIntentSynchronizationThread();
+ }
+ });
+ }
+
+ /**
+ * Stops the synchronizer.
+ */
+ public void stop() {
+ // Stop the thread(s)
+ bgpIntentsSynchronizerExecutor.shutdownNow();
+
+ //
+ // Withdraw all SDN-IP intents
+ //
+ if (!isElectedLeader) {
+ return; // Nothing to do: not the leader anymore
+ }
+ log.debug("Withdrawing all SDN-IP Route Intents...");
+ for (Intent intent : intentService.getIntents()) {
+ if (!(intent instanceof MultiPointToSinglePointIntent)
+ || !intent.appId().equals(appId)) {
+ continue;
+ }
+ intentService.withdraw(intent);
+ }
+
+ pushedRouteIntents.clear();
+ }
+
+ //@Override TODO hook this up to something
+ public void leaderChanged(boolean isLeader) {
+ log.debug("Leader changed: {}", isLeader);
+
+ if (!isLeader) {
+ this.isElectedLeader = false;
+ this.isActivatedLeader = false;
+ return; // Nothing to do
+ }
+ this.isActivatedLeader = false;
+ this.isElectedLeader = true;
+
+ //
+ // Tell the Intents Synchronizer thread to start the synchronization
+ //
+ intentsSynchronizerSemaphore.release();
+ }
+
+ /**
+ * Gets the pushed route intents.
+ *
+ * @return the pushed route intents
+ */
+ public Collection<MultiPointToSinglePointIntent> getPushedRouteIntents() {
+ List<MultiPointToSinglePointIntent> pushedIntents = new LinkedList<>();
+
+ for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
+ pushedRouteIntents.entrySet()) {
+ pushedIntents.add(entry.getValue());
+ }
+ return pushedIntents;
+ }
+
+ /**
+ * Thread for Intent Synchronization.
+ */
+ private void doIntentSynchronizationThread() {
+ boolean interrupted = false;
+ try {
+ while (!interrupted) {
+ try {
+ intentsSynchronizerSemaphore.acquire();
+ //
+ // Drain all permits, because a single synchronization is
+ // sufficient.
+ //
+ intentsSynchronizerSemaphore.drainPermits();
+ } catch (InterruptedException e) {
+ log.debug("Interrupted while waiting to become " +
+ "Intent Synchronization leader");
+ interrupted = true;
+ break;
+ }
+ syncIntents();
+ }
+ } finally {
+ if (interrupted) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+
+ /**
+ * Submits a multi-point-to-single-point intent.
+ *
+ * @param prefix the IPv4 matching prefix for the intent to submit
+ * @param intent the intent to submit
+ */
+ void submitRouteIntent(Ip4Prefix prefix,
+ MultiPointToSinglePointIntent intent) {
+ synchronized (this) {
+ if (isElectedLeader && isActivatedLeader) {
+ log.debug("Intent installation: adding Intent for prefix: {}",
+ prefix);
+ intentService.submit(intent);
+ }
+
+ // Maintain the Intent
+ pushedRouteIntents.put(prefix, intent);
+ }
+ }
+
+ /**
+ * Withdraws a multi-point-to-single-point intent.
+ *
+ * @param prefix the IPv4 matching prefix for the intent to withdraw.
+ */
+ void withdrawRouteIntent(Ip4Prefix prefix) {
+ synchronized (this) {
+ MultiPointToSinglePointIntent intent =
+ pushedRouteIntents.remove(prefix);
+
+ if (intent == null) {
+ log.debug("There is no intent in pushedRouteIntents to delete " +
+ "for prefix: {}", prefix);
+ return;
+ }
+
+ if (isElectedLeader && isActivatedLeader) {
+ log.debug("Intent installation: deleting Intent for prefix: {}",
+ prefix);
+ intentService.withdraw(intent);
+ }
+ }
+ }
+
+ /**
+ * Performs Intents Synchronization between the internally stored Route
+ * Intents and the installed Route Intents.
+ */
+ private void syncIntents() {
+ synchronized (this) {
+ if (!isElectedLeader) {
+ return; // Nothing to do: not the leader anymore
+ }
+ log.debug("Syncing SDN-IP Route Intents...");
+
+ Map<Ip4Prefix, MultiPointToSinglePointIntent> fetchedIntents =
+ new HashMap<>();
+
+ //
+ // Fetch all intents, and classify the Multi-Point-to-Point Intents
+ // based on the matching prefix.
+ //
+ for (Intent intent : intentService.getIntents()) {
+
+ if (!(intent instanceof MultiPointToSinglePointIntent)
+ || !intent.appId().equals(appId)) {
+ continue;
+ }
+ MultiPointToSinglePointIntent mp2pIntent =
+ (MultiPointToSinglePointIntent) intent;
+
+ Criterion c =
+ mp2pIntent.selector().getCriterion(Criterion.Type.IPV4_DST);
+ if (c != null && c instanceof IPCriterion) {
+ IPCriterion ipCriterion = (IPCriterion) c;
+ Ip4Prefix ip4Prefix = ipCriterion.ip().getIp4Prefix();
+ if (ip4Prefix == null) {
+ // TODO: For now we support only IPv4
+ continue;
+ }
+ fetchedIntents.put(ip4Prefix, mp2pIntent);
+ } else {
+ log.warn("No IPV4_DST criterion found for intent {}",
+ mp2pIntent.id());
+ }
+
+ }
+
+ //
+ // Compare for each prefix the local IN-MEMORY Intents with the
+ // FETCHED Intents:
+ // - If the IN-MEMORY Intent is same as the FETCHED Intent, store
+ // the FETCHED Intent in the local memory (i.e., override the
+ // IN-MEMORY Intent) to preserve the original Intent ID
+ // - if the IN-MEMORY Intent is not same as the FETCHED Intent,
+ // delete the FETCHED Intent, and push/install the IN-MEMORY
+ // Intent.
+ // - If there is an IN-MEMORY Intent for a prefix, but no FETCHED
+ // Intent for same prefix, then push/install the IN-MEMORY
+ // Intent.
+ // - If there is a FETCHED Intent for a prefix, but no IN-MEMORY
+ // Intent for same prefix, then delete/withdraw the FETCHED
+ // Intent.
+ //
+ Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
+ storeInMemoryIntents = new LinkedList<>();
+ Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
+ addIntents = new LinkedList<>();
+ Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
+ deleteIntents = new LinkedList<>();
+ for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
+ pushedRouteIntents.entrySet()) {
+ Ip4Prefix prefix = entry.getKey();
+ MultiPointToSinglePointIntent inMemoryIntent =
+ entry.getValue();
+ MultiPointToSinglePointIntent fetchedIntent =
+ fetchedIntents.get(prefix);
+
+ if (fetchedIntent == null) {
+ //
+ // No FETCHED Intent for same prefix: push the IN-MEMORY
+ // Intent.
+ //
+ addIntents.add(Pair.of(prefix, inMemoryIntent));
+ continue;
+ }
+
+ IntentState state = intentService.getIntentState(fetchedIntent.id());
+ if (state == IntentState.WITHDRAWING ||
+ state == IntentState.WITHDRAWN) {
+ // The intent has been withdrawn but according to our route
+ // table it should be installed. We'll reinstall it.
+ addIntents.add(Pair.of(prefix, inMemoryIntent));
+ }
+
+ //
+ // If IN-MEMORY Intent is same as the FETCHED Intent,
+ // store the FETCHED Intent in the local memory.
+ //
+ if (compareMultiPointToSinglePointIntents(inMemoryIntent,
+ fetchedIntent)) {
+ storeInMemoryIntents.add(Pair.of(prefix, fetchedIntent));
+ } else {
+ //
+ // The IN-MEMORY Intent is not same as the FETCHED Intent,
+ // hence delete the FETCHED Intent, and install the
+ // IN-MEMORY Intent.
+ //
+ deleteIntents.add(Pair.of(prefix, fetchedIntent));
+ addIntents.add(Pair.of(prefix, inMemoryIntent));
+ }
+ fetchedIntents.remove(prefix);
+ }
+
+ //
+ // Any remaining FETCHED Intents have to be deleted/withdrawn
+ //
+ for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
+ fetchedIntents.entrySet()) {
+ Ip4Prefix prefix = entry.getKey();
+ MultiPointToSinglePointIntent fetchedIntent = entry.getValue();
+ deleteIntents.add(Pair.of(prefix, fetchedIntent));
+ }
+
+ //
+ // Perform the actions:
+ // 1. Store in memory fetched intents that are same. Can be done
+ // even if we are not the leader anymore
+ // 2. Delete intents: check if the leader before each operation
+ // 3. Add intents: check if the leader before each operation
+ //
+ for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
+ storeInMemoryIntents) {
+ Ip4Prefix prefix = pair.getLeft();
+ MultiPointToSinglePointIntent intent = pair.getRight();
+ log.debug("Intent synchronization: updating in-memory " +
+ "Intent for prefix: {}", prefix);
+ pushedRouteIntents.put(prefix, intent);
+ }
+ //
+ isActivatedLeader = true; // Allow push of Intents
+ for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
+ deleteIntents) {
+ Ip4Prefix prefix = pair.getLeft();
+ MultiPointToSinglePointIntent intent = pair.getRight();
+ if (!isElectedLeader) {
+ isActivatedLeader = false;
+ return;
+ }
+ log.debug("Intent synchronization: deleting Intent for " +
+ "prefix: {}", prefix);
+ intentService.withdraw(intent);
+ }
+ //
+ for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
+ addIntents) {
+ Ip4Prefix prefix = pair.getLeft();
+ MultiPointToSinglePointIntent intent = pair.getRight();
+ if (!isElectedLeader) {
+ isActivatedLeader = false;
+ return;
+ }
+ log.debug("Intent synchronization: adding Intent for " +
+ "prefix: {}", prefix);
+ intentService.submit(intent);
+ }
+ if (!isElectedLeader) {
+ isActivatedLeader = false;
+ }
+ log.debug("Syncing SDN-IP routes completed.");
+ }
+ }
+
+ /**
+ * Compares two Multi-point to Single Point Intents whether they represent
+ * same logical intention.
+ *
+ * @param intent1 the first Intent to compare
+ * @param intent2 the second Intent to compare
+ * @return true if both Intents represent same logical intention, otherwise
+ * false
+ */
+ private boolean compareMultiPointToSinglePointIntents(
+ MultiPointToSinglePointIntent intent1,
+ MultiPointToSinglePointIntent intent2) {
+
+ return Objects.equal(intent1.appId(), intent2.appId()) &&
+ Objects.equal(intent1.selector(), intent2.selector()) &&
+ Objects.equal(intent1.treatment(), intent2.treatment()) &&
+ Objects.equal(intent1.ingressPoints(), intent2.ingressPoints()) &&
+ Objects.equal(intent1.egressPoint(), intent2.egressPoint());
+ }
+}
diff --git a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/PeerConnectivityManager.java b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/PeerConnectivityManager.java
index 56db046..a691ade 100644
--- a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/PeerConnectivityManager.java
+++ b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/PeerConnectivityManager.java
@@ -96,6 +96,13 @@
}
/**
+ * Stops the peer connectivity manager.
+ */
+ public void stop() {
+ // TODO: Implement it
+ }
+
+ /**
* Sets up paths to establish connectivity between all internal
* {@link BgpSpeaker}s and all external {@link BgpPeer}s.
*/
diff --git a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/Router.java b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/Router.java
index 6316b59..6b5f2f4 100644
--- a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/Router.java
+++ b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/Router.java
@@ -16,21 +16,16 @@
package org.onlab.onos.sdnip;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.Semaphore;
-import org.apache.commons.lang3.tuple.Pair;
import org.onlab.onos.core.ApplicationId;
import org.onlab.onos.net.ConnectPoint;
import org.onlab.onos.net.Host;
@@ -38,15 +33,9 @@
import org.onlab.onos.net.flow.DefaultTrafficTreatment;
import org.onlab.onos.net.flow.TrafficSelector;
import org.onlab.onos.net.flow.TrafficTreatment;
-import org.onlab.onos.net.flow.criteria.Criteria.IPCriterion;
-import org.onlab.onos.net.flow.criteria.Criterion;
-import org.onlab.onos.net.flow.criteria.Criterion.Type;
import org.onlab.onos.net.host.HostEvent;
import org.onlab.onos.net.host.HostListener;
import org.onlab.onos.net.host.HostService;
-import org.onlab.onos.net.intent.Intent;
-import org.onlab.onos.net.intent.IntentService;
-import org.onlab.onos.net.intent.IntentState;
import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
import org.onlab.onos.sdnip.config.BgpPeer;
import org.onlab.onos.sdnip.config.Interface;
@@ -59,7 +48,6 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Objects;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
@@ -76,100 +64,81 @@
public class Router implements RouteListener {
private static final Logger log = LoggerFactory.getLogger(Router.class);
+ // For routes announced by local BGP daemon in SDN network,
+ // the next hop will be 0.0.0.0.
+ private static final Ip4Address LOCAL_NEXT_HOP =
+ Ip4Address.valueOf("0.0.0.0");
// Store all route updates in a radix tree.
// The key in this tree is the binary string of prefix of the route.
private InvertedRadixTree<RouteEntry> bgpRoutes;
// Stores all incoming route updates in a queue.
- private BlockingQueue<RouteUpdate> routeUpdates;
+ private final BlockingQueue<RouteUpdate> routeUpdates;
// The Ip4Address is the next hop address of each route update.
- private SetMultimap<Ip4Address, RouteEntry> routesWaitingOnArp;
- private ConcurrentHashMap<Ip4Prefix, MultiPointToSinglePointIntent> pushedRouteIntents;
-
- private IntentService intentService;
- private HostService hostService;
- private SdnIpConfigService configService;
- private InterfaceService interfaceService;
-
- private ExecutorService bgpUpdatesExecutor;
- private ExecutorService bgpIntentsSynchronizerExecutor;
+ private final SetMultimap<Ip4Address, RouteEntry> routesWaitingOnArp;
private final ApplicationId appId;
-
- //
- // State to deal with SDN-IP Leader election and pushing Intents
- //
- private Semaphore intentsSynchronizerSemaphore = new Semaphore(0);
- private volatile boolean isElectedLeader = false;
- private volatile boolean isActivatedLeader = false;
-
- // For routes announced by local BGP daemon in SDN network,
- // the next hop will be 0.0.0.0.
- public static final Ip4Address LOCAL_NEXT_HOP =
- Ip4Address.valueOf("0.0.0.0");
+ private final IntentSynchronizer intentSynchronizer;
+ private final HostService hostService;
+ private final SdnIpConfigService configService;
+ private final InterfaceService interfaceService;
+ private final ExecutorService bgpUpdatesExecutor;
+ private final HostListener hostListener;
/**
* Class constructor.
*
* @param appId the application ID
- * @param intentService the intent service
+ * @param intentSynchronizer the intent synchronizer
* @param hostService the host service
* @param configService the configuration service
* @param interfaceService the interface service
*/
- public Router(ApplicationId appId, IntentService intentService,
+ public Router(ApplicationId appId, IntentSynchronizer intentSynchronizer,
HostService hostService, SdnIpConfigService configService,
InterfaceService interfaceService) {
this.appId = appId;
- this.intentService = intentService;
+ this.intentSynchronizer = intentSynchronizer;
this.hostService = hostService;
this.configService = configService;
this.interfaceService = interfaceService;
+ this.hostListener = new InternalHostListener();
+
bgpRoutes = new ConcurrentInvertedRadixTree<>(
new DefaultByteArrayNodeFactory());
routeUpdates = new LinkedBlockingQueue<>();
routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
HashMultimap.<Ip4Address, RouteEntry>create());
- pushedRouteIntents = new ConcurrentHashMap<>();
bgpUpdatesExecutor = Executors.newSingleThreadExecutor(
new ThreadFactoryBuilder().setNameFormat("bgp-updates-%d").build());
- bgpIntentsSynchronizerExecutor = Executors.newSingleThreadExecutor(
- new ThreadFactoryBuilder()
- .setNameFormat("bgp-intents-synchronizer-%d").build());
-
- this.hostService.addListener(new InternalHostListener());
}
/**
* Starts the router.
*/
public void start() {
+ this.hostService.addListener(hostListener);
+
bgpUpdatesExecutor.execute(new Runnable() {
@Override
public void run() {
doUpdatesThread();
}
});
-
- bgpIntentsSynchronizerExecutor.execute(new Runnable() {
- @Override
- public void run() {
- doIntentSynchronizationThread();
- }
- });
}
/**
- * Shuts the router down.
+ * Stops the router.
*/
- public void shutdown() {
- // Stop all threads
+ public void stop() {
+ this.hostService.removeListener(hostListener);
+
+ // Stop the thread(s)
bgpUpdatesExecutor.shutdownNow();
- bgpIntentsSynchronizerExecutor.shutdownNow();
synchronized (this) {
// Cleanup all local state
@@ -177,43 +146,9 @@
new DefaultByteArrayNodeFactory());
routeUpdates.clear();
routesWaitingOnArp.clear();
- pushedRouteIntents.clear();
-
- //
- // Withdraw all SDN-IP intents
- //
- if (!isElectedLeader) {
- return; // Nothing to do: not the leader anymore
- }
- log.debug("Withdrawing all SDN-IP Route Intents...");
- for (Intent intent : intentService.getIntents()) {
- if (!(intent instanceof MultiPointToSinglePointIntent)
- || !intent.appId().equals(appId)) {
- continue;
- }
- intentService.withdraw(intent);
- }
}
}
- //@Override TODO hook this up to something
- public void leaderChanged(boolean isLeader) {
- log.debug("Leader changed: {}", isLeader);
-
- if (!isLeader) {
- this.isElectedLeader = false;
- this.isActivatedLeader = false;
- return; // Nothing to do
- }
- this.isActivatedLeader = false;
- this.isElectedLeader = true;
-
- //
- // Tell the Intents Synchronizer thread to start the synchronization
- //
- intentsSynchronizerSemaphore.release();
- }
-
@Override
public void update(RouteUpdate routeUpdate) {
log.debug("Received new route update: {}", routeUpdate);
@@ -227,35 +162,6 @@
}
/**
- * Thread for Intent Synchronization.
- */
- private void doIntentSynchronizationThread() {
- boolean interrupted = false;
- try {
- while (!interrupted) {
- try {
- intentsSynchronizerSemaphore.acquire();
- //
- // Drain all permits, because a single synchronization is
- // sufficient.
- //
- intentsSynchronizerSemaphore.drainPermits();
- } catch (InterruptedException e) {
- log.debug("Interrupted while waiting to become " +
- "Intent Synchronization leader");
- interrupted = true;
- break;
- }
- syncIntents();
- }
- } finally {
- if (interrupted) {
- Thread.currentThread().interrupt();
- }
- }
- }
-
- /**
* Thread for handling route updates.
*/
private void doUpdatesThread() {
@@ -290,194 +196,6 @@
}
/**
- * Performs Intents Synchronization between the internally stored Route
- * Intents and the installed Route Intents.
- */
- private void syncIntents() {
- synchronized (this) {
- if (!isElectedLeader) {
- return; // Nothing to do: not the leader anymore
- }
- log.debug("Syncing SDN-IP Route Intents...");
-
- Map<Ip4Prefix, MultiPointToSinglePointIntent> fetchedIntents =
- new HashMap<>();
-
- //
- // Fetch all intents, and classify the Multi-Point-to-Point Intents
- // based on the matching prefix.
- //
- for (Intent intent : intentService.getIntents()) {
-
- if (!(intent instanceof MultiPointToSinglePointIntent)
- || !intent.appId().equals(appId)) {
- continue;
- }
- MultiPointToSinglePointIntent mp2pIntent =
- (MultiPointToSinglePointIntent) intent;
-
- Criterion c = mp2pIntent.selector().getCriterion(Type.IPV4_DST);
- if (c != null && c instanceof IPCriterion) {
- IPCriterion ipCriterion = (IPCriterion) c;
- Ip4Prefix ip4Prefix = ipCriterion.ip().getIp4Prefix();
- if (ip4Prefix == null) {
- // TODO: For now we support only IPv4
- continue;
- }
- fetchedIntents.put(ip4Prefix, mp2pIntent);
- } else {
- log.warn("No IPV4_DST criterion found for intent {}",
- mp2pIntent.id());
- }
-
- }
-
- //
- // Compare for each prefix the local IN-MEMORY Intents with the
- // FETCHED Intents:
- // - If the IN-MEMORY Intent is same as the FETCHED Intent, store
- // the FETCHED Intent in the local memory (i.e., override the
- // IN-MEMORY Intent) to preserve the original Intent ID
- // - if the IN-MEMORY Intent is not same as the FETCHED Intent,
- // delete the FETCHED Intent, and push/install the IN-MEMORY
- // Intent.
- // - If there is an IN-MEMORY Intent for a prefix, but no FETCHED
- // Intent for same prefix, then push/install the IN-MEMORY
- // Intent.
- // - If there is a FETCHED Intent for a prefix, but no IN-MEMORY
- // Intent for same prefix, then delete/withdraw the FETCHED
- // Intent.
- //
- Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
- storeInMemoryIntents = new LinkedList<>();
- Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
- addIntents = new LinkedList<>();
- Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
- deleteIntents = new LinkedList<>();
- for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
- pushedRouteIntents.entrySet()) {
- Ip4Prefix prefix = entry.getKey();
- MultiPointToSinglePointIntent inMemoryIntent =
- entry.getValue();
- MultiPointToSinglePointIntent fetchedIntent =
- fetchedIntents.get(prefix);
-
- if (fetchedIntent == null) {
- //
- // No FETCHED Intent for same prefix: push the IN-MEMORY
- // Intent.
- //
- addIntents.add(Pair.of(prefix, inMemoryIntent));
- continue;
- }
-
- IntentState state = intentService.getIntentState(fetchedIntent.id());
- if (state == IntentState.WITHDRAWING ||
- state == IntentState.WITHDRAWN) {
- // The intent has been withdrawn but according to our route
- // table it should be installed. We'll reinstall it.
- addIntents.add(Pair.of(prefix, inMemoryIntent));
- }
-
- //
- // If IN-MEMORY Intent is same as the FETCHED Intent,
- // store the FETCHED Intent in the local memory.
- //
- if (compareMultiPointToSinglePointIntents(inMemoryIntent,
- fetchedIntent)) {
- storeInMemoryIntents.add(Pair.of(prefix, fetchedIntent));
- } else {
- //
- // The IN-MEMORY Intent is not same as the FETCHED Intent,
- // hence delete the FETCHED Intent, and install the
- // IN-MEMORY Intent.
- //
- deleteIntents.add(Pair.of(prefix, fetchedIntent));
- addIntents.add(Pair.of(prefix, inMemoryIntent));
- }
- fetchedIntents.remove(prefix);
- }
-
- //
- // Any remaining FETCHED Intents have to be deleted/withdrawn
- //
- for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
- fetchedIntents.entrySet()) {
- Ip4Prefix prefix = entry.getKey();
- MultiPointToSinglePointIntent fetchedIntent = entry.getValue();
- deleteIntents.add(Pair.of(prefix, fetchedIntent));
- }
-
- //
- // Perform the actions:
- // 1. Store in memory fetched intents that are same. Can be done
- // even if we are not the leader anymore
- // 2. Delete intents: check if the leader before each operation
- // 3. Add intents: check if the leader before each operation
- //
- for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
- storeInMemoryIntents) {
- Ip4Prefix prefix = pair.getLeft();
- MultiPointToSinglePointIntent intent = pair.getRight();
- log.debug("Intent synchronization: updating in-memory " +
- "Intent for prefix: {}", prefix);
- pushedRouteIntents.put(prefix, intent);
- }
- //
- isActivatedLeader = true; // Allow push of Intents
- for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
- deleteIntents) {
- Ip4Prefix prefix = pair.getLeft();
- MultiPointToSinglePointIntent intent = pair.getRight();
- if (!isElectedLeader) {
- isActivatedLeader = false;
- return;
- }
- log.debug("Intent synchronization: deleting Intent for " +
- "prefix: {}", prefix);
- intentService.withdraw(intent);
- }
- //
- for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
- addIntents) {
- Ip4Prefix prefix = pair.getLeft();
- MultiPointToSinglePointIntent intent = pair.getRight();
- if (!isElectedLeader) {
- isActivatedLeader = false;
- return;
- }
- log.debug("Intent synchronization: adding Intent for " +
- "prefix: {}", prefix);
- intentService.submit(intent);
- }
- if (!isElectedLeader) {
- isActivatedLeader = false;
- }
- log.debug("Syncing SDN-IP routes completed.");
- }
- }
-
- /**
- * Compares two Multi-point to Single Point Intents whether they represent
- * same logical intention.
- *
- * @param intent1 the first Intent to compare
- * @param intent2 the second Intent to compare
- * @return true if both Intents represent same logical intention, otherwise
- * false
- */
- private boolean compareMultiPointToSinglePointIntents(
- MultiPointToSinglePointIntent intent1,
- MultiPointToSinglePointIntent intent2) {
-
- return Objects.equal(intent1.appId(), intent2.appId()) &&
- Objects.equal(intent1.selector(), intent2.selector()) &&
- Objects.equal(intent1.treatment(), intent2.treatment()) &&
- Objects.equal(intent1.ingressPoints(), intent2.ingressPoints()) &&
- Objects.equal(intent1.egressPoint(), intent2.egressPoint());
- }
-
- /**
* Processes adding a route entry.
* <p>
* Put new route entry into the radix tree. If there was an existing
@@ -488,7 +206,7 @@
*
* @param routeEntry the route entry to add
*/
- protected void processRouteAdd(RouteEntry routeEntry) {
+ void processRouteAdd(RouteEntry routeEntry) {
synchronized (this) {
log.debug("Processing route add: {}", routeEntry);
@@ -610,17 +328,8 @@
log.debug("Adding intent for prefix {}, next hop mac {}",
prefix, nextHopMacAddress);
- MultiPointToSinglePointIntent pushedIntent =
- pushedRouteIntents.get(prefix);
-
- // Just for testing.
- if (pushedIntent != null) {
- log.error("There should not be a pushed intent: {}", pushedIntent);
- }
-
- ConnectPoint egressPort = egressInterface.connectPoint();
-
Set<ConnectPoint> ingressPorts = new HashSet<>();
+ ConnectPoint egressPort = egressInterface.connectPoint();
for (Interface intf : interfaceService.getInterfaces()) {
if (!intf.connectPoint().equals(egressInterface.connectPoint())) {
@@ -644,14 +353,7 @@
new MultiPointToSinglePointIntent(appId, selector, treatment,
ingressPorts, egressPort);
- if (isElectedLeader && isActivatedLeader) {
- log.debug("Intent installation: adding Intent for prefix: {}",
- prefix);
- intentService.submit(intent);
- }
-
- // Maintain the Intent
- pushedRouteIntents.put(prefix, intent);
+ intentSynchronizer.submitRouteIntent(prefix, intent);
}
/**
@@ -663,7 +365,7 @@
*
* @param routeEntry the route entry to delete
*/
- protected void processRouteDelete(RouteEntry routeEntry) {
+ void processRouteDelete(RouteEntry routeEntry) {
synchronized (this) {
log.debug("Processing route delete: {}", routeEntry);
Ip4Prefix prefix = routeEntry.prefix();
@@ -691,21 +393,7 @@
private void executeRouteDelete(RouteEntry routeEntry) {
log.debug("Executing route delete: {}", routeEntry);
- Ip4Prefix prefix = routeEntry.prefix();
-
- MultiPointToSinglePointIntent intent =
- pushedRouteIntents.remove(prefix);
-
- if (intent == null) {
- log.debug("There is no intent in pushedRouteIntents to delete " +
- "for prefix: {}", prefix);
- } else {
- if (isElectedLeader && isActivatedLeader) {
- log.debug("Intent installation: deleting Intent for prefix: {}",
- prefix);
- intentService.withdraw(intent);
- }
- }
+ intentSynchronizer.withdrawRouteIntent(routeEntry.prefix());
}
/**
@@ -774,21 +462,6 @@
}
/**
- * Gets the pushed route intents.
- *
- * @return the pushed route intents
- */
- public Collection<MultiPointToSinglePointIntent> getPushedRouteIntents() {
- List<MultiPointToSinglePointIntent> pushedIntents = new LinkedList<>();
-
- for (Map.Entry<Ip4Prefix, MultiPointToSinglePointIntent> entry :
- pushedRouteIntents.entrySet()) {
- pushedIntents.add(entry.getValue());
- }
- return pushedIntents;
- }
-
- /**
* Listener for host events.
*/
class InternalHostListener implements HostListener {
diff --git a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/SdnIp.java b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/SdnIp.java
index c54e3f4..aa84747 100644
--- a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/SdnIp.java
+++ b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/SdnIp.java
@@ -55,6 +55,7 @@
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected HostService hostService;
+ private IntentSynchronizer intentSynchronizer;
private SdnIpConfigReader config;
private PeerConnectivityManager peerConnectivity;
private Router router;
@@ -64,35 +65,41 @@
protected void activate() {
log.debug("SDN-IP started");
+ ApplicationId appId = coreService.registerApplication(SDN_IP_APP);
config = new SdnIpConfigReader();
config.init();
- InterfaceService interfaceService = new HostToInterfaceAdaptor(hostService);
+ InterfaceService interfaceService =
+ new HostToInterfaceAdaptor(hostService);
- ApplicationId appId = coreService.registerApplication(SDN_IP_APP);
+ intentSynchronizer = new IntentSynchronizer(appId, intentService);
+ intentSynchronizer.start();
peerConnectivity = new PeerConnectivityManager(appId, config,
interfaceService, intentService);
peerConnectivity.start();
- router = new Router(appId, intentService, hostService, config, interfaceService);
+ router = new Router(appId, intentSynchronizer, hostService, config,
+ interfaceService);
router.start();
- // Manually set the router as the leader to allow testing
+ // Manually set the instance as the leader to allow testing
// TODO change this when we get a leader election
- router.leaderChanged(true);
+ intentSynchronizer.leaderChanged(true);
bgpSessionManager = new BgpSessionManager(router);
- bgpSessionManager.startUp(2000); // TODO
+ // TODO: the local BGP listen port number should be configurable
+ bgpSessionManager.start(2000);
// TODO need to disable link discovery on external ports
-
}
@Deactivate
protected void deactivate() {
- bgpSessionManager.shutDown();
- router.shutdown();
+ bgpSessionManager.stop();
+ router.stop();
+ peerConnectivity.stop();
+ intentSynchronizer.stop();
log.info("Stopped");
}
@@ -114,7 +121,7 @@
@Override
public void modifyPrimary(boolean isPrimary) {
- router.leaderChanged(isPrimary);
+ intentSynchronizer.leaderChanged(isPrimary);
}
static String dpidToUri(String dpid) {
diff --git a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/bgp/BgpSessionManager.java b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/bgp/BgpSessionManager.java
index b6dfd34..aaf26fa 100644
--- a/apps/sdnip/src/main/java/org/onlab/onos/sdnip/bgp/BgpSessionManager.java
+++ b/apps/sdnip/src/main/java/org/onlab/onos/sdnip/bgp/BgpSessionManager.java
@@ -181,8 +181,8 @@
* @param listenPortNumber the port number to listen on. By default
* it should be BgpConstants.BGP_PORT (179)
*/
- public void startUp(int listenPortNumber) {
- log.debug("BGP Session Manager startUp()");
+ public void start(int listenPortNumber) {
+ log.debug("BGP Session Manager start.");
isShutdown = false;
ChannelFactory channelFactory =
@@ -222,9 +222,9 @@
}
/**
- * Shuts down the BGP Session Manager operation.
+ * Stops the BGP Session Manager operation.
*/
- public void shutDown() {
+ public void stop() {
isShutdown = true;
allChannels.close().awaitUninterruptibly();
serverBootstrap.releaseExternalResources();