Merge branch 'master' of ssh://gerrit.onlab.us:29418/onos-next

@@ -25,10 +25,10 @@ import org.slf4j.LoggerFactory;
 /**
 /**
  * Manages the connectivity requirements between peers.
  * Manages the connectivity requirements between peers.
  */
  */
-public class PeerConnectivity {
+public class PeerConnectivityManager {
 
 
     private static final Logger log = LoggerFactory.getLogger(
     private static final Logger log = LoggerFactory.getLogger(
-            PeerConnectivity.class);
+            PeerConnectivityManager.class);
 
 
     // TODO these shouldn't be defined here
     // TODO these shouldn't be defined here
     private static final short BGP_PORT = 179;
     private static final short BGP_PORT = 179;
@@ -41,7 +41,7 @@ public class PeerConnectivity {
     // TODO this sucks.
     // TODO this sucks.
     private int intentId = 0;
     private int intentId = 0;
 
 
-    public PeerConnectivity(SdnIpConfigService configInfoService,
+    public PeerConnectivityManager(SdnIpConfigService configInfoService,
             InterfaceService interfaceService, IntentService intentService) {
             InterfaceService interfaceService, IntentService intentService) {
         this.configInfoService = configInfoService;
         this.configInfoService = configInfoService;
         this.interfaceService = interfaceService;
         this.interfaceService = interfaceService;

@@ -36,7 +36,7 @@ public class SdnIp implements SdnIpService {
     protected HostService hostService;
     protected HostService hostService;
 
 
     private SdnIpConfigReader config;
     private SdnIpConfigReader config;
-    private PeerConnectivity peerConnectivity;
+    private PeerConnectivityManager peerConnectivity;
     private Router router;
     private Router router;
     private BgpSessionManager bgpSessionManager;
     private BgpSessionManager bgpSessionManager;
 
 
@@ -49,7 +49,7 @@ public class SdnIp implements SdnIpService {
 
 
         InterfaceService interfaceService = new HostServiceBasedInterfaceService(hostService);
         InterfaceService interfaceService = new HostServiceBasedInterfaceService(hostService);
 
 
-        peerConnectivity = new PeerConnectivity(config, interfaceService, intentService);
+        peerConnectivity = new PeerConnectivityManager(config, interfaceService, intentService);
         peerConnectivity.start();
         peerConnectivity.start();
 
 
         router = new Router(intentService, hostService, config, interfaceService);
         router = new Router(intentService, hostService, config, interfaceService);
@@ -79,4 +79,8 @@ public class SdnIp implements SdnIpService {
     public Collection<RouteEntry> getRoutes() {
     public Collection<RouteEntry> getRoutes() {
         return router.getRoutes();
         return router.getRoutes();
     }
     }
+
+    static String dpidToUri(String dpid) {
+        return "of:" + dpid.replace(":", "");
+    }
 }
 }

@@ -7,6 +7,8 @@ import org.onlab.onos.net.Provided;
  */
  */
 public interface Topology extends Provided {
 public interface Topology extends Provided {
 
 
+    // FIXME: Following is not true right now. It is actually System.nanoTime(),
+    // which has no relation to epoch time, wall clock, etc.
     /**
     /**
      * Returns the time, specified in milliseconds since start of epoch,
      * Returns the time, specified in milliseconds since start of epoch,
      * when the topology became active and made available.
      * when the topology became active and made available.

@@ -52,6 +52,12 @@
           <artifactId>easymock</artifactId>
           <artifactId>easymock</artifactId>
           <scope>test</scope>
           <scope>test</scope>
         </dependency>
         </dependency>
+        <dependency>
+          <groupId>org.onlab.onos</groupId>
+          <artifactId>onos-api</artifactId>
+          <classifier>tests</classifier>
+          <scope>test</scope>
+        </dependency>
     </dependencies>
     </dependencies>
 
 
 </project>
 </project>

@@ -3,7 +3,7 @@ package org.onlab.onos.store.flow;
 import org.onlab.onos.net.DeviceId;
 import org.onlab.onos.net.DeviceId;
 
 
 /**
 /**
- * Service to return where the Replica should be placed.
+ * Service to return where the replica should be placed.
  */
  */
 public interface ReplicaInfoService {
 public interface ReplicaInfoService {
 
 
@@ -15,4 +15,19 @@ public interface ReplicaInfoService {
      * @return placement information
      * @return placement information
      */
      */
     ReplicaInfo getReplicaInfoFor(DeviceId deviceId);
     ReplicaInfo getReplicaInfoFor(DeviceId deviceId);
+
+    /**
+     * Adds the specified replica placement info change listener.
+     *
+     * @param listener the replica placement info change listener
+     */
+    void addListener(ReplicaInfoEventListener listener);
+
+    /**
+     * Removes the specified replica placement info change listener.
+     *
+     * @param listener the replica placement info change listener
+     */
+    void removeListener(ReplicaInfoEventListener listener);
+
 }
 }

 package org.onlab.onos.store.flow.impl;
 package org.onlab.onos.store.flow.impl;
 
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static org.slf4j.LoggerFactory.getLogger;
 import static org.slf4j.LoggerFactory.getLogger;
 import static org.onlab.onos.store.flow.ReplicaInfoEvent.Type.MASTER_CHANGED;
 import static org.onlab.onos.store.flow.ReplicaInfoEvent.Type.MASTER_CHANGED;
 
 
@@ -66,6 +67,16 @@ public class ReplicaInfoManager implements ReplicaInfoService {
                                Collections.<NodeId>emptyList());
                                Collections.<NodeId>emptyList());
     }
     }
 
 
+    @Override
+    public void addListener(ReplicaInfoEventListener listener) {
+        listenerRegistry.addListener(checkNotNull(listener));
+    }
+
+    @Override
+    public void removeListener(ReplicaInfoEventListener listener) {
+        listenerRegistry.removeListener(checkNotNull(listener));
+    }
+
     final class InternalMastershipListener implements MastershipListener {
     final class InternalMastershipListener implements MastershipListener {
 
 
         @Override
         @Override

+package org.onlab.onos.store.flow.impl;
+
+import static com.google.common.base.Preconditions.checkState;
+import static org.junit.Assert.*;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.onos.cluster.NodeId;
+import org.onlab.onos.event.AbstractListenerRegistry;
+import org.onlab.onos.event.DefaultEventSinkRegistry;
+import org.onlab.onos.event.Event;
+import org.onlab.onos.event.EventDeliveryService;
+import org.onlab.onos.event.EventSink;
+import org.onlab.onos.mastership.MastershipEvent;
+import org.onlab.onos.mastership.MastershipEvent.Type;
+import org.onlab.onos.mastership.MastershipListener;
+import org.onlab.onos.mastership.MastershipService;
+import org.onlab.onos.mastership.MastershipServiceAdapter;
+import org.onlab.onos.net.DeviceId;
+import org.onlab.onos.store.flow.ReplicaInfo;
+import org.onlab.onos.store.flow.ReplicaInfoEvent;
+import org.onlab.onos.store.flow.ReplicaInfoEventListener;
+import org.onlab.onos.store.flow.ReplicaInfoService;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Maps;
+
+public class ReplicaInfoManagerTest {
+
+
+    private static final DeviceId DID1 = DeviceId.deviceId("of:1");
+    private static final DeviceId DID2 = DeviceId.deviceId("of:2");
+    private static final NodeId NID1 = new NodeId("foo");
+
+    private ReplicaInfoManager mgr;
+    private ReplicaInfoService service;
+
+    private AbstractListenerRegistry<MastershipEvent, MastershipListener>
+        mastershipListenerRegistry;
+    private TestEventDispatcher eventDispatcher;
+
+
+    @Before
+    public void setUp() throws Exception {
+        mastershipListenerRegistry = new AbstractListenerRegistry<>();
+
+        mgr = new ReplicaInfoManager();
+        service = mgr;
+
+        eventDispatcher = new TestEventDispatcher();
+        mgr.eventDispatcher = eventDispatcher;
+        mgr.mastershipService = new TestMastershipService();
+
+        // register dummy mastership event source
+        mgr.eventDispatcher.addSink(MastershipEvent.class, mastershipListenerRegistry);
+
+        mgr.activate();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        mgr.deactivate();
+    }
+
+    @Test
+    public void testGetReplicaInfoFor() {
+        ReplicaInfo info1 = service.getReplicaInfoFor(DID1);
+        assertEquals(Optional.of(NID1), info1.master());
+        // backups are always empty for now
+        assertEquals(Collections.emptyList(), info1.backups());
+
+        ReplicaInfo info2 = service.getReplicaInfoFor(DID2);
+        assertEquals("There's no master", Optional.absent(), info2.master());
+        // backups are always empty for now
+        assertEquals(Collections.emptyList(), info2.backups());
+    }
+
+    @Test
+    public void testReplicaInfoEvent() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        service.addListener(new MasterNodeCheck(latch, DID1, NID1));
+
+        // fake MastershipEvent
+        eventDispatcher.post(new MastershipEvent(Type.MASTER_CHANGED, DID1, NID1));
+
+        assertTrue(latch.await(1, TimeUnit.SECONDS));
+    }
+
+
+    private final class MasterNodeCheck implements ReplicaInfoEventListener {
+        private final CountDownLatch latch;
+        private Optional<NodeId> expectedMaster;
+        private DeviceId expectedDevice;
+
+
+        MasterNodeCheck(CountDownLatch latch, DeviceId did,
+                NodeId nid) {
+            this.latch = latch;
+            this.expectedMaster = Optional.fromNullable(nid);
+            this.expectedDevice = did;
+        }
+
+        @Override
+        public void event(ReplicaInfoEvent event) {
+            assertEquals(expectedDevice, event.subject());
+            assertEquals(expectedMaster, event.replicaInfo().master());
+            // backups are always empty for now
+            assertEquals(Collections.emptyList(), event.replicaInfo().backups());
+            latch.countDown();
+        }
+    }
+
+
+    private final class TestMastershipService
+            extends MastershipServiceAdapter
+            implements MastershipService {
+
+        private Map<DeviceId, NodeId> masters;
+
+        TestMastershipService() {
+            masters = Maps.newHashMap();
+            masters.put(DID1, NID1);
+            // DID2 has no master
+        }
+
+        @Override
+        public NodeId getMasterFor(DeviceId deviceId) {
+            return masters.get(deviceId);
+        }
+
+        @Override
+        public void addListener(MastershipListener listener) {
+            mastershipListenerRegistry.addListener(listener);
+        }
+
+        @Override
+        public void removeListener(MastershipListener listener) {
+            mastershipListenerRegistry.removeListener(listener);
+        }
+    }
+
+
+    // code clone
+    /**
+     * Implements event delivery system that delivers events synchronously, or
+     * in-line with the post method invocation.
+     */
+    private static class TestEventDispatcher extends DefaultEventSinkRegistry
+            implements EventDeliveryService {
+
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        @Override
+        public void post(Event event) {
+            EventSink sink = getSink(event.getClass());
+            checkState(sink != null, "No sink for event %s", event);
+            sink.process(event);
+        }
+    }
+}

@@ -172,7 +172,7 @@ public class OpenFlowDeviceProvider extends AbstractProvider implements DevicePr
          */
          */
         private List<PortDescription> buildPortDescriptions(
         private List<PortDescription> buildPortDescriptions(
                 List<OFPortDesc> ports) {
                 List<OFPortDesc> ports) {
-            final List<PortDescription> portDescs = new ArrayList<>();
+            final List<PortDescription> portDescs = new ArrayList<>(ports.size());
             for (OFPortDesc port : ports) {
             for (OFPortDesc port : ports) {
                 portDescs.add(buildPortDescription(port));
                 portDescs.add(buildPortDescription(port));
             }
             }