hyper-resource 1.0.0.lap76 → 1.0.0.lap77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ce1175b9a38189b65f6808a5b74886a60c28810049245514277ba23fe2ccbde
-  data.tar.gz: c083a34eaa6f3219a295da8a635caf87e3434aa59c4be2ea744f67cc31e3a4f3
+  metadata.gz: 4564204f79d886ec827b4fdafa1d153ce63b111dd1fc57faaadd47efb53a5dfc
+  data.tar.gz: 325ec362368ddc0e94434f67e665b002b3a47f4ee485e624a3d2b9c5a6e9ba8b
 SHA512:
-  metadata.gz: 96fcb7ba69e61b428eac56b5697763f5a8d9233d3ffce01ca19f4b8298bb6ac19fbdb24cccc577caeef7c3044b7a59ff3a0d7f8ac51751c60962405409adb506
-  data.tar.gz: 46d12e1710df25b38ea9dc7f203e6ae3ef3f006a6f945c5804ca2d0579e49dd2ec34cf56ab0d1b0b8d1b70545c42a81480306180471ddc266aae1daaa8494fee
+  metadata.gz: 983c55f79ca78190707d810008b5e86f0bcad611fb921b5d87b68b5ab0d11d00074cc7a216ab5f00fec80e5e2faef7f313f1ddb1f2ad75b9b2c0e1d1a3dbb012
+  data.tar.gz: ccec9ccfea294761cd2a876fd5094c385ea78d57162707754dd2d1b410e7133adf5f77e28751f0fd818d304202acdd887abd6f36ee1c70d6be2992240ed2fdb4

data/lib/hyper_record/pub_sub.rb

@@ -18,6 +18,35 @@ module HyperRecord
         )
       end
 
+      def publish_record(record)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}")
+        time_now = Time.now.to_f
+        scrub_time = time_now - 24.hours.to_f
+
+        message = {
+          record_type: record.class.to_s,
+          id: record.id,
+          updated_at: record.updated_at
+        }
+        message[:destroyed] = true if record.destroyed?
+
+        # can only trigger to max 10 channels at once on pusher
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
+          end
+          if Hyperloop.resource_transport == :pusher && channel_array.size > 0
+            _pusher_client.trigger_async(channel_array, 'update', message)
+          end
+        end
+        Hyperloop.redis_instance.del("HRPS__#{record.class}__#{record.id}") if record.destroyed?
+      end
+
       def publish_relation(base_record, relation_name, record = nil)
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}")
         time_now = Time.now.to_f
@@ -35,60 +64,40 @@ module HyperRecord
           message[:cause][:updated_at] = record.updated_at
           message[:cause][:destroyed] = true if record.destroyed?
         end
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}", session_id)
-            next
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
           if Hyperloop.resource_transport == :pusher
-            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            _pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
 
-      def publish_record(record)
-        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}")
+      def publish_rest_class_method(record_class, rest_class_method_name)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-
         message = {
-          record_type: record.class.to_s,
-          id: record.id,
-          updated_at: record.updated_at
+          record_type: record_class.to_s,
+          rest_class_method: rest_class_method_name
         }
-        message[:destroyed] = true if record.destroyed?
-
-        subscribers.each_slice(50) do |slice|
-          channel_array= []
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
           slice.each do |session_id, last_requested|
             if last_requested.to_f < scrub_time
-              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}", session_id)
+              Hyperloop.redis_instance.hdel("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}", session_id)
               next
             end
             channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          if Hyperloop.resource_transport == :pusher && channel_array.size > 0
-            _pusher_client.trigger(channel_array, 'update', message)
-          end
-        end
-        Hyperloop.redis_instance.del("HRPS__#{record.class}__#{record.id}") if record.destroyed?
-      end
-
-      def publish_rest_class_method(record_class, rest_class_method_name)
-        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}")
-        time_now = Time.now.to_f
-        scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}", session_id)
-            next
-          end
-          message = {
-            record_type: record_class.to_s,
-            rest_class_method: rest_class_method_name
-          }
           if Hyperloop.resource_transport == :pusher
-            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            _pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
@@ -97,18 +106,22 @@ module HyperRecord
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}", session_id)
-            next
+        message = {
+          record_type: record.class.to_s,
+          id: record.id,
+          rest_method: method_name
+        }
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          message = {
-            record_type: record.class.to_s,
-            id: record.id,
-            rest_method: method_name
-          }
           if Hyperloop.resource_transport == :pusher
-            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            _pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
@@ -117,21 +130,30 @@ module HyperRecord
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__scope__#{scope_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record_class}__scope__#{scope_name}", session_id)
-            next
+        message = {
+          record_type: record_class.to_s,
+          scope: scope_name
+        }
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record_class}__scope__#{scope_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          message = {
-            record_type: record_class.to_s,
-            scope: scope_name
-          }
           if Hyperloop.resource_transport == :pusher
-            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            _pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
 
+      def subscribe_record(record)
+        return unless session.id
+        Hyperloop.redis_instance.hset "HRPS__#{record.class}__#{record.id}", session.id.to_s, Time.now.to_f.to_s
+      end
+
       def subscribe_relation(relation, base_record = nil, relation_name = nil)
         return unless session.id
         time_now = Time.now.to_f.to_s
@@ -150,11 +172,6 @@ module HyperRecord
         end
       end
 
-      def subscribe_record(record)
-        return unless session.id
-        Hyperloop.redis_instance.hset "HRPS__#{record.class}__#{record.id}", session.id.to_s, Time.now.to_f.to_s
-      end
-
       def subscribe_rest_class_method(record_class, rest_class_method_name)
         return unless session.id
         time_now = Time.now.to_f.to_s
@@ -185,16 +202,16 @@ module HyperRecord
         end
       end
 
-      def pub_sub_relation(relation, base_record, relation_name, causing_record = nil)
-        subscribe_relation(relation, base_record, relation_name)
-        publish_relation(base_record, relation_name, causing_record)
-      end
-
       def pub_sub_record(record)
         subscribe_record(record)
         publish_record(record)
       end
 
+      def pub_sub_relation(relation, base_record, relation_name, causing_record = nil)
+        subscribe_relation(relation, base_record, relation_name)
+        publish_relation(base_record, relation_name, causing_record)
+      end
+
       def pub_sub_rest_class_method(record_class, rest_class_method_name)
         subscribe_rest_class_method(record_class, rest_class_method_name)
         publish_rest_class_method(record_class, rest_class_method_name)
@@ -217,36 +234,60 @@ module HyperRecord
 
     # instance methods
 
+    def publish_record(record)
+      self.class.publish_record(record)
+    end
+
     def publish_relation(base_record, relation_name, record = nil)
       self.class.publish_relation(base_record, relation_name, record)
     end
 
-    def publish_record(record)
-      self.class.publish_record(record)
+    def publish_rest_class_method(record_class, rest_class_method_name)
+      self.class.publish_rest_class_method(record_class, rest_class_method_name)
+    end
+
+    def publish_rest_method(record, method_name)
+      self.class.publish_rest_method(record, method_name)
     end
 
     def publish_scope(record_class, scope_name)
       self.class.publish_scope(record_class, scope_name)
     end
 
+    def subscribe_record(record)
+      self.class.subscribe_record(record)
+    end
+
     def subscribe_relation(relation, base_record = nil, relation_name = nil)
       self.class.subscribe_relation(relation, base_record, relation_name)
     end
 
-    def subscribe_record(record)
-      self.class.subscribe_record(record)
+    def subscribe_rest_class_method(record_class, rest_class_method_name)
+      self.class.subscribe_rest_class_method(record_class, rest_class_method_name)
+    end
+
+    def subscribe_rest_method(record, method_name)
+      self.class.subscribe_rest_method(record, method_name)
     end
 
     def subscribe_scope(collection, record_class = nil, scope_name = nil)
       self.class.subscribe_scope(collection, record_class, scope_name)
     end
 
+    def pub_sub_record(record)
+      self.class.pub_sub_record(record)
+    end
+
     def pub_sub_relation(relation, base_record, relation_name, causing_record = nil)
       self.class.pub_sub_relation(relation, base_record, relation_name, causing_record)
     end
 
-    def pub_sub_record(record)
-      self.class.pub_sub_record(record)
+    def pub_sub_rest_class_method(record_class, rest_class_method_name)
+      self.class.pub_sub_rest_class_method(record_class, rest_class_method_name)
+    end
+
+    def pub_sub_rest_method(record, method_name)
+      self.class.pub_sub_rest_method(record, method_name)
     end
 
     def pub_sub_scope(collection, record_class, scope_name)

data/lib/hyperloop/resource/pub_sub.rb

@@ -16,6 +16,35 @@ module Hyperloop
         end
       end
 
+      def publish_record(record)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}")
+        time_now = Time.now.to_f
+        scrub_time = time_now - 24.hours.to_f
+
+        message = {
+          record_type: record.class.to_s,
+          id: record.id,
+          updated_at: record.updated_at
+        }
+        message[:destroyed] = true if record.destroyed?
+
+        # can only trigger to max 10 channels at once on pusher
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
+          end
+          if Hyperloop.resource_transport == :pusher && channel_array.size > 0
+            self.class._pusher_client.trigger_async(channel_array, 'update', message)
+          end
+        end
+        Hyperloop.redis_instance.del("HRPS__#{record.class}__#{record.id}") if record.destroyed?
+      end
+
       def publish_relation(base_record, relation_name, record = nil)
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}")
         time_now = Time.now.to_f
@@ -31,61 +60,42 @@ module Hyperloop
           message[:cause][:record_type] = record.class.to_s
           message[:cause][:id] = record.id
           message[:cause][:updated_at] = record.updated_at
+          message[:cause][:destroyed] = true if record.destroyed?
         end
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}", session_id)
-            next
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{base_record.class}__#{base_record.id}__#{relation_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
           if Hyperloop.resource_transport == :pusher
-            self.class._pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            self.class._pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
 
-      def publish_record(record)
-        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}")
+      def publish_rest_class_method(record_class, rest_class_method_name)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-
         message = {
-          record_type: record.class.to_s,
-          id: record.id,
-          updated_at: record.updated_at
+          record_type: record_class.to_s,
+          rest_class_method: rest_class_method_name
         }
-        message[:destroyed] = true if record.destroyed?
-
-        subscribers.each_slice(50) do |slice|
-          channel_array= []
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
           slice.each do |session_id, last_requested|
             if last_requested.to_f < scrub_time
-              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}", session_id)
+              Hyperloop.redis_instance.hdel("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}", session_id)
               next
             end
             channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          if Hyperloop.resource_transport == :pusher && channel_array.size > 0
-            self.class._pusher_client.trigger(channel_array, 'update', message)
-          end
-        end
-        Hyperloop.redis_instance.del("HRPS__#{record.class}__#{record.id}") if record.destroyed?
-      end
-
-      def publish_rest_class_method(record_class, rest_class_method_name)
-        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}")
-        time_now = Time.now.to_f
-        scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}", session_id)
-            next
-          end
-          message = {
-            record_type: record_class.to_s,
-            rest_class_method: rest_class_method_name
-          }
           if Hyperloop.resource_transport == :pusher
-            self.class._pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            self.class._pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
@@ -94,18 +104,22 @@ module Hyperloop
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}", session_id)
-            next
+        message = {
+          record_type: record.class.to_s,
+          id: record.id,
+          rest_method: method_name
+        }
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          message = {
-            record_type: record.class.to_s,
-            id: record.id,
-            rest_method: method_name
-          }
           if Hyperloop.resource_transport == :pusher
-            self.class._pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            self.class._pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
@@ -114,21 +128,30 @@ module Hyperloop
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__scope__#{scope_name}")
         time_now = Time.now.to_f
         scrub_time = time_now - 24.hours.to_f
-        subscribers.each do |session_id, last_requested|
-          if last_requested.to_f < scrub_time
-            Hyperloop.redis_instance.hdel("HRPS__#{record_class}__scope__#{scope_name}", session_id)
-            next
+        message = {
+          record_type: record_class.to_s,
+          scope: scope_name
+        }
+        subscribers.each_slice(10) do |slice|
+          channel_array = []
+          slice.each do |session_id, last_requested|
+            if last_requested.to_f < scrub_time
+              Hyperloop.redis_instance.hdel("HRPS__#{record_class}__scope__#{scope_name}", session_id)
+              next
+            end
+            channel_array << "hyper-record-update-channel-#{session_id}"
           end
-          message = {
-            record_type: record_class.to_s,
-            scope: scope_name
-          }
           if Hyperloop.resource_transport == :pusher
-            self.class._pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+            self.class._pusher_client.trigger_async(channel_array, 'update', message)
           end
         end
       end
 
+      def subscribe_record(record)
+        return unless session.id
+        Hyperloop.redis_instance.hset "HRPS__#{record.class}__#{record.id}", session.id.to_s, Time.now.to_f.to_s
+      end
+
       def subscribe_relation(relation, base_record = nil, relation_name = nil)
         return unless session.id
         time_now = Time.now.to_f.to_s
@@ -147,11 +170,6 @@ module Hyperloop
         end
       end
 
-      def subscribe_record(record)
-        return unless session.id
-        Hyperloop.redis_instance.hset "HRPS__#{record.class}__#{record.id}", session.id.to_s, Time.now.to_f.to_s
-      end
-
       def subscribe_rest_class_method(record_class, rest_class_method_name)
         return unless session.id
         time_now = Time.now.to_f.to_s
@@ -182,16 +200,16 @@ module Hyperloop
         end
       end
 
-      def pub_sub_relation(relation, base_record, relation_name, causing_record = nil)
-        subscribe_relation(relation, base_record, relation_name)
-        publish_relation(base_record, relation_name, causing_record)
-      end
-
       def pub_sub_record(record)
         subscribe_record(record)
         publish_record(record)
       end
 
+      def pub_sub_relation(relation, base_record, relation_name, causing_record = nil)
+        subscribe_relation(relation, base_record, relation_name)
+        publish_relation(base_record, relation_name, causing_record)
+      end
+
       def pub_sub_rest_class_method(record_class, rest_class_method_name)
         subscribe_rest_class_method(record_class, rest_class_method_name)
         publish_rest_class_method(record_class, rest_class_method_name)

data/lib/hyperloop/resource/version.rb

@@ -1,5 +1,5 @@
 module Hyperloop
   module Resource
-    VERSION = '1.0.0.lap76'
+    VERSION = '1.0.0.lap77'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyper-resource
 version: !ruby/object:Gem::Version
-  version: 1.0.0.lap76
+  version: 1.0.0.lap77
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal