Updated SDN-IP to use the Intent framework batch-based intents.

Also, created a local cache of IPv4-to-MAC address mapping,
to avoid relatively costly hostService.getHostsByIp() calls
per added route.

Change-Id: I8abed378985708e883fd99e85c54b01f38756515

@@ -26,6 +26,7 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.Semaphore;
 
 
+import org.apache.commons.lang3.tuple.Pair;
 import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.net.flow.criteria.Criteria.IPCriterion;
 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;
@@ -116,7 +117,7 @@ public class IntentSynchronizer {
             //
             //
             log.debug("SDN-IP Intent Synchronizer shutdown: " +
             log.debug("SDN-IP Intent Synchronizer shutdown: " +
                       "withdrawing all intents...");
                       "withdrawing all intents...");
-            IntentOperations.Builder builder = IntentOperations.builder();
+            IntentOperations.Builder builder = IntentOperations.builder(appId);
             for (Intent intent : intentService.getIntents()) {
             for (Intent intent : intentService.getIntents()) {
                 // Skip the intents from other applications
                 // Skip the intents from other applications
                 if (!intent.appId().equals(appId)) {
                 if (!intent.appId().equals(appId)) {
@@ -234,51 +235,84 @@ public class IntentSynchronizer {
     }
     }
 
 
     /**
     /**
-     * Submits a multi-point-to-single-point intent.
+     * Updates multi-point-to-single-point route intents.
      *
      *
-     * @param prefix the IPv4 matching prefix for the intent to submit
-     * @param intent the intent to submit
+     * @param submitIntents the intents to submit
+     * @param withdrawPrefixes the IPv4 matching prefixes for the intents
+     * to withdraw
      */
      */
-    void submitRouteIntent(Ip4Prefix prefix,
-                           MultiPointToSinglePointIntent intent) {
+    void updateRouteIntents(
+                Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>> submitIntents,
+                Collection<Ip4Prefix> withdrawPrefixes) {
+
+        //
+        // NOTE: Semantically, we MUST withdraw existing intents before
+        // submitting new intents.
+        //
         synchronized (this) {
         synchronized (this) {
-            MultiPointToSinglePointIntent oldIntent =
-                routeIntents.put(prefix, intent);
+            MultiPointToSinglePointIntent intent;
 
 
-            if (isElectedLeader && isActivatedLeader) {
-                if (oldIntent != null) {
-                    //
-                    // TODO: Short-term solution to explicitly withdraw
-                    // instead of using "replace" operation.
-                    //
-                    log.debug("SDN-IP Withdrawing old intent: {}", oldIntent);
-                    intentService.withdraw(oldIntent);
+            log.debug("SDN-IP submitting intents = {} withdrawing = {}",
+                     submitIntents.size(), withdrawPrefixes.size());
+
+            //
+            // Prepare the Intent batch operations for the intents to withdraw
+            //
+            IntentOperations.Builder withdrawBuilder =
+                IntentOperations.builder(appId);
+            for (Ip4Prefix prefix : withdrawPrefixes) {
+                intent = routeIntents.remove(prefix);
+                if (intent == null) {
+                    log.debug("SDN-IP No intent in routeIntents to delete " +
+                              "for prefix: {}", prefix);
+                    continue;
+                }
+                if (isElectedLeader && isActivatedLeader) {
+                    log.debug("SDN-IP Withdrawing intent: {}", intent);
+                    withdrawBuilder.addWithdrawOperation(intent.id());
                 }
                 }
-                log.debug("SDN-IP Submitting intent: {}", intent);
-                intentService.submit(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 =
-                routeIntents.remove(prefix);
-
-            if (intent == null) {
-                log.debug("SDN-IP no intent in routeIntents to delete for " +
-                          "prefix: {}", prefix);
-                return;
+            //
+            // Prepare the Intent batch operations for the intents to submit
+            //
+            IntentOperations.Builder submitBuilder =
+                IntentOperations.builder(appId);
+            for (Pair<Ip4Prefix, MultiPointToSinglePointIntent> pair :
+                     submitIntents) {
+                Ip4Prefix prefix = pair.getLeft();
+                intent = pair.getRight();
+                MultiPointToSinglePointIntent oldIntent =
+                    routeIntents.put(prefix, intent);
+                if (isElectedLeader && isActivatedLeader) {
+                    if (oldIntent != null) {
+                        //
+                        // TODO: Short-term solution to explicitly withdraw
+                        // instead of using "replace" operation.
+                        //
+                        log.debug("SDN-IP Withdrawing old intent: {}",
+                                  oldIntent);
+                        withdrawBuilder.addWithdrawOperation(oldIntent.id());
+                    }
+                    log.debug("SDN-IP Submitting intent: {}", intent);
+                    submitBuilder.addSubmitOperation(intent);
+                }
             }
             }
 
 
+            //
+            // Submit the Intent operations
+            //
             if (isElectedLeader && isActivatedLeader) {
             if (isElectedLeader && isActivatedLeader) {
-                log.debug("SDN-IP Withdrawing intent: {}", intent);
-                intentService.withdraw(intent);
+                IntentOperations intentOperations = withdrawBuilder.build();
+                if (!intentOperations.operations().isEmpty()) {
+                    log.debug("SDN-IP Withdrawing intents executed");
+                    intentService.execute(intentOperations);
+                }
+                intentOperations = submitBuilder.build();
+                if (!intentOperations.operations().isEmpty()) {
+                    log.debug("SDN-IP Submitting intents executed");
+                    intentService.execute(intentOperations);
+                }
             }
             }
         }
         }
     }
     }

@@ -15,6 +15,8 @@
  */
  */
 package org.onlab.onos.sdnip;
 package org.onlab.onos.sdnip;
 
 
+import java.util.Collection;
+
 /**
 /**
  * An interface to receive route updates from route providers.
  * An interface to receive route updates from route providers.
  */
  */
@@ -22,7 +24,7 @@ public interface RouteListener {
     /**
     /**
      * Receives a route update from a route provider.
      * Receives a route update from a route provider.
      *
      *
-     * @param routeUpdate the updated route information
+     * @param routeUpdates the collection with updated route information
      */
      */
-    public void update(RouteUpdate routeUpdate);
+    public void update(Collection<RouteUpdate> routeUpdates);
 }
 }

@@ -20,12 +20,15 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 
 
+import org.apache.commons.lang3.tuple.Pair;
 import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.net.ConnectPoint;
 import org.onlab.onos.net.ConnectPoint;
 import org.onlab.onos.net.Host;
 import org.onlab.onos.net.Host;
@@ -74,11 +77,14 @@ public class Router implements RouteListener {
     private InvertedRadixTree<RouteEntry> bgpRoutes;
     private InvertedRadixTree<RouteEntry> bgpRoutes;
 
 
     // Stores all incoming route updates in a queue.
     // Stores all incoming route updates in a queue.
-    private final BlockingQueue<RouteUpdate> routeUpdates;
+    private final BlockingQueue<Collection<RouteUpdate>> routeUpdatesQueue;
 
 
     // The Ip4Address is the next hop address of each route update.
     // The Ip4Address is the next hop address of each route update.
     private final SetMultimap<Ip4Address, RouteEntry> routesWaitingOnArp;
     private final SetMultimap<Ip4Address, RouteEntry> routesWaitingOnArp;
 
 
+    // The IPv4 address to MAC address mapping
+    private final Map<Ip4Address, MacAddress> ip2Mac;
+
     private final ApplicationId appId;
     private final ApplicationId appId;
     private final IntentSynchronizer intentSynchronizer;
     private final IntentSynchronizer intentSynchronizer;
     private final HostService hostService;
     private final HostService hostService;
@@ -110,9 +116,10 @@ public class Router implements RouteListener {
 
 
         bgpRoutes = new ConcurrentInvertedRadixTree<>(
         bgpRoutes = new ConcurrentInvertedRadixTree<>(
                 new DefaultByteArrayNodeFactory());
                 new DefaultByteArrayNodeFactory());
-        routeUpdates = new LinkedBlockingQueue<>();
+        routeUpdatesQueue = new LinkedBlockingQueue<>();
         routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
         routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
                 HashMultimap.<Ip4Address, RouteEntry>create());
                 HashMultimap.<Ip4Address, RouteEntry>create());
+        ip2Mac = new ConcurrentHashMap<>();
 
 
         bgpUpdatesExecutor = Executors.newSingleThreadExecutor(
         bgpUpdatesExecutor = Executors.newSingleThreadExecutor(
                 new ThreadFactoryBuilder()
                 new ThreadFactoryBuilder()
@@ -146,19 +153,18 @@ public class Router implements RouteListener {
             // Cleanup all local state
             // Cleanup all local state
             bgpRoutes = new ConcurrentInvertedRadixTree<>(
             bgpRoutes = new ConcurrentInvertedRadixTree<>(
                 new DefaultByteArrayNodeFactory());
                 new DefaultByteArrayNodeFactory());
-            routeUpdates.clear();
+            routeUpdatesQueue.clear();
             routesWaitingOnArp.clear();
             routesWaitingOnArp.clear();
+            ip2Mac.clear();
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public void update(RouteUpdate routeUpdate) {
-        log.debug("Received new route update: {}", routeUpdate);
-
+    public void update(Collection<RouteUpdate> routeUpdates) {
         try {
         try {
-            routeUpdates.put(routeUpdate);
+            routeUpdatesQueue.put(routeUpdates);
         } catch (InterruptedException e) {
         } catch (InterruptedException e) {
-            log.debug("Interrupted while putting on routeUpdates queue", e);
+            log.debug("Interrupted while putting on routeUpdatesQueue", e);
             Thread.currentThread().interrupt();
             Thread.currentThread().interrupt();
         }
         }
     }
     }
@@ -171,18 +177,9 @@ public class Router implements RouteListener {
         try {
         try {
             while (!interrupted) {
             while (!interrupted) {
                 try {
                 try {
-                    RouteUpdate update = routeUpdates.take();
-                    switch (update.type()) {
-                        case UPDATE:
-                            processRouteAdd(update.routeEntry());
-                            break;
-                        case DELETE:
-                            processRouteDelete(update.routeEntry());
-                            break;
-                        default:
-                            log.error("Unknown update Type: {}", update.type());
-                            break;
-                    }
+                    Collection<RouteUpdate> routeUpdates =
+                        routeUpdatesQueue.take();
+                    processRouteUpdates(routeUpdates);
                 } catch (InterruptedException e) {
                 } catch (InterruptedException e) {
                     log.debug("Interrupted while taking from updates queue", e);
                     log.debug("Interrupted while taking from updates queue", e);
                     interrupted = true;
                     interrupted = true;
@@ -198,98 +195,137 @@ public class Router implements RouteListener {
     }
     }
 
 
     /**
     /**
-     * Processes adding a route entry.
-     * <p>
-     * Put new route entry into the radix tree. If there was an existing
-     * next hop for this prefix, but the next hop was different, then execute
-     * deleting old route entry. If the next hop is the SDN domain, we do not
-     * handle it at the moment. Otherwise, execute adding a route.
-     * </p>
+     * Processes route updates.
      *
      *
-     * @param routeEntry the route entry to add
+     * @param routeUpdates the route updates to process
      */
      */
-    void processRouteAdd(RouteEntry routeEntry) {
+    void processRouteUpdates(Collection<RouteUpdate> routeUpdates) {
         synchronized (this) {
         synchronized (this) {
-            log.debug("Processing route add: {}", routeEntry);
-
-            Ip4Prefix prefix = routeEntry.prefix();
-            Ip4Address nextHop = null;
-            RouteEntry foundRouteEntry =
-                    bgpRoutes.put(RouteEntry.createBinaryString(prefix),
-                                  routeEntry);
-            if (foundRouteEntry != null) {
-                nextHop = foundRouteEntry.nextHop();
-            }
-
-            if (nextHop != null && !nextHop.equals(routeEntry.nextHop())) {
-                // There was an existing nexthop for this prefix. This update
-                // supersedes that, so we need to remove the old flows for this
-                // prefix from the switches
-                executeRouteDelete(routeEntry);
-            }
-            if (nextHop != null && nextHop.equals(routeEntry.nextHop())) {
-                return;
-            }
-
-            if (routeEntry.nextHop().equals(LOCAL_NEXT_HOP)) {
-                // Route originated by SDN domain
-                // We don't handle these at the moment
-                log.debug("Own route {} to {}",
-                          routeEntry.prefix(), routeEntry.nextHop());
-                return;
+            Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
+                submitIntents = new LinkedList<>();
+            Collection<Ip4Prefix> withdrawPrefixes = new LinkedList<>();
+            MultiPointToSinglePointIntent intent;
+
+            for (RouteUpdate update : routeUpdates) {
+                switch (update.type()) {
+                case UPDATE:
+                    intent = processRouteAdd(update.routeEntry(),
+                                             withdrawPrefixes);
+                    if (intent != null) {
+                        submitIntents.add(Pair.of(update.routeEntry().prefix(),
+                                                  intent));
+                    }
+                    break;
+                case DELETE:
+                    processRouteDelete(update.routeEntry(), withdrawPrefixes);
+                    break;
+                default:
+                    log.error("Unknown update Type: {}", update.type());
+                    break;
+                }
             }
             }
 
 
-            executeRouteAdd(routeEntry);
+            intentSynchronizer.updateRouteIntents(submitIntents,
+                                                  withdrawPrefixes);
         }
         }
     }
     }
 
 
     /**
     /**
-     * Executes adding a route entry.
+     * Processes adding a route entry.
+     * <p>
+     * The route entry is added to the radix tree. If there was an existing
+     * next hop for this prefix, but the next hop was different, then the
+     * old route entry is deleted.
+     * </p>
      * <p>
      * <p>
-     * Find out the egress Interface and MAC address of next hop router for
-     * this route entry. If the MAC address can not be found in ARP cache,
-     * then this prefix will be put in routesWaitingOnArp queue. Otherwise,
-     * new route intent will be created and installed.
+     * NOTE: Currently, we don't handle routes if the next hop is within the
+     * SDN domain.
      * </p>
      * </p>
      *
      *
      * @param routeEntry the route entry to add
      * @param routeEntry the route entry to add
+     * @param withdrawPrefixes the collection of accumulated prefixes whose
+     * intents will be withdrawn
+     * @return the corresponding intent that should be submitted, or null
      */
      */
-    private void executeRouteAdd(RouteEntry routeEntry) {
-        log.debug("Executing route add: {}", routeEntry);
+    private MultiPointToSinglePointIntent processRouteAdd(
+                RouteEntry routeEntry,
+                Collection<Ip4Prefix> withdrawPrefixes) {
+        log.debug("Processing route add: {}", routeEntry);
+
+        Ip4Prefix prefix = routeEntry.prefix();
+        Ip4Address nextHop = null;
+        RouteEntry foundRouteEntry =
+            bgpRoutes.put(RouteEntry.createBinaryString(prefix),
+                          routeEntry);
+        if (foundRouteEntry != null) {
+            nextHop = foundRouteEntry.nextHop();
+        }
 
 
-        // Monitor the IP address so we'll get notified of updates to the MAC
-        // address.
-        hostService.startMonitoringIp(routeEntry.nextHop());
+        if (nextHop != null && !nextHop.equals(routeEntry.nextHop())) {
+            // There was an existing nexthop for this prefix. This update
+            // supersedes that, so we need to remove the old flows for this
+            // prefix from the switches
+            withdrawPrefixes.add(routeEntry.prefix());
+        }
+        if (nextHop != null && nextHop.equals(routeEntry.nextHop())) {
+            return null;
+        }
 
 
-        // See if we know the MAC address of the next hop
-        MacAddress nextHopMacAddress = null;
-        Set<Host> hosts = hostService.getHostsByIp(routeEntry.nextHop());
-        if (!hosts.isEmpty()) {
-            // TODO how to handle if multiple hosts are returned?
-            nextHopMacAddress = hosts.iterator().next().mac();
+        if (routeEntry.nextHop().equals(LOCAL_NEXT_HOP)) {
+            // Route originated by SDN domain
+            // We don't handle these at the moment
+            log.debug("Own route {} to {}",
+                      routeEntry.prefix(), routeEntry.nextHop());
+            return null;
         }
         }
 
 
+        //
+        // Find the MAC address of next hop router for this route entry.
+        // If the MAC address can not be found in ARP cache, then this prefix
+        // will be put in routesWaitingOnArp queue. Otherwise, generate
+        // a new route intent.
+        //
+
+        // Monitor the IP address for updates of the MAC address
+        hostService.startMonitoringIp(routeEntry.nextHop());
+
+        // Check if we know the MAC address of the next hop
+        MacAddress nextHopMacAddress = ip2Mac.get(routeEntry.nextHop());
+        if (nextHopMacAddress == null) {
+            Set<Host> hosts = hostService.getHostsByIp(routeEntry.nextHop());
+            if (!hosts.isEmpty()) {
+                // TODO how to handle if multiple hosts are returned?
+                nextHopMacAddress = hosts.iterator().next().mac();
+            }
+            if (nextHopMacAddress != null) {
+                ip2Mac.put(routeEntry.nextHop(), nextHopMacAddress);
+            }
+        }
         if (nextHopMacAddress == null) {
         if (nextHopMacAddress == null) {
             routesWaitingOnArp.put(routeEntry.nextHop(), routeEntry);
             routesWaitingOnArp.put(routeEntry.nextHop(), routeEntry);
-            return;
+            return null;
         }
         }
-
-        addRouteIntentToNextHop(routeEntry.prefix(),
-                                routeEntry.nextHop(),
-                                nextHopMacAddress);
+        return generateRouteIntent(routeEntry.prefix(), routeEntry.nextHop(),
+                                   nextHopMacAddress);
     }
     }
 
 
     /**
     /**
-     * Adds a route intent given a prefix and a next hop IP address. This
-     * method will find the egress interface for the intent.
+     * Generates a route intent for a prefix, the next hop IP address, and
+     * the next hop MAC address.
+     * <p/>
+     * This method will find the egress interface for the intent.
+     * Intent will match dst IP prefix and rewrite dst MAC address at all other
+     * border switches, then forward packets according to dst MAC address.
      *
      *
      * @param prefix            IP prefix of the route to add
      * @param prefix            IP prefix of the route to add
      * @param nextHopIpAddress  IP address of the next hop
      * @param nextHopIpAddress  IP address of the next hop
      * @param nextHopMacAddress MAC address of the next hop
      * @param nextHopMacAddress MAC address of the next hop
+     * @return the generated intent, or null if no intent should be submitted
      */
      */
-    private void addRouteIntentToNextHop(Ip4Prefix prefix,
-                                         Ip4Address nextHopIpAddress,
-                                         MacAddress nextHopMacAddress) {
+    private MultiPointToSinglePointIntent generateRouteIntent(
+                Ip4Prefix prefix,
+                Ip4Address nextHopIpAddress,
+                MacAddress nextHopMacAddress) {
 
 
         // Find the attachment point (egress interface) of the next hop
         // Find the attachment point (egress interface) of the next hop
         Interface egressInterface;
         Interface egressInterface;
@@ -308,30 +344,17 @@ public class Router implements RouteListener {
             if (egressInterface == null) {
             if (egressInterface == null) {
                 log.warn("No outgoing interface found for {}",
                 log.warn("No outgoing interface found for {}",
                          nextHopIpAddress);
                          nextHopIpAddress);
-                return;
+                return null;
             }
             }
         }
         }
 
 
-        doAddRouteIntent(prefix, egressInterface, nextHopMacAddress);
-    }
-
-    /**
-     * Installs a route intent for a prefix.
-     * <p/>
-     * Intent will match dst IP prefix and rewrite dst MAC address at all other
-     * border switches, then forward packets according to dst MAC address.
-     *
-     * @param prefix            IP prefix from route
-     * @param egressInterface   egress Interface connected to next hop router
-     * @param nextHopMacAddress MAC address of next hop router
-     */
-    private void doAddRouteIntent(Ip4Prefix prefix, Interface egressInterface,
-                                  MacAddress nextHopMacAddress) {
-        log.debug("Adding intent for prefix {}, next hop mac {}",
-                  prefix, nextHopMacAddress);
-
+        //
+        // Generate the intent itself
+        //
         Set<ConnectPoint> ingressPorts = new HashSet<>();
         Set<ConnectPoint> ingressPorts = new HashSet<>();
         ConnectPoint egressPort = egressInterface.connectPoint();
         ConnectPoint egressPort = egressInterface.connectPoint();
+        log.debug("Generating intent for prefix {}, next hop mac {}",
+                  prefix, nextHopMacAddress);
 
 
         for (Interface intf : interfaceService.getInterfaces()) {
         for (Interface intf : interfaceService.getInterfaces()) {
             if (!intf.connectPoint().equals(egressInterface.connectPoint())) {
             if (!intf.connectPoint().equals(egressInterface.connectPoint())) {
@@ -351,51 +374,39 @@ public class Router implements RouteListener {
                 .setEthDst(nextHopMacAddress)
                 .setEthDst(nextHopMacAddress)
                 .build();
                 .build();
 
 
-        MultiPointToSinglePointIntent intent =
-                new MultiPointToSinglePointIntent(appId, selector, treatment,
-                                                  ingressPorts, egressPort);
-
-        intentSynchronizer.submitRouteIntent(prefix, intent);
+        return new MultiPointToSinglePointIntent(appId, selector, treatment,
+                                                 ingressPorts, egressPort);
     }
     }
 
 
     /**
     /**
-     * Executes deleting a route entry.
+     * Processes the deletion of a route entry.
      * <p>
      * <p>
-     * Removes prefix from radix tree, and if successful, then try to delete
-     * the related intent.
+     * The prefix for the routing entry is removed from radix tree.
+     * If the operation is successful, the prefix is added to the collection
+     * of prefixes whose intents that will be withdrawn.
      * </p>
      * </p>
      *
      *
      * @param routeEntry the route entry to delete
      * @param routeEntry the route entry to delete
+     * @param withdrawPrefixes the collection of accumulated prefixes whose
+     * intents will be withdrawn
      */
      */
-    void processRouteDelete(RouteEntry routeEntry) {
-        synchronized (this) {
-            log.debug("Processing route delete: {}", routeEntry);
-            Ip4Prefix prefix = routeEntry.prefix();
-
-            if (bgpRoutes.remove(RouteEntry.createBinaryString(prefix))) {
-                //
-                // Only delete flows if an entry was actually removed from the
-                // tree. If no entry was removed, the <prefix, nexthop> wasn't
-                // there so it's probably already been removed and we don't
-                // need to do anything.
-                //
-                executeRouteDelete(routeEntry);
-            }
-
-            routesWaitingOnArp.remove(routeEntry.nextHop(), routeEntry);
-            // TODO cancel the request in the ARP manager as well
+    private void processRouteDelete(RouteEntry routeEntry,
+                                    Collection<Ip4Prefix> withdrawPrefixes) {
+        log.debug("Processing route delete: {}", routeEntry);
+        Ip4Prefix prefix = routeEntry.prefix();
+
+        if (bgpRoutes.remove(RouteEntry.createBinaryString(prefix))) {
+            //
+            // Only withdraw intents if an entry was actually removed from the
+            // tree. If no entry was removed, the <prefix, nexthop> wasn't
+            // there so it's probably already been removed and we don't
+            // need to do anything.
+            //
+            withdrawPrefixes.add(routeEntry.prefix());
         }
         }
-    }
-
-    /**
-     * Executed deleting a route entry.
-     *
-     * @param routeEntry the route entry to delete
-     */
-    private void executeRouteDelete(RouteEntry routeEntry) {
-        log.debug("Executing route delete: {}", routeEntry);
 
 
-        intentSynchronizer.withdrawRouteIntent(routeEntry.prefix());
+        routesWaitingOnArp.remove(routeEntry.nextHop(), routeEntry);
+        // TODO cancel the request in the ARP manager as well
     }
     }
 
 
     /**
     /**
@@ -418,6 +429,9 @@ public class Router implements RouteListener {
         // while we're pushing intents. If the tree changes, the
         // while we're pushing intents. If the tree changes, the
         // tree and intents could get out of sync.
         // tree and intents could get out of sync.
         synchronized (this) {
         synchronized (this) {
+            Collection<Pair<Ip4Prefix, MultiPointToSinglePointIntent>>
+                submitIntents = new LinkedList<>();
+            MultiPointToSinglePointIntent intent;
 
 
             Set<RouteEntry> routesToPush =
             Set<RouteEntry> routesToPush =
                     routesWaitingOnArp.removeAll(ipAddress);
                     routesWaitingOnArp.removeAll(ipAddress);
@@ -429,18 +443,30 @@ public class Router implements RouteListener {
                 RouteEntry foundRouteEntry =
                 RouteEntry foundRouteEntry =
                         bgpRoutes.getValueForExactKey(binaryString);
                         bgpRoutes.getValueForExactKey(binaryString);
                 if (foundRouteEntry != null &&
                 if (foundRouteEntry != null &&
-                        foundRouteEntry.nextHop().equals(routeEntry.nextHop())) {
+                    foundRouteEntry.nextHop().equals(routeEntry.nextHop())) {
                     // We only push prefix flows if the prefix is still in the
                     // We only push prefix flows if the prefix is still in the
                     // radix tree and the next hop is the same as our
                     // radix tree and the next hop is the same as our
                     // update.
                     // update.
                     // The prefix could have been removed while we were waiting
                     // The prefix could have been removed while we were waiting
                     // for the ARP, or the next hop could have changed.
                     // for the ARP, or the next hop could have changed.
-                    addRouteIntentToNextHop(prefix, ipAddress, macAddress);
+                    intent = generateRouteIntent(prefix, ipAddress,
+                                                 macAddress);
+                    if (intent != null) {
+                        submitIntents.add(Pair.of(prefix, intent));
+                    }
                 } else {
                 } else {
                     log.debug("{} has been revoked before the MAC was resolved",
                     log.debug("{} has been revoked before the MAC was resolved",
-                            routeEntry);
+                              routeEntry);
                 }
                 }
             }
             }
+
+            if (!submitIntents.isEmpty()) {
+                Collection<Ip4Prefix> withdrawPrefixes = new LinkedList<>();
+                intentSynchronizer.updateRouteIntents(submitIntents,
+                                                      withdrawPrefixes);
+            }
+
+            ip2Mac.put(ipAddress, macAddress);
         }
         }
     }
     }
 
 
@@ -469,9 +495,13 @@ public class Router implements RouteListener {
     class InternalHostListener implements HostListener {
     class InternalHostListener implements HostListener {
         @Override
         @Override
         public void event(HostEvent event) {
         public void event(HostEvent event) {
-            if (event.type() == HostEvent.Type.HOST_ADDED ||
-                    event.type() == HostEvent.Type.HOST_UPDATED) {
-                Host host = event.subject();
+            log.debug("Received HostEvent {}", event);
+
+            Host host = event.subject();
+            switch (event.type()) {
+            case HOST_ADDED:
+                // FALLTHROUGH
+            case HOST_UPDATED:
                 for (IpAddress ip : host.ipAddresses()) {
                 for (IpAddress ip : host.ipAddresses()) {
                     Ip4Address ip4Address = ip.getIp4Address();
                     Ip4Address ip4Address = ip.getIp4Address();
                     if (ip4Address == null) {
                     if (ip4Address == null) {
@@ -480,6 +510,19 @@ public class Router implements RouteListener {
                     }
                     }
                     updateMac(ip4Address, host.mac());
                     updateMac(ip4Address, host.mac());
                 }
                 }
+                break;
+            case HOST_REMOVED:
+                for (IpAddress ip : host.ipAddresses()) {
+                    Ip4Address ip4Address = ip.getIp4Address();
+                    if (ip4Address == null) {
+                        // TODO: For now we support only IPv4
+                        continue;
+                    }
+                    ip2Mac.remove(ip4Address);
+                }
+                break;
+            default:
+                break;
             }
             }
         }
         }
     }
     }

@@ -22,6 +22,7 @@ import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.SocketAddress;
 import java.util.Collection;
 import java.util.Collection;
+import java.util.LinkedList;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
@@ -248,18 +249,28 @@ public class BgpSessionManager {
         synchronized void routeUpdates(BgpSession bgpSession,
         synchronized void routeUpdates(BgpSession bgpSession,
                         Collection<BgpRouteEntry> addedBgpRouteEntries,
                         Collection<BgpRouteEntry> addedBgpRouteEntries,
                         Collection<BgpRouteEntry> deletedBgpRouteEntries) {
                         Collection<BgpRouteEntry> deletedBgpRouteEntries) {
+            Collection<RouteUpdate> routeUpdates = new LinkedList<>();
+            RouteUpdate routeUpdate;
+
             if (isShutdown) {
             if (isShutdown) {
                 return;         // Ignore any leftover updates if shutdown
                 return;         // Ignore any leftover updates if shutdown
             }
             }
             // Process the deleted route entries
             // Process the deleted route entries
             for (BgpRouteEntry bgpRouteEntry : deletedBgpRouteEntries) {
             for (BgpRouteEntry bgpRouteEntry : deletedBgpRouteEntries) {
-                processDeletedRoute(bgpSession, bgpRouteEntry);
+                routeUpdate = processDeletedRoute(bgpSession, bgpRouteEntry);
+                if (routeUpdate != null) {
+                    routeUpdates.add(routeUpdate);
+                }
             }
             }
 
 
             // Process the added/updated route entries
             // Process the added/updated route entries
             for (BgpRouteEntry bgpRouteEntry : addedBgpRouteEntries) {
             for (BgpRouteEntry bgpRouteEntry : addedBgpRouteEntries) {
-                processAddedRoute(bgpSession, bgpRouteEntry);
+                routeUpdate = processAddedRoute(bgpSession, bgpRouteEntry);
+                if (routeUpdate != null) {
+                    routeUpdates.add(routeUpdate);
+                }
             }
             }
+            routeListener.update(routeUpdates);
         }
         }
 
 
         /**
         /**
@@ -268,9 +279,11 @@ public class BgpSessionManager {
          * @param bgpSession the BGP session the route entry update was
          * @param bgpSession the BGP session the route entry update was
          * received on
          * received on
          * @param bgpRouteEntry the added/updated route entry
          * @param bgpRouteEntry the added/updated route entry
+         * @return the result route update that should be forwarded to the
+         * Route Listener, or null if no route update should be forwarded
          */
          */
-        private void processAddedRoute(BgpSession bgpSession,
-                                       BgpRouteEntry bgpRouteEntry) {
+        private RouteUpdate processAddedRoute(BgpSession bgpSession,
+                                              BgpRouteEntry bgpRouteEntry) {
             RouteUpdate routeUpdate;
             RouteUpdate routeUpdate;
             BgpRouteEntry bestBgpRouteEntry =
             BgpRouteEntry bestBgpRouteEntry =
                 bgpRoutes.get(bgpRouteEntry.prefix());
                 bgpRoutes.get(bgpRouteEntry.prefix());
@@ -284,9 +297,7 @@ public class BgpSessionManager {
                 bgpRoutes.put(bgpRouteEntry.prefix(), bgpRouteEntry);
                 bgpRoutes.put(bgpRouteEntry.prefix(), bgpRouteEntry);
                 routeUpdate =
                 routeUpdate =
                     new RouteUpdate(RouteUpdate.Type.UPDATE, bgpRouteEntry);
                     new RouteUpdate(RouteUpdate.Type.UPDATE, bgpRouteEntry);
-                // Forward the result route updates to the Route Listener
-                routeListener.update(routeUpdate);
-                return;
+                return routeUpdate;
             }
             }
 
 
             //
             //
@@ -296,7 +307,7 @@ public class BgpSessionManager {
             //
             //
             if (bestBgpRouteEntry.getBgpSession() !=
             if (bestBgpRouteEntry.getBgpSession() !=
                 bgpRouteEntry.getBgpSession()) {
                 bgpRouteEntry.getBgpSession()) {
-                return;
+                return null;            // Nothing to do
             }
             }
 
 
             // Find the next best route
             // Find the next best route
@@ -315,8 +326,7 @@ public class BgpSessionManager {
             bgpRoutes.put(bestBgpRouteEntry.prefix(), bestBgpRouteEntry);
             bgpRoutes.put(bestBgpRouteEntry.prefix(), bestBgpRouteEntry);
             routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
             routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
                                           bestBgpRouteEntry);
                                           bestBgpRouteEntry);
-            // Forward the result route updates to the Route Listener
-            routeListener.update(routeUpdate);
+            return routeUpdate;
         }
         }
 
 
         /**
         /**
@@ -325,9 +335,11 @@ public class BgpSessionManager {
          * @param bgpSession the BGP session the route entry update was
          * @param bgpSession the BGP session the route entry update was
          * received on
          * received on
          * @param bgpRouteEntry the deleted route entry
          * @param bgpRouteEntry the deleted route entry
+         * @return the result route update that should be forwarded to the
+         * Route Listener, or null if no route update should be forwarded
          */
          */
-        private void processDeletedRoute(BgpSession bgpSession,
-                                         BgpRouteEntry bgpRouteEntry) {
+        private RouteUpdate processDeletedRoute(BgpSession bgpSession,
+                                                BgpRouteEntry bgpRouteEntry) {
             RouteUpdate routeUpdate;
             RouteUpdate routeUpdate;
             BgpRouteEntry bestBgpRouteEntry =
             BgpRouteEntry bestBgpRouteEntry =
                 bgpRoutes.get(bgpRouteEntry.prefix());
                 bgpRoutes.get(bgpRouteEntry.prefix());
@@ -340,7 +352,7 @@ public class BgpSessionManager {
             // because we need to check whether this is same object.
             // because we need to check whether this is same object.
             //
             //
             if (bgpRouteEntry != bestBgpRouteEntry) {
             if (bgpRouteEntry != bestBgpRouteEntry) {
-                return;         // Nothing to do
+                return null;            // Nothing to do
             }
             }
 
 
             //
             //
@@ -353,9 +365,7 @@ public class BgpSessionManager {
                               bestBgpRouteEntry);
                               bestBgpRouteEntry);
                 routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
                 routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
                                               bestBgpRouteEntry);
                                               bestBgpRouteEntry);
-                // Forward the result route updates to the Route Listener
-                routeListener.update(routeUpdate);
-                return;
+                return routeUpdate;
             }
             }
 
 
             //
             //
@@ -364,8 +374,7 @@ public class BgpSessionManager {
             bgpRoutes.remove(bgpRouteEntry.prefix());
             bgpRoutes.remove(bgpRouteEntry.prefix());
             routeUpdate = new RouteUpdate(RouteUpdate.Type.DELETE,
             routeUpdate = new RouteUpdate(RouteUpdate.Type.DELETE,
                                           bgpRouteEntry);
                                           bgpRouteEntry);
-            // Forward the result route updates to the Route Listener
-            routeListener.update(routeUpdate);
+            return routeUpdate;
         }
         }
 
 
         /**
         /**

@@ -325,13 +325,13 @@ public class IntentSyncTest extends AbstractIntentTest {
                 .andReturn(IntentState.WITHDRAWING).anyTimes();
                 .andReturn(IntentState.WITHDRAWING).anyTimes();
         expect(intentService.getIntents()).andReturn(intents).anyTimes();
         expect(intentService.getIntents()).andReturn(intents).anyTimes();
 
 
-        IntentOperations.Builder builder = IntentOperations.builder(null); //FIXME null
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
         builder.addWithdrawOperation(intent2.id());
         builder.addWithdrawOperation(intent2.id());
         builder.addWithdrawOperation(intent4.id());
         builder.addWithdrawOperation(intent4.id());
         intentService.execute(TestIntentServiceHelper.eqExceptId(
         intentService.execute(TestIntentServiceHelper.eqExceptId(
                                 builder.build()));
                                 builder.build()));
 
 
-        builder = IntentOperations.builder(null); //FIXME null
+        builder = IntentOperations.builder(APPID);
         builder.addSubmitOperation(intent3);
         builder.addSubmitOperation(intent3);
         builder.addSubmitOperation(intent4Update);
         builder.addSubmitOperation(intent4Update);
         builder.addSubmitOperation(intent6);
         builder.addSubmitOperation(intent6);

@@ -566,7 +566,7 @@ public class PeerConnectivityManagerTest extends AbstractIntentTest {
         reset(intentService);
         reset(intentService);
 
 
         // Setup the expected intents
         // Setup the expected intents
-        IntentOperations.Builder builder = IntentOperations.builder(null); //FIXME null
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
         for (Intent intent : intentList) {
         for (Intent intent : intentList) {
             builder.addSubmitOperation(intent);
             builder.addSubmitOperation(intent);
         }
         }
@@ -601,9 +601,8 @@ public class PeerConnectivityManagerTest extends AbstractIntentTest {
         replay(configInfoService);
         replay(configInfoService);
 
 
         reset(intentService);
         reset(intentService);
-        IntentOperations.Builder builder = IntentOperations.builder(null); //FIXME null
-        intentService.execute(TestIntentServiceHelper.eqExceptId(
-                builder.build()));
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        intentService.execute(builder.build());
         replay(intentService);
         replay(intentService);
         peerConnectivityManager.start();
         peerConnectivityManager.start();
         verify(intentService);
         verify(intentService);
@@ -627,9 +626,8 @@ public class PeerConnectivityManagerTest extends AbstractIntentTest {
         replay(configInfoService);
         replay(configInfoService);
 
 
         reset(intentService);
         reset(intentService);
-        IntentOperations.Builder builder = IntentOperations.builder(null); //FIXME null
-        intentService.execute(TestIntentServiceHelper.eqExceptId(
-                builder.build()));
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        intentService.execute(builder.build());
         replay(intentService);
         replay(intentService);
         peerConnectivityManager.start();
         peerConnectivityManager.start();
         verify(intentService);
         verify(intentService);

@@ -25,6 +25,7 @@ import static org.easymock.EasyMock.verify;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertTrue;
 
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Map;
@@ -50,6 +51,7 @@ import org.onlab.onos.net.host.HostListener;
 import org.onlab.onos.net.host.HostService;
 import org.onlab.onos.net.host.HostService;
 import org.onlab.onos.net.host.InterfaceIpAddress;
 import org.onlab.onos.net.host.InterfaceIpAddress;
 import org.onlab.onos.net.intent.Intent;
 import org.onlab.onos.net.intent.Intent;
+import org.onlab.onos.net.intent.IntentOperations;
 import org.onlab.onos.net.intent.IntentService;
 import org.onlab.onos.net.intent.IntentService;
 import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
 import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
 import org.onlab.onos.net.intent.AbstractIntentTest;
 import org.onlab.onos.net.intent.AbstractIntentTest;
@@ -234,7 +236,7 @@ public class RouterTest extends AbstractIntentTest {
      * This method tests adding a route entry.
      * This method tests adding a route entry.
      */
      */
     @Test
     @Test
-    public void testProcessRouteAdd() throws TestUtilsException {
+    public void testRouteAdd() throws TestUtilsException {
         // Construct a route entry
         // Construct a route entry
         RouteEntry routeEntry = new RouteEntry(
         RouteEntry routeEntry = new RouteEntry(
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Prefix.valueOf("1.1.1.0/24"),
@@ -261,13 +263,19 @@ public class RouterTest extends AbstractIntentTest {
 
 
         // Set up test expectation
         // Set up test expectation
         reset(intentService);
         reset(intentService);
-        intentService.submit(TestIntentServiceHelper.eqExceptId(intent));
+        // Setup the expected intents
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addSubmitOperation(intent);
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call the processRouteAdd() method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteAdd(routeEntry);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
+                                                  routeEntry);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         // Verify
         // Verify
         assertEquals(router.getRoutes().size(), 1);
         assertEquals(router.getRoutes().size(), 1);
@@ -289,32 +297,16 @@ public class RouterTest extends AbstractIntentTest {
     @Test
     @Test
     public void testRouteUpdate() throws TestUtilsException {
     public void testRouteUpdate() throws TestUtilsException {
         // Firstly add a route
         // Firstly add a route
-        testProcessRouteAdd();
+        testRouteAdd();
+
+        Intent addedIntent =
+            intentSynchronizer.getRouteIntents().iterator().next();
 
 
         // Construct the existing route entry
         // Construct the existing route entry
         RouteEntry routeEntry = new RouteEntry(
         RouteEntry routeEntry = new RouteEntry(
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Address.valueOf("192.168.10.1"));
                 Ip4Address.valueOf("192.168.10.1"));
 
 
-        // Construct the existing MultiPointToSinglePointIntent intent
-        TrafficSelector.Builder selectorBuilder =
-                DefaultTrafficSelector.builder();
-        selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
-                routeEntry.prefix());
-
-        TrafficTreatment.Builder treatmentBuilder =
-                DefaultTrafficTreatment.builder();
-        treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
-
-        Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
-        ingressPoints.add(SW2_ETH1);
-        ingressPoints.add(SW3_ETH1);
-
-        MultiPointToSinglePointIntent intent =
-                new MultiPointToSinglePointIntent(APPID,
-                        selectorBuilder.build(), treatmentBuilder.build(),
-                        ingressPoints, SW1_ETH1);
-
         // Start to construct a new route entry and new intent
         // Start to construct a new route entry and new intent
         RouteEntry routeEntryUpdate = new RouteEntry(
         RouteEntry routeEntryUpdate = new RouteEntry(
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Prefix.valueOf("1.1.1.0/24"),
@@ -343,14 +335,23 @@ public class RouterTest extends AbstractIntentTest {
 
 
         // Set up test expectation
         // Set up test expectation
         reset(intentService);
         reset(intentService);
-        intentService.withdraw(TestIntentServiceHelper.eqExceptId(intent));
-        intentService.submit(TestIntentServiceHelper.eqExceptId(intentNew));
+        // Setup the expected intents
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addWithdrawOperation(addedIntent.id());
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
+        builder = IntentOperations.builder(APPID);
+        builder.addSubmitOperation(intentNew);
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call the processRouteAdd() method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteAdd(routeEntryUpdate);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
+                                                  routeEntryUpdate);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         // Verify
         // Verify
         assertEquals(router.getRoutes().size(), 1);
         assertEquals(router.getRoutes().size(), 1);
@@ -368,43 +369,33 @@ public class RouterTest extends AbstractIntentTest {
      * This method tests deleting a route entry.
      * This method tests deleting a route entry.
      */
      */
     @Test
     @Test
-    public void testProcessRouteDelete() throws TestUtilsException {
+    public void testRouteDelete() throws TestUtilsException {
         // Firstly add a route
         // Firstly add a route
-        testProcessRouteAdd();
+        testRouteAdd();
+
+        Intent addedIntent =
+            intentSynchronizer.getRouteIntents().iterator().next();
 
 
         // Construct the existing route entry
         // Construct the existing route entry
         RouteEntry routeEntry = new RouteEntry(
         RouteEntry routeEntry = new RouteEntry(
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Prefix.valueOf("1.1.1.0/24"),
                 Ip4Address.valueOf("192.168.10.1"));
                 Ip4Address.valueOf("192.168.10.1"));
 
 
-        // Construct the existing MultiPointToSinglePointIntent intent
-        TrafficSelector.Builder selectorBuilder =
-                DefaultTrafficSelector.builder();
-        selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
-                routeEntry.prefix());
-
-        TrafficTreatment.Builder treatmentBuilder =
-                DefaultTrafficTreatment.builder();
-        treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
-
-        Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
-        ingressPoints.add(SW2_ETH1);
-        ingressPoints.add(SW3_ETH1);
-
-        MultiPointToSinglePointIntent intent =
-                new MultiPointToSinglePointIntent(APPID,
-                        selectorBuilder.build(), treatmentBuilder.build(),
-                        ingressPoints, SW1_ETH1);
-
         // Set up expectation
         // Set up expectation
         reset(intentService);
         reset(intentService);
-        intentService.withdraw(TestIntentServiceHelper.eqExceptId(intent));
+        // Setup the expected intents
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addWithdrawOperation(addedIntent.id());
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call route deleting method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteDelete(routeEntry);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.DELETE,
+                                                  routeEntry);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         // Verify
         // Verify
         assertEquals(router.getRoutes().size(), 0);
         assertEquals(router.getRoutes().size(), 0);
@@ -428,10 +419,12 @@ public class RouterTest extends AbstractIntentTest {
         reset(intentService);
         reset(intentService);
         replay(intentService);
         replay(intentService);
 
 
-        // Call the processRouteAdd() method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteAdd(routeEntry);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
+                                                  routeEntry);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         // Verify
         // Verify
         assertEquals(router.getRoutes().size(), 1);
         assertEquals(router.getRoutes().size(), 1);

@@ -24,6 +24,7 @@ import static org.easymock.EasyMock.verify;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertTrue;
 
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Map;
@@ -50,6 +51,7 @@ import org.onlab.onos.net.host.HostEvent;
 import org.onlab.onos.net.host.HostService;
 import org.onlab.onos.net.host.HostService;
 import org.onlab.onos.net.host.InterfaceIpAddress;
 import org.onlab.onos.net.host.InterfaceIpAddress;
 import org.onlab.onos.net.intent.Intent;
 import org.onlab.onos.net.intent.Intent;
+import org.onlab.onos.net.intent.IntentOperations;
 import org.onlab.onos.net.intent.IntentService;
 import org.onlab.onos.net.intent.IntentService;
 import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
 import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
 import org.onlab.onos.net.intent.AbstractIntentTest;
 import org.onlab.onos.net.intent.AbstractIntentTest;
@@ -196,7 +198,7 @@ public class RouterTestWithAsyncArp extends AbstractIntentTest {
      * This method tests adding a route entry.
      * This method tests adding a route entry.
      */
      */
     @Test
     @Test
-    public void testProcessRouteAdd() throws TestUtilsException {
+    public void testRouteAdd() throws TestUtilsException {
 
 
         // Construct a route entry
         // Construct a route entry
         RouteEntry routeEntry = new RouteEntry(
         RouteEntry routeEntry = new RouteEntry(
@@ -214,13 +216,18 @@ public class RouterTestWithAsyncArp extends AbstractIntentTest {
         replay(hostService);
         replay(hostService);
 
 
         reset(intentService);
         reset(intentService);
-        intentService.submit(TestIntentServiceHelper.eqExceptId(intent));
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addSubmitOperation(intent);
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call the processRouteAdd() method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteAdd(routeEntry);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
+                                                  routeEntry);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         Host host = new DefaultHost(ProviderId.NONE, HostId.NONE,
         Host host = new DefaultHost(ProviderId.NONE, HostId.NONE,
                 MacAddress.valueOf("00:00:00:00:00:01"), VlanId.NONE,
                 MacAddress.valueOf("00:00:00:00:00:01"), VlanId.NONE,
@@ -299,14 +306,22 @@ public class RouterTestWithAsyncArp extends AbstractIntentTest {
         replay(hostService);
         replay(hostService);
 
 
         reset(intentService);
         reset(intentService);
-        intentService.withdraw(TestIntentServiceHelper.eqExceptId(intent));
-        intentService.submit(TestIntentServiceHelper.eqExceptId(intentNew));
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addWithdrawOperation(intent.id());
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
+        builder = IntentOperations.builder(APPID);
+        builder.addSubmitOperation(intentNew);
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call the processRouteAdd() method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteAdd(routeEntryUpdate);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.UPDATE,
+                                                  routeEntryUpdate);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         Host host = new DefaultHost(ProviderId.NONE, HostId.NONE,
         Host host = new DefaultHost(ProviderId.NONE, HostId.NONE,
                 MacAddress.valueOf("00:00:00:00:00:02"), VlanId.NONE,
                 MacAddress.valueOf("00:00:00:00:00:02"), VlanId.NONE,
@@ -334,7 +349,7 @@ public class RouterTestWithAsyncArp extends AbstractIntentTest {
      * This method tests deleting a route entry.
      * This method tests deleting a route entry.
      */
      */
     @Test
     @Test
-    public void testProcessRouteDelete() throws TestUtilsException {
+    public void testRouteDelete() throws TestUtilsException {
 
 
         // Construct the existing route entry
         // Construct the existing route entry
         RouteEntry routeEntry = new RouteEntry(
         RouteEntry routeEntry = new RouteEntry(
@@ -351,13 +366,18 @@ public class RouterTestWithAsyncArp extends AbstractIntentTest {
 
 
         // Set up expectation
         // Set up expectation
         reset(intentService);
         reset(intentService);
-        intentService.withdraw(TestIntentServiceHelper.eqExceptId(intent));
+        IntentOperations.Builder builder = IntentOperations.builder(APPID);
+        builder.addWithdrawOperation(intent.id());
+        intentService.execute(TestIntentServiceHelper.eqExceptId(
+                                builder.build()));
         replay(intentService);
         replay(intentService);
 
 
-        // Call route deleting method in Router class
+        // Call the processRouteUpdates() method in Router class
         intentSynchronizer.leaderChanged(true);
         intentSynchronizer.leaderChanged(true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
-        router.processRouteDelete(routeEntry);
+        RouteUpdate routeUpdate = new RouteUpdate(RouteUpdate.Type.DELETE,
+                                                  routeEntry);
+        router.processRouteUpdates(Collections.<RouteUpdate>singletonList(routeUpdate));
 
 
         // Verify
         // Verify
         assertEquals(router.getRoutes().size(), 0);
         assertEquals(router.getRoutes().size(), 0);

@@ -236,9 +236,7 @@ public class SdnIpTest extends AbstractIntentTest {
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
 
 
         // Add route updates
         // Add route updates
-        for (RouteUpdate update : routeUpdates) {
-            router.processRouteAdd(update.routeEntry());
-        }
+        router.processRouteUpdates(routeUpdates);
 
 
         latch.await(5000, TimeUnit.MILLISECONDS);
         latch.await(5000, TimeUnit.MILLISECONDS);
 
 
@@ -304,17 +302,19 @@ public class SdnIpTest extends AbstractIntentTest {
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
         TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
 
 
         // Send the add updates first
         // Send the add updates first
-        for (RouteUpdate update : routeUpdates) {
-            router.processRouteAdd(update.routeEntry());
-        }
+        router.processRouteUpdates(routeUpdates);
 
 
         // Give some time to let the intents be submitted
         // Give some time to let the intents be submitted
         installCount.await(5000, TimeUnit.MILLISECONDS);
         installCount.await(5000, TimeUnit.MILLISECONDS);
 
 
         // Send the DELETE updates
         // Send the DELETE updates
+        List<RouteUpdate> deleteRouteUpdates = new ArrayList<>();
         for (RouteUpdate update : routeUpdates) {
         for (RouteUpdate update : routeUpdates) {
-            router.processRouteDelete(update.routeEntry());
+            RouteUpdate deleteUpdate = new RouteUpdate(RouteUpdate.Type.DELETE,
+                                                       update.routeEntry());
+            deleteRouteUpdates.add(deleteUpdate);
         }
         }
+        router.processRouteUpdates(deleteRouteUpdates);
 
 
         deleteCount.await(5000, TimeUnit.MILLISECONDS);
         deleteCount.await(5000, TimeUnit.MILLISECONDS);
 
 

@@ -82,7 +82,7 @@ public class BgpSessionManagerTest {
      */
      */
     private class DummyRouteListener implements RouteListener {
     private class DummyRouteListener implements RouteListener {
         @Override
         @Override
-        public void update(RouteUpdate routeUpdate) {
+        public void update(Collection<RouteUpdate> routeUpdate) {
             // Nothing to do
             // Nothing to do
         }
         }
     }
     }