[Falcon] Componentize IntentSynchronizer and SdnIpFib.

Change-Id: Ic384ce00572ae1e4bbf94b4de814cea3499d3828

@@ -47,9 +47,9 @@ import org.onosproject.net.packet.PacketContext;
 import org.onosproject.net.packet.PacketProcessor;
 import org.onosproject.net.packet.PacketProcessor;
 import org.onosproject.net.packet.PacketService;
 import org.onosproject.net.packet.PacketService;
 import org.onosproject.routing.IntentRequestListener;
 import org.onosproject.routing.IntentRequestListener;
+import org.onosproject.routing.IntentSynchronizationService;
 import org.onosproject.routing.RouteEntry;
 import org.onosproject.routing.RouteEntry;
 import org.onosproject.routing.RoutingService;
 import org.onosproject.routing.RoutingService;
-import org.onosproject.routing.SdnIpService;
 import org.onosproject.routing.config.RoutingConfigurationService;
 import org.onosproject.routing.config.RoutingConfigurationService;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 
 
@@ -86,7 +86,7 @@ public class SdnIpReactiveRouting {
     protected RoutingService routingService;
     protected RoutingService routingService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected SdnIpService sdnIpService;
+    protected IntentSynchronizationService intentSynchronizer;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected RoutingConfigurationService config;
     protected RoutingConfigurationService config;
@@ -109,8 +109,7 @@ public class SdnIpReactiveRouting {
         appId = coreService.registerApplication(APP_NAME);
         appId = coreService.registerApplication(APP_NAME);
 
 
         intentRequestListener = new ReactiveRoutingFib(appId, hostService,
         intentRequestListener = new ReactiveRoutingFib(appId, hostService,
-                config, interfaceService,
-                sdnIpService.getIntentSynchronizationService());
+                config, interfaceService, intentSynchronizer);
 
 
         packetService.addProcessor(processor, PacketProcessor.director(2));
         packetService.addProcessor(processor, PacketProcessor.director(2));
         requestIntercepts();
         requestIntercepts();

 /*
 /*
- * Copyright 2014-2015 Open Networking Laboratory
+ * Copyright 2015 Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.routing;
 package org.onosproject.routing;
 
 
 /**
 /**
- * Service interface exported by SDN-IP.
+ * Administrative APIs for managing intent synchronization.
  */
  */
-public interface SdnIpService {
+public interface IntentSynchronizationAdminService {
 
 
     /**
     /**
      * Changes whether this SDN-IP instance is the primary or not based on the
      * Changes whether this SDN-IP instance is the primary or not based on the
@@ -29,11 +30,7 @@ public interface SdnIpService {
     void modifyPrimary(boolean isPrimary);
     void modifyPrimary(boolean isPrimary);
 
 
     /**
     /**
-     * Gets the intent synchronization service.
-     *
-     * @return intent synchronization service
+     * Withdraws all intents.
      */
      */
-    // TODO fix service resolution in SDN-IP
-    IntentSynchronizationService getIntentSynchronizationService();
-
+    void removeIntents();
 }
 }

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.routing;
+
+import org.onlab.packet.IpAddress;
+
+import java.util.Collection;
+
+/**
+ * Routing service adapter.
+ */
+public class RoutingServiceAdapter implements RoutingService {
+
+    @Override
+    public void start() {
+
+    }
+
+    @Override
+    public void addFibListener(FibListener fibListener) {
+
+    }
+
+    @Override
+    public void stop() {
+
+    }
+
+    @Override
+    public Collection<RouteEntry> getRoutes4() {
+        return null;
+    }
+
+    @Override
+    public Collection<RouteEntry> getRoutes6() {
+        return null;
+    }
+
+    @Override
+    public RouteEntry getLongestMatchableRouteEntry(IpAddress ipAddress) {
+        return null;
+    }
+}

@@ -35,7 +35,6 @@ import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
 import org.onosproject.core.CoreService;
 import org.onosproject.core.CoreService;
-import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.net.Host;
 import org.onosproject.net.Host;
 import org.onosproject.net.host.HostEvent;
 import org.onosproject.net.host.HostEvent;
 import org.onosproject.net.host.HostListener;
 import org.onosproject.net.host.HostListener;
@@ -107,9 +106,6 @@ public class Router implements RoutingService {
     protected BgpService bgpService;
     protected BgpService bgpService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected InterfaceService interfaceService;
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected RoutingConfigurationService routingConfigurationService;
     protected RoutingConfigurationService routingConfigurationService;
 
 
     private ExecutorService bgpUpdatesExecutor;
     private ExecutorService bgpUpdatesExecutor;
@@ -123,7 +119,7 @@ public class Router implements RoutingService {
                 new DefaultByteArrayNodeFactory());
                 new DefaultByteArrayNodeFactory());
 
 
         routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
         routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
-                HashMultimap.<IpAddress, RouteEntry>create());
+                HashMultimap.create());
 
 
         coreService.registerApplication(ROUTER_APP_ID);
         coreService.registerApplication(ROUTER_APP_ID);
 
 

@@ -58,7 +58,15 @@
 
 
         <dependency>
         <dependency>
             <groupId>org.onosproject</groupId>
             <groupId>org.onosproject</groupId>
-            <artifactId>onos-app-routing</artifactId>
+            <artifactId>onos-app-routing-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-app-routing-api</artifactId>
+            <scope>test</scope>
+            <classifier>tests</classifier>
             <version>${project.version}</version>
             <version>${project.version}</version>
         </dependency>
         </dependency>
 
 

@@ -15,101 +15,117 @@
  */
  */
 package org.onosproject.sdnip;
 package org.onosproject.sdnip;
 
 
-import static java.util.concurrent.Executors.newSingleThreadExecutor;
-import static org.onlab.util.Tools.groupedThreads;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onosproject.cluster.ClusterService;
+import org.onosproject.cluster.LeadershipEvent;
+import org.onosproject.cluster.LeadershipEventListener;
+import org.onosproject.cluster.LeadershipService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.IntentService;
+import org.onosproject.net.intent.IntentState;
+import org.onosproject.net.intent.Key;
+import org.onosproject.routing.IntentSynchronizationAdminService;
+import org.onosproject.routing.IntentSynchronizationService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ExecutorService;
 
 
-import org.onosproject.core.ApplicationId;
-import org.onosproject.net.intent.Intent;
-import org.onosproject.net.intent.IntentService;
-import org.onosproject.net.intent.IntentState;
 import org.onosproject.net.intent.IntentUtils;
 import org.onosproject.net.intent.IntentUtils;
-import org.onosproject.net.intent.Key;
-import org.onosproject.routing.IntentSynchronizationService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import static java.util.concurrent.Executors.newSingleThreadExecutor;
+import static org.onlab.util.Tools.groupedThreads;
 
 
 /**
 /**
- * Synchronizes intents between the in-memory intent store and the
- * IntentService.
+ * Synchronizes intents between an in-memory intent store and the IntentService.
  */
  */
-public class IntentSynchronizer implements IntentSynchronizationService {
+@Service
+@Component(immediate = true)
+public class IntentSynchronizer implements IntentSynchronizationService,
+        IntentSynchronizationAdminService {
+
+    private static final Logger log = LoggerFactory.getLogger(IntentSynchronizer.class);
+
+    private static final String APP_NAME = "org.onosproject.intentsynchronizer";
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
 
 
-    private static final Logger log =
-        LoggerFactory.getLogger(IntentSynchronizer.class);
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected LeadershipService leadershipService;
 
 
-    private final ApplicationId appId;
-    private final IntentService intentService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected ClusterService clusterService;
 
 
-    private final Map<Key, Intent> intents;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected IntentService intentService;
+
+    private ApplicationId appId;
+
+    private final InternalLeadershipListener leadershipEventListener =
+            new InternalLeadershipListener();
+
+    private final Map<Key, Intent> intents = new ConcurrentHashMap<>();
+
+    private ExecutorService intentsSynchronizerExecutor;
 
 
-    //
-    // State to deal with the Leader election and pushing Intents
-    //
-    private final ExecutorService intentsSynchronizerExecutor;
     private volatile boolean isElectedLeader = false;
     private volatile boolean isElectedLeader = false;
     private volatile boolean isActivatedLeader = false;
     private volatile boolean isActivatedLeader = false;
 
 
-    /**
-     * Class constructor.
-     *
-     * @param appId the Application ID
-     * @param intentService the intent service
-     */
-    public IntentSynchronizer(ApplicationId appId, IntentService intentService) {
-        this(appId, intentService,
-                newSingleThreadExecutor(groupedThreads("onos/" + appId, "sync")));
-    }
+    @Activate
+    public void activate() {
+        intentsSynchronizerExecutor = createExecutor();
 
 
-    /**
-     * Class constructor.
-     *
-     * @param appId the Application ID
-     * @param intentService the intent service
-     * @param executorService executor service for synchronization thread
-     */
-    public IntentSynchronizer(ApplicationId appId, IntentService intentService,
-                       ExecutorService executorService) {
-        this.appId = appId;
-        this.intentService = intentService;
+        this.appId = coreService.registerApplication(APP_NAME);
 
 
-        intents = new ConcurrentHashMap<>();
+        leadershipService.addListener(leadershipEventListener);
+        leadershipService.runForLeadership(appId.name());
 
 
-        intentsSynchronizerExecutor = executorService;
+        log.info("Started");
     }
     }
 
 
-    /**
-     * Starts the synchronizer.
-     */
-    public void start() {
-
-    }
+    @Deactivate
+    public void deactivate() {
+        leadershipService.withdraw(appId.name());
+        leadershipService.removeListener(leadershipEventListener);
 
 
-    /**
-     * Stops the synchronizer.
-     */
-    public void stop() {
         synchronized (this) {
         synchronized (this) {
-            // Stop the thread(s)
             intentsSynchronizerExecutor.shutdownNow();
             intentsSynchronizerExecutor.shutdownNow();
-            log.info("Intents Synchronizer Executor shutdown completed");
-
         }
         }
+
+        log.info("Stopped");
     }
     }
 
 
     /**
     /**
-     * Withdraws all intents.
+     * Creates an executor that will be used for synchronization tasks.
+     * <p>
+     * Can be overridden to change the type of executor used.
+     * </p>
+     *
+     * @return executor service
      */
      */
+    protected ExecutorService createExecutor() {
+        return newSingleThreadExecutor(groupedThreads("onos/" + appId, "sync"));
+    }
+
+    @Override
     public void removeIntents() {
     public void removeIntents() {
         if (!isElectedLeader) {
         if (!isElectedLeader) {
-            // only leader will withdraw intents
+            // Only leader will withdraw intents
             return;
             return;
         }
         }
 
 
@@ -152,18 +168,19 @@ public class IntentSynchronizer implements IntentSynchronizationService {
      *
      *
      * @param isLeader true if this instance is now the leader, otherwise false
      * @param isLeader true if this instance is now the leader, otherwise false
      */
      */
-    public void leaderChanged(boolean isLeader) {
+    private void leaderChanged(boolean isLeader) {
         log.debug("Leader changed: {}", isLeader);
         log.debug("Leader changed: {}", isLeader);
 
 
         if (!isLeader) {
         if (!isLeader) {
             this.isElectedLeader = false;
             this.isElectedLeader = false;
             this.isActivatedLeader = false;
             this.isActivatedLeader = false;
-            return;                     // Nothing to do
+            // Nothing to do
+            return;
         }
         }
         this.isActivatedLeader = false;
         this.isActivatedLeader = false;
         this.isElectedLeader = true;
         this.isElectedLeader = true;
 
 
-        // Run the synchronization method off-thread
+        // Run the synchronization task
         intentsSynchronizerExecutor.execute(this::synchronizeIntents);
         intentsSynchronizerExecutor.execute(this::synchronizeIntents);
     }
     }
 
 
@@ -232,10 +249,49 @@ public class IntentSynchronizer implements IntentSynchronizationService {
         }
         }
 
 
         if (isElectedLeader) {
         if (isElectedLeader) {
-            isActivatedLeader = true;       // Allow push of Intents
+            // Allow push of Intents
+            isActivatedLeader = true;
         } else {
         } else {
             isActivatedLeader = false;
             isActivatedLeader = false;
         }
         }
         log.debug("Intent synchronization completed");
         log.debug("Intent synchronization completed");
     }
     }
+
+    @Override
+    public void modifyPrimary(boolean isPrimary) {
+        leaderChanged(isPrimary);
+    }
+
+    /**
+     * A listener for leadership events.
+     */
+    private class InternalLeadershipListener implements LeadershipEventListener {
+
+        @Override
+        public void event(LeadershipEvent event) {
+            if (!event.subject().topic().equals(appId.name())) {
+                // Not our topic: ignore
+                return;
+            }
+            if (!Objects.equals(event.subject().leader(),
+                    clusterService.getLocalNode().id())) {
+                // The event is not about this instance: ignore
+                return;
+            }
+
+            switch (event.type()) {
+            case LEADER_ELECTED:
+                log.info("IntentSynchronizer gained leadership");
+                leaderChanged(true);
+                break;
+            case LEADER_BOOTED:
+                log.info("IntentSynchronizer lost leadership");
+                leaderChanged(false);
+                break;
+            case LEADER_REELECTED:
+            default:
+                break;
+            }
+        }
+    }
 }
 }

@@ -15,136 +15,79 @@
  */
  */
 package org.onosproject.sdnip;
 package org.onosproject.sdnip;
 
 
-import static org.slf4j.LoggerFactory.getLogger;
-
-import java.util.Objects;
-
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
-import org.apache.felix.scr.annotations.Service;
 import org.onosproject.app.ApplicationService;
 import org.onosproject.app.ApplicationService;
-import org.onosproject.cluster.ClusterService;
-import org.onosproject.cluster.ControllerNode;
-import org.onosproject.cluster.LeadershipEvent;
-import org.onosproject.cluster.LeadershipEventListener;
-import org.onosproject.cluster.LeadershipService;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.CoreService;
 import org.onosproject.core.CoreService;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.net.config.NetworkConfigService;
 import org.onosproject.net.config.NetworkConfigService;
-import org.onosproject.net.host.HostService;
-import org.onosproject.net.intent.IntentService;
+import org.onosproject.routing.IntentSynchronizationAdminService;
 import org.onosproject.routing.IntentSynchronizationService;
 import org.onosproject.routing.IntentSynchronizationService;
 import org.onosproject.routing.RoutingService;
 import org.onosproject.routing.RoutingService;
-import org.onosproject.routing.SdnIpService;
-import org.onosproject.routing.config.RoutingConfigurationService;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 
 
+import static org.slf4j.LoggerFactory.getLogger;
+
 /**
 /**
  * Component for the SDN-IP peering application.
  * Component for the SDN-IP peering application.
  */
  */
 @Component(immediate = true)
 @Component(immediate = true)
-@Service
-public class SdnIp implements SdnIpService {
+public class SdnIp {
 
 
-    private static final String SDN_IP_APP = "org.onosproject.sdnip";
+    public static final String SDN_IP_APP = "org.onosproject.sdnip";
     private final Logger log = getLogger(getClass());
     private final Logger log = getLogger(getClass());
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected CoreService coreService;
     protected CoreService coreService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected IntentService intentService;
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected ApplicationService applicationService;
     protected ApplicationService applicationService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected HostService hostService;
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected ClusterService clusterService;
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected LeadershipService leadershipService;
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected RoutingService routingService;
+    protected NetworkConfigService networkConfigService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected RoutingConfigurationService config;
+    protected InterfaceService interfaceService;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected NetworkConfigService networkConfigService;
+    protected IntentSynchronizationService intentSynchronizer;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected InterfaceService interfaceService;
+    protected IntentSynchronizationAdminService intentSynchronizerAdmin;
 
 
-    private IntentSynchronizer intentSynchronizer;
     private PeerConnectivityManager peerConnectivity;
     private PeerConnectivityManager peerConnectivity;
-    private SdnIpFib fib;
 
 
-    private LeadershipEventListener leadershipEventListener =
-            new InnerLeadershipEventListener();
     private ApplicationId appId;
     private ApplicationId appId;
-    private ControllerNode localControllerNode;
 
 
     @Activate
     @Activate
     protected void activate() {
     protected void activate() {
-        log.info("SDN-IP started");
-
         appId = coreService.registerApplication(SDN_IP_APP);
         appId = coreService.registerApplication(SDN_IP_APP);
 
 
-        localControllerNode = clusterService.getLocalNode();
-
-        intentSynchronizer = new IntentSynchronizer(appId, intentService);
-        intentSynchronizer.start();
-
         peerConnectivity = new PeerConnectivityManager(appId,
         peerConnectivity = new PeerConnectivityManager(appId,
                                                        intentSynchronizer,
                                                        intentSynchronizer,
                                                        networkConfigService,
                                                        networkConfigService,
-                coreService.getAppId(RoutingService.ROUTER_APP_ID),
+                coreService.registerApplication(RoutingService.ROUTER_APP_ID),
                                                        interfaceService);
                                                        interfaceService);
         peerConnectivity.start();
         peerConnectivity.start();
 
 
-        fib = new SdnIpFib(appId, interfaceService, intentSynchronizer);
-
-        routingService.addFibListener(fib);
-        routingService.start();
-
-        leadershipService.addListener(leadershipEventListener);
-        leadershipService.runForLeadership(appId.name());
-
+        // TODO fix removing intents
         applicationService.registerDeactivateHook(appId,
         applicationService.registerDeactivateHook(appId,
-                intentSynchronizer::removeIntents);
+                intentSynchronizerAdmin::removeIntents);
 
 
+        log.info("SDN-IP started");
     }
     }
 
 
     @Deactivate
     @Deactivate
     protected void deactivate() {
     protected void deactivate() {
-        routingService.stop();
         peerConnectivity.stop();
         peerConnectivity.stop();
-        intentSynchronizer.stop();
-
-        leadershipService.withdraw(appId.name());
-        leadershipService.removeListener(leadershipEventListener);
 
 
         log.info("SDN-IP Stopped");
         log.info("SDN-IP Stopped");
     }
     }
 
 
-    @Override
-    public void modifyPrimary(boolean isPrimary) {
-        intentSynchronizer.leaderChanged(isPrimary);
-    }
-
-    @Override
-    public IntentSynchronizationService getIntentSynchronizationService() {
-        return intentSynchronizer;
-    }
-
     /**
     /**
      * Converts DPIDs of the form xx:xx:xx:xx:xx:xx:xx to OpenFlow provider
      * Converts DPIDs of the form xx:xx:xx:xx:xx:xx:xx to OpenFlow provider
      * device URIs.
      * device URIs.
@@ -156,38 +99,5 @@ public class SdnIp implements SdnIpService {
         return "of:" + dpid.replace(":", "");
         return "of:" + dpid.replace(":", "");
     }
     }
 
 
-    /**
-     * A listener for Leadership Events.
-     */
-    private class InnerLeadershipEventListener
-        implements LeadershipEventListener {
-
-        @Override
-        public void event(LeadershipEvent event) {
-            log.debug("Leadership Event: time = {} type = {} event = {}",
-                      event.time(), event.type(), event);
-
-            if (!event.subject().topic().equals(appId.name())) {
-                return;         // Not our topic: ignore
-            }
-            if (!Objects.equals(event.subject().leader(), localControllerNode.id())) {
-                return;         // The event is not about this instance: ignore
-            }
-
-            switch (event.type()) {
-            case LEADER_ELECTED:
-                log.info("SDN-IP Leader Elected");
-                intentSynchronizer.leaderChanged(true);
-                break;
-            case LEADER_BOOTED:
-                log.info("SDN-IP Leader Lost Election");
-                intentSynchronizer.leaderChanged(false);
-                break;
-            case LEADER_REELECTED:
-                break;
-            default:
-                break;
-            }
-        }
-    }
+
 }
 }

@@ -17,12 +17,18 @@
 package org.onosproject.sdnip;
 package org.onosproject.sdnip;
 
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableList;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.VlanId;
 import org.onlab.packet.VlanId;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.ConnectPoint;
@@ -37,6 +43,7 @@ import org.onosproject.net.intent.constraint.PartialFailureConstraint;
 import org.onosproject.routing.FibListener;
 import org.onosproject.routing.FibListener;
 import org.onosproject.routing.FibUpdate;
 import org.onosproject.routing.FibUpdate;
 import org.onosproject.routing.IntentSynchronizationService;
 import org.onosproject.routing.IntentSynchronizationService;
+import org.onosproject.routing.RoutingService;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
@@ -51,40 +58,49 @@ import static com.google.common.base.Preconditions.checkArgument;
 /**
 /**
  * FIB component of SDN-IP.
  * FIB component of SDN-IP.
  */
  */
-public class SdnIpFib implements FibListener {
+@Component(immediate = true)
+public class SdnIpFib {
     private Logger log = LoggerFactory.getLogger(getClass());
     private Logger log = LoggerFactory.getLogger(getClass());
 
 
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected InterfaceService interfaceService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected IntentSynchronizationService intentSynchronizer;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected RoutingService routingService;
+
+    private final InternalFibListener fibListener = new InternalFibListener();
+
     private static final int PRIORITY_OFFSET = 100;
     private static final int PRIORITY_OFFSET = 100;
     private static final int PRIORITY_MULTIPLIER = 5;
     private static final int PRIORITY_MULTIPLIER = 5;
     protected static final ImmutableList<Constraint> CONSTRAINTS
     protected static final ImmutableList<Constraint> CONSTRAINTS
             = ImmutableList.of(new PartialFailureConstraint());
             = ImmutableList.of(new PartialFailureConstraint());
 
 
-    private final Map<IpPrefix, MultiPointToSinglePointIntent> routeIntents;
+    private final Map<IpPrefix, MultiPointToSinglePointIntent> routeIntents
+            = new ConcurrentHashMap<>();
 
 
-    private final ApplicationId appId;
-    private final InterfaceService interfaceService;
-    private final IntentSynchronizationService intentSynchronizer;
+    private ApplicationId appId;
 
 
-    /**
-     * Class constructor.
-     *
-     * @param appId application ID to use when generating intents
-     * @param interfaceService interface service
-     * @param intentSynchronizer intent synchronizer
-     */
-    public SdnIpFib(ApplicationId appId, InterfaceService interfaceService,
-                    IntentSynchronizationService intentSynchronizer) {
-        routeIntents = new ConcurrentHashMap<>();
+    @Activate
+    public void activate() {
+        appId = coreService.getAppId(SdnIp.SDN_IP_APP);
 
 
-        this.appId = appId;
-        this.interfaceService = interfaceService;
-        this.intentSynchronizer = intentSynchronizer;
+        routingService.addFibListener(fibListener);
+        routingService.start();
     }
     }
 
 
+    @Deactivate
+    public void deactivate() {
+        // TODO remove listener
+        routingService.stop();
+    }
 
 
-    @Override
-    public void update(Collection<FibUpdate> updates,
-                       Collection<FibUpdate> withdraws) {
+    private void update(Collection<FibUpdate> updates, Collection<FibUpdate> withdraws) {
         int submitCount = 0, withdrawCount = 0;
         int submitCount = 0, withdrawCount = 0;
         //
         //
         // NOTE: Semantically, we MUST withdraw existing intents before
         // NOTE: Semantically, we MUST withdraw existing intents before
@@ -224,4 +240,11 @@ public class SdnIpFib implements FibListener {
                 .build();
                 .build();
     }
     }
 
 
+    private class InternalFibListener implements FibListener {
+        @Override
+        public void update(Collection<FibUpdate> updates, Collection<FibUpdate> withdraws) {
+            SdnIpFib.this.update(updates, withdraws);
+        }
+    }
+
 }
 }

@@ -18,10 +18,10 @@ package org.onosproject.sdnip.cli;
 import org.apache.karaf.shell.commands.Argument;
 import org.apache.karaf.shell.commands.Argument;
 import org.apache.karaf.shell.commands.Command;
 import org.apache.karaf.shell.commands.Command;
 import org.onosproject.cli.AbstractShellCommand;
 import org.onosproject.cli.AbstractShellCommand;
-import org.onosproject.routing.SdnIpService;
+import org.onosproject.routing.IntentSynchronizationAdminService;
 
 
 /**
 /**
- * Command to change whether this SDNIP instance is primary or not.
+ * Command to change whether this instance's intent synchronizer is primary.
  */
  */
 @Command(scope = "onos", name = "sdnip-set-primary",
 @Command(scope = "onos", name = "sdnip-set-primary",
          description = "Changes the primary status of this SDN-IP instance")
          description = "Changes the primary status of this SDN-IP instance")
@@ -34,7 +34,7 @@ public class PrimaryChangeCommand extends AbstractShellCommand {
 
 
     @Override
     @Override
     protected void execute() {
     protected void execute() {
-        get(SdnIpService.class).modifyPrimary(isPrimary);
+        get(IntentSynchronizationAdminService.class).modifyPrimary(isPrimary);
     }
     }
 
 
 }
 }

@@ -29,7 +29,9 @@ import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.VlanId;
 import org.onlab.packet.VlanId;
 import org.onosproject.TestApplicationId;
 import org.onosproject.TestApplicationId;
+import org.onosproject.cluster.LeadershipServiceAdapter;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreServiceAdapter;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
@@ -43,14 +45,15 @@ import org.onosproject.net.intent.AbstractIntentTest;
 import org.onosproject.net.intent.Intent;
 import org.onosproject.net.intent.Intent;
 import org.onosproject.net.intent.IntentService;
 import org.onosproject.net.intent.IntentService;
 import org.onosproject.net.intent.IntentState;
 import org.onosproject.net.intent.IntentState;
+import org.onosproject.net.intent.IntentUtils;
 import org.onosproject.net.intent.Key;
 import org.onosproject.net.intent.Key;
 import org.onosproject.net.intent.MultiPointToSinglePointIntent;
 import org.onosproject.net.intent.MultiPointToSinglePointIntent;
-import org.onosproject.net.intent.IntentUtils;
 import org.onosproject.routing.RouteEntry;
 import org.onosproject.routing.RouteEntry;
 
 
 import java.util.Collections;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.Set;
+import java.util.concurrent.ExecutorService;
 
 
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.expect;
@@ -88,7 +91,8 @@ public class IntentSyncTest extends AbstractIntentTest {
     private IntentSynchronizer intentSynchronizer;
     private IntentSynchronizer intentSynchronizer;
     private final Set<Interface> interfaces = Sets.newHashSet();
     private final Set<Interface> interfaces = Sets.newHashSet();
 
 
-    private static final ApplicationId APPID = TestApplicationId.create("SDNIP");
+    private static final ApplicationId APPID =
+            TestApplicationId.create("intent-sync-test");
 
 
     @Before
     @Before
     public void setUp() throws Exception {
     public void setUp() throws Exception {
@@ -98,8 +102,13 @@ public class IntentSyncTest extends AbstractIntentTest {
 
 
         intentService = createMock(IntentService.class);
         intentService = createMock(IntentService.class);
 
 
-        intentSynchronizer = new IntentSynchronizer(APPID, intentService,
-                MoreExecutors.newDirectExecutorService());
+        intentSynchronizer = new TestIntentSynchronizer();
+
+        intentSynchronizer.coreService = new TestCoreService();
+        intentSynchronizer.leadershipService = new TestLeadershipService();
+        intentSynchronizer.intentService = intentService;
+
+        intentSynchronizer.activate();
     }
     }
 
 
     /**
     /**
@@ -268,7 +277,7 @@ public class IntentSyncTest extends AbstractIntentTest {
         // Give the leadership to the intent synchronizer. It will now attempt
         // Give the leadership to the intent synchronizer. It will now attempt
         // to synchronize the intents in the store with the intents it has
         // to synchronize the intents in the store with the intents it has
         // recorded based on the earlier user input.
         // recorded based on the earlier user input.
-        intentSynchronizer.leaderChanged(true);
+        intentSynchronizer.modifyPrimary(true);
 
 
         verify(intentService);
         verify(intentService);
     }
     }
@@ -290,7 +299,7 @@ public class IntentSyncTest extends AbstractIntentTest {
 
 
         // Give the intent synchronizer leadership so it will submit intents
         // Give the intent synchronizer leadership so it will submit intents
         // to the intent service
         // to the intent service
-        intentSynchronizer.leaderChanged(true);
+        intentSynchronizer.modifyPrimary(true);
 
 
         // Test the submit
         // Test the submit
         intentSynchronizer.submit(intent);
         intentSynchronizer.submit(intent);
@@ -303,7 +312,7 @@ public class IntentSyncTest extends AbstractIntentTest {
         reset(intentService);
         reset(intentService);
         replay(intentService);
         replay(intentService);
 
 
-        intentSynchronizer.leaderChanged(false);
+        intentSynchronizer.modifyPrimary(false);
 
 
         intentSynchronizer.submit(intent);
         intentSynchronizer.submit(intent);
 
 
@@ -328,7 +337,7 @@ public class IntentSyncTest extends AbstractIntentTest {
 
 
         // Give the intent synchronizer leadership so it will submit intents
         // Give the intent synchronizer leadership so it will submit intents
         // to the intent service
         // to the intent service
-        intentSynchronizer.leaderChanged(true);
+        intentSynchronizer.modifyPrimary(true);
 
 
         // Test the submit then withdraw
         // Test the submit then withdraw
         intentSynchronizer.submit(intent);
         intentSynchronizer.submit(intent);
@@ -342,7 +351,7 @@ public class IntentSyncTest extends AbstractIntentTest {
         reset(intentService);
         reset(intentService);
         replay(intentService);
         replay(intentService);
 
 
-        intentSynchronizer.leaderChanged(false);
+        intentSynchronizer.modifyPrimary(false);
 
 
         intentSynchronizer.submit(intent);
         intentSynchronizer.submit(intent);
         intentSynchronizer.withdraw(intent);
         intentSynchronizer.withdraw(intent);
@@ -418,4 +427,22 @@ public class IntentSyncTest extends AbstractIntentTest {
                 "ingressPoints", intent.ingressPoints());
                 "ingressPoints", intent.ingressPoints());
         return intentNew;
         return intentNew;
     }
     }
+
+    private class TestIntentSynchronizer extends IntentSynchronizer {
+        @Override
+        protected ExecutorService createExecutor() {
+            return MoreExecutors.newDirectExecutorService();
+        }
+    }
+
+    private class TestCoreService extends CoreServiceAdapter {
+        @Override
+        public ApplicationId registerApplication(String name) {
+            return APPID;
+        }
+    }
+
+    private class TestLeadershipService extends LeadershipServiceAdapter {
+
+    }
 }
 }

@@ -28,6 +28,7 @@ import org.onlab.packet.MacAddress;
 import org.onlab.packet.VlanId;
 import org.onlab.packet.VlanId;
 import org.onosproject.TestApplicationId;
 import org.onosproject.TestApplicationId;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreServiceAdapter;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.incubator.net.intf.Interface;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.incubator.net.intf.InterfaceService;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.ConnectPoint;
@@ -42,8 +43,10 @@ import org.onosproject.net.intent.AbstractIntentTest;
 import org.onosproject.net.intent.Key;
 import org.onosproject.net.intent.Key;
 import org.onosproject.net.intent.MultiPointToSinglePointIntent;
 import org.onosproject.net.intent.MultiPointToSinglePointIntent;
 import org.onosproject.routing.FibEntry;
 import org.onosproject.routing.FibEntry;
+import org.onosproject.routing.FibListener;
 import org.onosproject.routing.FibUpdate;
 import org.onosproject.routing.FibUpdate;
 import org.onosproject.routing.IntentSynchronizationService;
 import org.onosproject.routing.IntentSynchronizationService;
+import org.onosproject.routing.RoutingServiceAdapter;
 import org.onosproject.routing.config.BgpPeer;
 import org.onosproject.routing.config.BgpPeer;
 import org.onosproject.routing.config.RoutingConfigurationService;
 import org.onosproject.routing.config.RoutingConfigurationService;
 
 
@@ -90,6 +93,8 @@ public class SdnIpFibTest extends AbstractIntentTest {
 
 
     private static final ApplicationId APPID = TestApplicationId.create("SDNIP");
     private static final ApplicationId APPID = TestApplicationId.create("SDNIP");
 
 
+    private FibListener fibListener;
+
     @Before
     @Before
     public void setUp() throws Exception {
     public void setUp() throws Exception {
         super.setUp();
         super.setUp();
@@ -106,7 +111,13 @@ public class SdnIpFibTest extends AbstractIntentTest {
 
 
         intentSynchronizer = createMock(IntentSynchronizationService.class);
         intentSynchronizer = createMock(IntentSynchronizationService.class);
 
 
-        sdnipFib = new SdnIpFib(APPID, interfaceService, intentSynchronizer);
+        sdnipFib = new SdnIpFib();
+        sdnipFib.routingService = new TestRoutingService();
+        sdnipFib.coreService = new TestCoreService();
+        sdnipFib.interfaceService = interfaceService;
+        sdnipFib.intentSynchronizer = intentSynchronizer;
+
+        sdnipFib.activate();
     }
     }
 
 
     /**
     /**
@@ -242,7 +253,7 @@ public class SdnIpFibTest extends AbstractIntentTest {
 
 
         // Send in the UPDATE FibUpdate
         // Send in the UPDATE FibUpdate
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
-        sdnipFib.update(Collections.singleton(fibUpdate), Collections.emptyList());
+        fibListener.update(Collections.singleton(fibUpdate), Collections.emptyList());
 
 
         verify(intentSynchronizer);
         verify(intentSynchronizer);
     }
     }
@@ -295,7 +306,7 @@ public class SdnIpFibTest extends AbstractIntentTest {
 
 
         // Send in the UPDATE FibUpdate
         // Send in the UPDATE FibUpdate
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
-        sdnipFib.update(Collections.singleton(fibUpdate), Collections.emptyList());
+        fibListener.update(Collections.singleton(fibUpdate), Collections.emptyList());
 
 
         verify(intentSynchronizer);
         verify(intentSynchronizer);
     }
     }
@@ -354,7 +365,7 @@ public class SdnIpFibTest extends AbstractIntentTest {
         // Send in the UPDATE FibUpdate
         // Send in the UPDATE FibUpdate
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE,
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE,
                 fibEntryUpdate);
                 fibEntryUpdate);
-        sdnipFib.update(Collections.singletonList(fibUpdate),
+        fibListener.update(Collections.singletonList(fibUpdate),
                 Collections.emptyList());
                 Collections.emptyList());
 
 
         verify(intentSynchronizer);
         verify(intentSynchronizer);
@@ -410,8 +421,23 @@ public class SdnIpFibTest extends AbstractIntentTest {
 
 
         // Send in the DELETE FibUpdate
         // Send in the DELETE FibUpdate
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.DELETE, fibEntry);
         FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.DELETE, fibEntry);
-        sdnipFib.update(Collections.emptyList(), Collections.singletonList(fibUpdate));
+        fibListener.update(Collections.emptyList(), Collections.singletonList(fibUpdate));
 
 
         verify(intentSynchronizer);
         verify(intentSynchronizer);
     }
     }
+
+    private class TestCoreService extends CoreServiceAdapter {
+        @Override
+        public ApplicationId getAppId(String name) {
+            return APPID;
+        }
+    }
+
+    private class TestRoutingService extends RoutingServiceAdapter {
+
+        @Override
+        public void addFibListener(FibListener fibListener) {
+            SdnIpFibTest.this.fibListener = fibListener;
+        }
+    }
 }
 }