Merge branch 'feature/zmqtests' into develop

JonasKunze · JonasKunze · commit d57d330977e2 · 2014-04-10T00:20:40.000+02:00
diff --git a/src/main/java/de/metalcon/like/server/LikeButtonServer.java b/src/main/java/de/metalcon/like/server/LikeButtonServer.java
@@ -83,7 +83,7 @@ public void run() {
         writeWorker.start();
 
         while (true) {
-            long ns = service.updateAllNodes();
+            long ns = service.updateAllLargeNodes();
             if (ns < 1E9) {
                 try {
                     Thread.sleep(1000);
diff --git a/src/main/java/de/metalcon/like/server/api/backend/LikeService.java b/src/main/java/de/metalcon/like/server/api/backend/LikeService.java
@@ -265,12 +265,12 @@ public long[] getAllNownNodes() {
     }
 
     /**
-     * Reads the persistent like histories and adds new likes in to the commons
+     * Reads the persistent like histories and adds new likes into the commons
      * list of each node
      * 
      * @return The number of nanoseconds spend within this method
      */
-    public long updateAllNodes() {
+    public long updateAllLargeNodes() {
         long start = System.nanoTime();
         long[] allNodes = NodeFactory.getAllNodeMuids();
         if (allNodes == null) {
@@ -279,7 +279,7 @@ public long updateAllNodes() {
 
         for (long uuid : allNodes) {
             Node n = NodeFactory.getNode(uuid);
-            n.updateCommons();
+            n.updateLargeNodeCommons();
         }
         return System.nanoTime() - start;
     }
diff --git a/src/main/java/de/metalcon/like/server/api/frontend/LikeServerRequestHandler.java b/src/main/java/de/metalcon/like/server/api/frontend/LikeServerRequestHandler.java
@@ -108,7 +108,7 @@ public Response handleRequest(final LikeServerRequest request) {
          * All other request should be write requests -> forward them to the
          * write worker asynchronously
          */
-        writeWorkDispatcher.execute(request, null/* ignore the response */);
+        writeWorkDispatcher.execute(request, /* ignore the response */null);
 
         return new RequestQueuedResponse();
     }
diff --git a/src/main/java/de/metalcon/like/server/core/Commons.java b/src/main/java/de/metalcon/like/server/core/Commons.java
@@ -31,7 +31,7 @@ public Commons(
             final Vote likeType) {
         this.node = node;
         persistentCommonsMap =
-                new PersistentUidMap(node.getMuid() + "" + likeType);
+                new PersistentUidMap(node.getUid() + "" + likeType);
         this.likeType = likeType;
     }
 
@@ -71,27 +71,35 @@ public long[] getCommonNodes(final long muid) {
     }
 
     /**
-     * Updates the commons of node and writes the data to disk
+     * Updates the commons of node and writes the data to disk if nod has a
+     * large in degree
      */
-    public void update() {
+    public void updateLargeNode() {
         final int now = (int) (System.currentTimeMillis() / 1000l);
 
         /*
-         * Update all outgoing nodes
+         * Update all incoming nodes if this node is large.
          */
-        final long[] outNodes = node.getLikesOut(Vote.UP).toArray();
-        if (outNodes != null) {
-            for (long friendUUID : outNodes) {
-                if (friendUUID == 0) {
-                    break;
+        final long[] inNodes = node.getLikesIn(Vote.UP).toArray();
+        if (inNodes != null && inNodes.length >= Node.LARGE_NODE_DEGREE) {
+            if (inNodes != null) {
+                for (long friendUUID : inNodes) {
+                    if (friendUUID == 0) {
+                        break;
+                    }
+                    (NodeFactory.getNode(friendUUID)).updateCommons(node
+                            .getUid());
                 }
-                updateFriend(NodeFactory.getNode(friendUUID), false);
             }
         }
 
         persistentCommonsMap.setUpdateTimeStamp(now);
     }
 
+    public void updateNode(final long likedNode) {
+        updateFriend(NodeFactory.getNode(likedNode), false);
+    }
+
     /**
      * Adds the friend to all entities in the commonsMap liked by the friend
      * node.
@@ -100,22 +108,26 @@ public void update() {
      *            The friend to be added to the commonsMap
      */
     public void friendAdded(final Node friend) {
+        /*
+         * Update the commons with friend
+         */
         updateFriend(friend, true);
 
         /*
-         * Instead of frequently running LikeService.updateAllNodes() we could
-         * run following code. The problem here is that big nodes would trigger
-         * these expensive calls much too often.
+         * Update all incoming nodes if this node is not too large.
          */
-        //        final long[] inNodes = node.getLikesIn(Vote.UP).toArray();
-        //        if (inNodes != null) {
-        //            for (long friendUUID : inNodes) {
-        //                if (friendUUID == 0) {
-        //                    break;
-        //                }
-        //                (NodeFactory.getNode(friendUUID)).updateCommons();
-        //            }
-        //        }
+        final long[] inNodes = node.getLikesIn(Vote.UP).toArray();
+        if (inNodes == null || inNodes.length < Node.LARGE_NODE_DEGREE) {
+            if (inNodes != null) {
+                for (long friendUUID : inNodes) {
+                    if (friendUUID == 0) {
+                        break;
+                    }
+                    (NodeFactory.getNode(friendUUID)).updateCommons(node
+                            .getUid());
+                }
+            }
+        }
     }
 
     /**
@@ -130,14 +142,14 @@ public void friendRemoved(final Node friend) {
             /*
              * Remove the friend from the commons list of the liked entity
              */
-            persistentCommonsMap.remove(outID, friend.getMuid());
+            persistentCommonsMap.remove(outID, friend.getUid());
         }
 
         for (long outID : friend.getLikesOut(Vote.DOWN)) {
             /*
              * Remove the friend from the commons list of the liked entity
              */
-            persistentCommonsMap.remove(outID, friend.getMuid());
+            persistentCommonsMap.remove(outID, friend.getUid());
         }
     }
 
@@ -160,15 +172,15 @@ public void updateFriend(final Node friend, final boolean ignoreTimestamp) {
         int searchTS =
                 ignoreTimestamp ? 0 : persistentCommonsMap
                         .getLastUpdateTimeStamp();
-        for (Like like : friend.getLikesFromTimeOn(searchTS)) {
-            if (like.getMUID() == node.getMuid()) {
+        for (Like like : friend.getLikeHistoryFromTimeOn(searchTS)) {
+            if (like.getMUID() == node.getUid()) {
                 continue;
             }
             if (like.getVote() == likeType) {
                 /*
                  * Q1 node -> friend -> likedNode
                  */
-                persistentCommonsMap.append(like.getMUID(), friend.getMuid());
+                persistentCommonsMap.append(like.getMUID(), friend.getUid());
 
                 /*
                  * Q2 node -> likedNode && node -> friend -> likedNode FIXME:
@@ -178,19 +190,19 @@ public void updateFriend(final Node friend, final boolean ignoreTimestamp) {
                  * friend.getLikedNodes()
                  */
                 if (node.getLikesOut(likeType).contains(like.getMUID())) {
-                    persistentCommonsMap.append(friend.getMuid(),
-                            like.getMUID());
+                    persistentCommonsMap
+                            .append(friend.getUid(), like.getMUID());
                 }
             } else {
-                persistentCommonsMap.remove(like.getMUID(), friend.getMuid());
-                persistentCommonsMap.remove(friend.getMuid(), like.getMUID());
+                persistentCommonsMap.remove(like.getMUID(), friend.getUid());
+                persistentCommonsMap.remove(friend.getUid(), like.getMUID());
             }
         }
     }
 
     @Override
     public String toString() {
-        return node.getMuid() + "(" + likeType + "):\n"
+        return node.getUid() + "(" + likeType + "):\n"
                 + persistentCommonsMap.toString();
     }
 }
diff --git a/src/main/java/de/metalcon/like/server/core/Node.java b/src/main/java/de/metalcon/like/server/core/Node.java
@@ -14,12 +14,19 @@ public class Node {
     private static final int LastLikeCacheSize = 10;
 
     // Class Variables
-    private final long Muid;
+    private final long Uid;
 
     private final Commons likeCommons;
 
     private final Commons dislikeCommons;
 
+    /*
+     * This defines what large node means. Nodes with this in/out degree will
+     * not be updated during the creation of a new edge. They must be updated
+     * frequently by a special thread.
+     */
+    public static final int LARGE_NODE_DEGREE = 100;
+
     /*
      * lastLikes[lastLikesFirstEntryPointer] is the newest like The list is
      * ordered by descending timestamps (newest first)
@@ -60,36 +67,18 @@ public class Node {
     Node(
             final long muid,
             final boolean isNewNode) {
-        Muid = muid;
-        // commons = new Commons(this, storageDir,
-        // PersistentMuidArrayMap.class);
-
-        // commons = new Commons(this, storageDir,
-        // PersistentMuidArrayMapRedis.class);
-
-        // commons = new Commons(this, storageDir, LazyPersistentMuidMap.class);
+        Uid = muid;
 
         likeCommons = new Commons(this, Vote.UP);
 
         dislikeCommons = new Commons(this, Vote.DOWN);
 
-        // try {
-        // friends = new PersistentMuidSet(storageDir + "/" + Muid
-        // + "_friends");
-        // inNodes = new PersistentMuidSet(storageDir + "/" + Muid
-        // + "_inNodes");
-        //
-        // } catch (IOException e) {
-        // e.printStackTrace();
-        // System.exit(1);
-        // }
-
-        likedOut = new PersistentUidSet(Muid + "likedOut");
-        likedIn = new PersistentUidSet(Muid + "likedIn");
-        dislikedOut = new PersistentUidSet(Muid + "dislikedOut");
-        dislikedIn = new PersistentUidSet(Muid + "dislikedIn");
-
-        likeHistory = new PersistentLikeHistory(Muid);
+        likedOut = new PersistentUidSet(Uid + "likedOut");
+        likedIn = new PersistentUidSet(Uid + "likedIn");
+        dislikedOut = new PersistentUidSet(Uid + "dislikedOut");
+        dislikedIn = new PersistentUidSet(Uid + "dislikedIn");
+
+        likeHistory = new PersistentLikeHistory(Uid);
     }
 
     /**
@@ -110,7 +99,7 @@ public void delete() throws IOException {
         dislikedOut.delete();
         dislikedIn.delete();
 
-        NodeFactory.removeNodeFromPersistentList(Muid);
+        NodeFactory.removeNodeFromPersistentList(Uid);
 
         likeHistory.delete();
     }
@@ -122,7 +111,7 @@ public void delete() throws IOException {
      *            The time all likes have to be younger than
      * @return An array of the newest likes
      */
-    public Like[] getLikesFromTimeOn(final int timestamp) {
+    public Like[] getLikeHistoryFromTimeOn(final int timestamp) {
         int arrayLength = 10;
         Like[] likesFoundInCache = new Like[arrayLength];
         int likesFoundInCachePointer = 0;
@@ -263,8 +252,8 @@ public void addLike(final Like like) throws IOException {
             likedNode = NodeFactory.createNewNode(like.getMUID());
         }
 
-        addOutNode(likedNode.Muid, like.getVote());
-        likedNode.addInNode(Muid, like.getVote());
+        addOutNode(likedNode.Uid, like.getVote());
+        likedNode.addInNode(Uid, like.getVote());
 
         synchronized (lastLikesCache) {
             if (lastLikesFirstEntryPointer == 0) {
@@ -321,7 +310,7 @@ public void addLike(final long muid, final int timestamp, final Vote vote)
      * @throws IOException
      */
     public void removeFriendship(final Node friend) throws IOException {
-        addLike(new Like(friend.getMuid(),
+        addLike(new Like(friend.getUid(),
                 (int) System.currentTimeMillis() / 1000, Vote.NEUTRAL));
     }
 
@@ -432,15 +421,29 @@ public long[] getCommonDislikedNodes(final long muid) {
         return dislikeCommons.getCommonNodes(muid);
     }
 
-    public final long getMuid() {
-        return Muid;
+    /**
+     * 
+     * @return The unique identifyer of this node
+     */
+    public final long getUid() {
+        return Uid;
     }
 
-    protected Commons getCommons() {
-        return likeCommons;
+    /**
+     * Updates commons of incoming nodes with this node if this node has a large
+     * in degree
+     */
+    public void updateLargeNodeCommons() {
+        likeCommons.updateLargeNode();
     }
 
-    public void updateCommons() {
-        likeCommons.update();
+    /**
+     * Update all commons this node has with likedNode
+     * 
+     * @param likedNode
+     *            the freshly liked node
+     */
+    public void updateCommons(final long likedNode) {
+        likeCommons.updateNode(likedNode);
     }
 }
diff --git a/src/main/java/de/metalcon/like/server/core/PersistentUidSet.java b/src/main/java/de/metalcon/like/server/core/PersistentUidSet.java
@@ -70,7 +70,7 @@ public boolean remove(long uuid) {
 	}
 
 	public boolean remove(Node n) {
-		return remove(n.getMuid());
+		return remove(n.getUid());
 	}
 
 	/**
diff --git a/src/test/java/de/metalcon/like/requests/ZmqTest.java b/src/test/java/de/metalcon/like/requests/ZmqTest.java
@@ -32,6 +32,18 @@ public class ZmqTest {
 
     private ZMQ.Context ctx;
 
+<<<<<<< HEAD
+        //        LikeButtonServer server;
+        //        try {
+        //            server = new LikeButtonServer();
+        //            server.start();
+        //        } catch (MetalconException e) {
+        //            e.printStackTrace();
+        //        }
+        //
+        //        Thread.sleep(100);
+        ZMQ.Context ctx = ZMQ.context(1);
+=======
     @Before
     public void setUpBeforeClass() throws Exception {
         LikeButtonServer server;
@@ -45,6 +57,9 @@ public void setUpBeforeClass() throws Exception {
         ctx = ZMQ.context(1);
 
         dispatcher = new Dispatcher();
+>>>>>>> develop
+
+        dispatcher = new Dispatcher();
 
         String serviceID = "serviceID";
         dispatcher.registerServiceAdapter(serviceID, new ZmqAdapter(ctx,
diff --git a/src/test/java/de/metalcon/like/server/api/DeleteEdgeTest.java b/src/test/java/de/metalcon/like/server/api/DeleteEdgeTest.java
@@ -29,7 +29,7 @@ public void testStateafterRemove() throws IOException {
 
         likeService.putEdge(4, 2, Vote.UP);
 
-        likeService.updateAllNodes();
+        likeService.updateAllLargeNodes();
 
         long[] commons = likeService.getCommonNodes(1, 3, Vote.UP);
         HashSet<Long> set = convertArrayToHashSet(commons);
@@ -58,5 +58,4 @@ public void testStateafterRemove() throws IOException {
         assertFalse(set.contains(2L));
         assertTrue(set.contains(4L));
     }
-
 }

Original file line number	Diff line number	Diff line change
`@@ -265,12 +265,12 @@ public long[] getAllNownNodes() {`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`/**`
`268`		`- * Reads the persistent like histories and adds new likes in to the commons`
	`268`	`+ * Reads the persistent like histories and adds new likes into the commons`
`269`	`269`	`* list of each node`
`270`	`270`	`*`
`271`	`271`	`* @return The number of nanoseconds spend within this method`
`272`	`272`	`*/`
`273`		`- public long updateAllNodes() {`
	`273`	`+ public long updateAllLargeNodes() {`
`274`	`274`	`long start = System.nanoTime();`
`275`	`275`	`long[] allNodes = NodeFactory.getAllNodeMuids();`
`276`	`276`	`if (allNodes == null) {`
`@@ -279,7 +279,7 @@ public long updateAllNodes() {`
`279`	`279`
`280`	`280`	`for (long uuid : allNodes) {`
`281`	`281`	`Node n = NodeFactory.getNode(uuid);`
`282`		`- n.updateCommons();`
	`282`	`+ n.updateLargeNodeCommons();`
`283`	`283`	`}`
`284`	`284`	`return System.nanoTime() - start;`
`285`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public Response handleRequest(final LikeServerRequest request) {`
`108`	`108`	`* All other request should be write requests -> forward them to the`
`109`	`109`	`* write worker asynchronously`
`110`	`110`	`*/`
`111`		`- writeWorkDispatcher.execute(request, null/* ignore the response */);`
	`111`	`+ writeWorkDispatcher.execute(request, /* ignore the response */null);`
`112`	`112`
`113`	`113`	`return new RequestQueuedResponse();`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ public boolean remove(long uuid) {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`public boolean remove(Node n) {`
`73`		`- return remove(n.getMuid());`
	`73`	`+ return remove(n.getUid());`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public void testStateafterRemove() throws IOException {`
`29`	`29`
`30`	`30`	`likeService.putEdge(4, 2, Vote.UP);`
`31`	`31`
`32`		`- likeService.updateAllNodes();`
	`32`	`+ likeService.updateAllLargeNodes();`
`33`	`33`
`34`	`34`	`long[] commons = likeService.getCommonNodes(1, 3, Vote.UP);`
`35`	`35`	`HashSet<Long> set = convertArrayToHashSet(commons);`
`@@ -58,5 +58,4 @@ public void testStateafterRemove() throws IOException {`
`58`	`58`	`assertFalse(set.contains(2L));`
`59`	`59`	`assertTrue(set.contains(4L));`
`60`	`60`	`}`
`61`		`-`
`62`	`61`	`}`