cloudcms-server 0.9.261 → 0.9.264

package/middleware/awareness/providers/abstract-async.js

@@ -14,28 +14,33 @@ class AbstractAsyncProvider extends AbstractProvider
     {
         super(config);
     }
-
+    
+    _lock(lockKey, workFunction)
+    {
+        process.locks.lock(lockKey, workFunction);
+    }
+    
     readOrCreateChannel(channelId, callback) {
 
         var self = this;
 
         self.readChannel(channelId, function(err, channel) {
-
+    
             if (err) {
                 return callback(err);
             }
-
+    
             if (channel) {
                 return callback(null, channel);
             }
 
             var channel = {};
             self.writeChannel(channelId, channel, function(err) {
-
+    
                 if (err) {
                     return callback(err);
                 }
-
+    
                 callback(null, channel);
             });
         });
@@ -46,26 +51,52 @@ class AbstractAsyncProvider extends AbstractProvider
     register(channelId, user, callback)
     {
         var self = this;
-
+        
+        //console.log("a1");
+        self._lock("channels", function(err, releaseLockFn) {
+            // console.log("a2: ", err);
+            // console.log("a3: ", releaseLockFn);
+            self.doRegister(channelId, user, function(err) {
+                // console.log("a4 ", err);
+                callback(err);
+                // console.log("a5: ", releaseLockFn);
+                return releaseLockFn();
+            });
+        });
+    }
+    
+    /**
+     * Workhorse method.  The "channels" lock is taken out ahead of this being called.
+     *
+     * @param channelId
+     * @param user
+     * @param callback
+     * @private
+     */
+    doRegister(channelId, user, callback)
+    {
+        var self = this;
+        
         self.readOrCreateChannel(channelId, function (err, channel) {
-
+    
             if (err) {
                 return callback(err);
             }
-
+        
             if (!channel.users) {
                 channel.users = {};
             }
-
+        
             channel.users[user.id] = {
                 "user": user,
                 "time": new Date().getTime()
             };
-
+            
             self.writeChannel(channelId, channel, function (err) {
                 callback(err);
             });
         });
+        
     }
 
     discover(channelId, callback)
@@ -101,123 +132,136 @@ class AbstractAsyncProvider extends AbstractProvider
         });
     }
 
-    expire(beforeMs, callback)
+    checkRegistered(channelId, userId, callback)
     {
         var self = this;
 
-        self.listChannelIds(function(err, channelIds) {
+        self.readChannel(channelId, function(err, channel) {
 
             if (err) {
                 return callback(err);
             }
 
+            if (!channel) {
+                return callback(null, false);
+            }
+
+            if (!channel.users) {
+                return callback(null, false);
+            }
+
+            if (channel.users[userId]) {
+                return callback(null, true);
+            }
+
+            callback(null, false);
+
+        });
+    }
+    
+    expire(beforeMs, callback)
+    {
+        var self = this;
+        
+        self._lock("channels", function(err, releaseLockFn) {
+            self._expire(beforeMs, function(err) {
+                callback(err);
+                return releaseLockFn();
+            });
+        });
+    }
+    
+    /**
+     * @override
+     */
+    _expire(beforeMs, callback)
+    {
+        var self = this;
+        
+        self.listChannelIds(function(err, channelIds) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
             if (!channelIds || channelIds.length === 0) {
                 return callback(null, [], {});
             }
-
+            
             // a list of channel IDs whose memberships were updated
             var updatedMembershipChannelIds = [];
             var expiredUserIdsByChannelId = {};
-
+            
             var fns = [];
-
+            
             for (var i = 0; i < channelIds.length; i++)
             {
                 var channelId = channelIds[i];
-
+                
                 var fn = function (channelId, updatedMembershipChannelIds, expiredUserIdsByChannelId, beforeMs) {
                     return function (done) {
-
+                        
                         self.readChannel(channelId, function(err, channel) {
-
+                            
                             if (err) {
                                 return done(err);
                             }
-
+                            
                             if (!channel) {
                                 return done();
                             }
+                            
+                            if (!channel.users || Object.keys(channel.users).length === 0)
+                            {
+                                return done();
+                            }
 
-                            var updatedMembership = false;
-
-                            if (channel.users)
+                            // populate all of the user IDs that need to be removed
+                            var userIdsToRemove = [];
+                            for (var userId in channel.users)
                             {
-                                // populate all of the user IDs that need to be removed
-                                var userIdsToRemove = [];
-                                for (var userId in channel.users)
+                                var entry = channel.users[userId];
+                                if (entry.time < beforeMs)
                                 {
-                                    var entry = channel.users[userId];
-                                    if (entry.time < beforeMs)
-                                    {
-                                        updatedMembership = true;
-                                        userIdsToRemove.push(userId);
-
-                                        var expiredUserIds = expiredUserIdsByChannelId[channelId]
-                                        if (!expiredUserIds) {
-                                            expiredUserIds = expiredUserIdsByChannelId[channelId] = [];
-                                        }
-
-                                        expiredUserIds.push(userId);
+                                    updatedMembershipChannelIds.push(channelId);
+                                    userIdsToRemove.push(userId);
+                                    
+                                    var expiredUserIds = expiredUserIdsByChannelId[channelId]
+                                    if (!expiredUserIds) {
+                                        expiredUserIds = expiredUserIdsByChannelId[channelId] = [];
                                     }
-                                }
-
-                                // remove the user IDs
-                                for (var i = 0; i < userIdsToRemove.length; i++)
-                                {
-                                    delete channel.users[userIdsToRemove[i]];
+                                    
+                                    expiredUserIds.push(userId);
                                 }
                             }
-
-                            if (updatedMembership)
+                            
+                            // remove the user IDs
+                            for (var i = 0; i < userIdsToRemove.length; i++)
                             {
-                                updatedMembershipChannelIds.push(channelId);
+                                delete channel.users[userIdsToRemove[i]];
                             }
-
-                            done();
+                            
+                            self.writeChannel(channelId, channel, function() {
+                                done();
+                            });
+                            
                         });
                     };
                 }(channelId, updatedMembershipChannelIds, expiredUserIdsByChannelId, beforeMs);
                 fns.push(fn);
             }
-
+            
             async.parallel(fns, function(err) {
-
+                
                 if (err) {
                     return callback(err);
                 }
-
+                
                 callback(null, updatedMembershipChannelIds, expiredUserIdsByChannelId);
             });
         });
-    }
-
-    checkRegistered(channelId, userId, callback)
-    {
-        var self = this;
-
-        self.readChannel(channelId, function(err, channel) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (!channel) {
-                return callback(null, false);
-            }
-
-            if (!channel.users) {
-                return callback(null, false);
-            }
-
-            if (channel.users[userId]) {
-                return callback(null, true);
-            }
-
-            callback(null, false);
-
-        });
-    }
-
+    };
+    
     acquireLock(channelId, user, callback)
     {
         var self = this;
@@ -303,14 +347,16 @@ class AbstractAsyncProvider extends AbstractProvider
             callback(null, lock);
         });
     }
-
-
+    
+    
+    
+    
     //////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // ABSTRACT METHODS
     //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////
-
+    
     // ABSTRACT
     readChannel(channelId, callback)
     {
@@ -328,7 +374,7 @@ class AbstractAsyncProvider extends AbstractProvider
     {
         throw new Error("listChannelIds() method is not implemented");
     }
-
+    
     // ABSTRACT
     readLock(lockId, callback)
     {

package/middleware/awareness/providers/abstract.js

@@ -2,7 +2,7 @@
  * Abstract class for an Awareness Provider.
  *
  * This class provides an interface or base functions that any implementation class must implement in order to
- * work with the Awareness Service.  Any methods that
+ * work with the Awareness Service.
  *
  */
 class AbstractProvider

package/middleware/awareness/providers/memory.js

@@ -24,20 +24,6 @@ class MemoryProvider extends AbstractAsyncProvider
         callback();
     }
 
-    readOrCreateChannel(channelId, callback)
-    {
-        var self = this;
-
-        var channel = self.channelMap[channelId];
-        if (channel) {
-            return callback(null, channel);
-        }
-
-        channel = self.channelMap[channelId] = {};
-
-        callback(null, channel);
-    }
-
     readChannel(channelId, callback)
     {
         var self = this;