Merge pull request #24 from ghedamat/sorted-set

use a sorted set to store the list of revisions

Author: Aaron Chambers

lib/redis.js

@@ -62,11 +62,9 @@ module.exports = CoreObject.extend({
   },
 
   fetchRevisions: function(keyPrefix) {
-    var currentKey = keyPrefix + ':current';
-
     return Promise.hash({
       revisions: this._listRevisions(keyPrefix),
-      current: this._client.get(currentKey)
+      current: this._activeRevision(keyPrefix)
     }).then(function(results) {
         return results.revisions.map(function(revision) {
           return {
@@ -79,7 +77,7 @@ module.exports = CoreObject.extend({
 
   _listRevisions: function(keyPrefix) {
     var client = this._client;
-    return client.lrange(keyPrefix, 0, this._maxNumberOfRecentUploads - 1);
+    return client.zrevrange(keyPrefix, 0, -1);
   },
 
   _validateRevisionKey: function(revisionKey, revisions) {
@@ -106,16 +104,38 @@ module.exports = CoreObject.extend({
       })
       .then(function() {
         return client.set(redisKey, value);
-      })
+      });
   },
 
   _updateRecentUploadsList: function(keyPrefix, revisionKey) {
     var client = this._client;
-    return client.lpush(keyPrefix, revisionKey);
+    var score = new Date().getTime();
+    return client.zadd(keyPrefix, score, revisionKey);
+  },
+
+  _activeRevision: function(keyPrefix) {
+    var currentKey = keyPrefix + ':current';
+    return this._client.get(currentKey);
   },
 
   _trimRecentUploadsList: function(keyPrefix, maxEntries) {
     var client = this._client;
-    return client.ltrim(keyPrefix, 0, maxEntries - 1);
+
+    return Promise.hash({
+      revisionsToBeRemoved: client.zrange(keyPrefix, 0, -(maxEntries + 1)),
+      current: this._activeRevision(keyPrefix)
+    }).then(function(results) {
+      var revisions = results.revisionsToBeRemoved;
+      var current = results.current;
+      if (!revisions) {
+        return;
+      }
+      revisions.forEach(function(revision) {
+        if (revision !== current) {
+          client.del(keyPrefix + ":" + revision);
+          client.zrem(keyPrefix, revision);
+        }
+      });
+    });
   }
 });

tests/helpers/fake-redis-client.js

@@ -2,12 +2,24 @@ var CoreObject = require('core-object');
 
 module.exports = CoreObject.extend({
   init: function (options) {
+    this.recentRevisions = [];
     this.options = options;
   },
   get: function(key) {
     return Promise.resolve('some-other-value');
   },
   set: function() { },
-  lpush: function() { },
-  ltrim: function() { }
+  del: function() { },
+  zadd: function(key, score , tag) {
+    this.recentRevisions.push(key + ':' + tag);
+  },
+  zrem: function(val,revision) {
+    var i = this.recentRevisions.indexOf(revision)
+    this.recentRevisions.splice(i,1);
+  },
+  zrange: function() {
+  },
+  zrevrange: function() {
+    return this.recentRevisions;
+  }
 });

tests/unit/lib/redis-nodetest.js

@@ -61,44 +61,67 @@ describe('redis', function() {
     });
 
     it('updates the list of recent uploads once upload is successful', function() {
-      var recentUploads = [];
+      var redis = new Redis({}, new FakeRedis(FakeClient.extend({
+        get: function(key) {
+          return Promise.resolve(null);
+        }
+      })));
+
+      var promise = redis.upload('key', 'value');
+      return assert.isFulfilled(promise)
+        .then(function() {
+          assert.equal(redis._client.recentRevisions.length, 1);
+          assert.equal(redis._client.recentRevisions[0], 'key:default');
+        });
+    });
+
+    it('trims the list of recent uploads and removes the index key', function() {
+      var finalUploads = ['3','4','5','6','7','8','9','10','11','key:12'];
 
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
         get: function(key) {
           return Promise.resolve(null);
         },
-        lpush: function(key, tag) {
-          recentUploads.push(key + tag);
+        del: function(key) {
+          assert(key === 'key:1' || key === 'key:2');
         },
+        zrange: function() {
+          return this.recentRevisions.slice(0,2);
+        }
       })));
 
-      var promise = redis.upload('key', 'value');
+      redis._client.recentRevisions = ['1','2','3','4','5','6','7','8','9','10','11'];
+
+      var promise = redis.upload('key', '12', 'value');
       return assert.isFulfilled(promise)
         .then(function() {
-          assert.equal(recentUploads.length, 1);
-          assert.equal(recentUploads[0], 'keydefault');
+          assert.equal(redis._client.recentRevisions.length, 10);
+          assert.deepEqual(redis._client.recentRevisions, finalUploads);
         });
     });
 
-    it('trims the list of recent uploads', function() {
-      var recentUploads = ['a', 'b', 'c'];
+    it('trims the list of recent uploads but leaves the active one', function() {
+      var finalUploads = ['1','3','4','5','6','7','8','9','10','11','key:12'];
 
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
         get: function(key) {
+          if (key == 'key:current') {
+            return Promise.resolve('1');
+          }
           return Promise.resolve(null);
         },
-        lpush: function(key, tag) {
-          recentUploads.push(key + tag);
-        },
-        ltrim: function() {
-          recentUploads.pop();
+        zrange: function() {
+          return this.recentRevisions.slice(0,2);
         }
       })));
 
-      var promise = redis.upload('key', 'value');
+      redis._client.recentRevisions = ['1','2','3','4','5','6','7','8','9','10','11'];
+
+      var promise = redis.upload('key', '12', 'value');
       return assert.isFulfilled(promise)
         .then(function() {
-          assert.equal(recentUploads.length, 3);
+          assert.equal(redis._client.recentRevisions.length, 11);
+          assert.deepEqual(redis._client.recentRevisions, finalUploads);
         });
     });
 
@@ -140,14 +163,14 @@ describe('redis', function() {
 
   describe('#activate', function() {
     it('rejects if the revisionKey doesn\t exist in list of uploaded revisions', function() {
-      var recentRevisions = ['a', 'b', 'c'];
-
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
-        lrange: function() {
-          return recentRevisions;
+        zrevrange: function() {
+          return this.recentRevisions;
         }
       })));
 
+      redis._client.recentRevisions = ['a', 'b', 'c'];
+
       var promise = redis.activate('key-prefix', 'revision-key');
       return assert.isRejected(promise)
         .then(function(error) {
@@ -156,20 +179,17 @@ describe('redis', function() {
     });
 
     it('resolves and sets the current revision to the revision key provided', function() {
-      var recentRevisions = ['a', 'b', 'c'];
       var redisKey, redisValue;
 
-
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
-        lrange: function() {
-          return recentRevisions;
-        },
         set: function(key, value) {
           redisKey = key;
           redisValue = value;
         }
       })));
 
+      redis._client.recentRevisions = ['a', 'b', 'c'];
+
       var promise = redis.activate('key-prefix', 'c');
       return assert.isFulfilled(promise)
         .then(function() {
@@ -181,16 +201,11 @@ describe('redis', function() {
 
   describe('#fetchRevisions', function() {
     it('lists the last existing revisions', function() {
-      var recentRevisions = ['a', 'b', 'c'];
-
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
-        lrange: function() {
-          return recentRevisions;
-        },
-        get: function() {
-        }
       })));
 
+      redis._client.recentRevisions = ['a', 'b', 'c'];
+
       var promise = redis.fetchRevisions('key-prefix');
       return assert.isFulfilled(promise)
         .then(function(result) {
@@ -213,18 +228,16 @@ describe('redis', function() {
     });
 
     it('lists revisions and marks the active one', function() {
-      var recentRevisions = ['a', 'b'];
       var currentRevision = 'b';
 
       var redis = new Redis({}, new FakeRedis(FakeClient.extend({
-        lrange: function() {
-          return recentRevisions;
-        },
         get: function() {
           return currentRevision;
         }
       })));
 
+      redis._client.recentRevisions = ['a', 'b'];
+
       var promise = redis.fetchRevisions('key-prefix');
       return assert.isFulfilled(promise)
         .then(function(result) {