loco-rails 4.1.1 → 5.0.0

data/lib/loco/emitter.rb

@@ -3,23 +3,28 @@
 module Loco
   module Emitter
     def emit(obj, event = nil, opts = {})
-      Broadcaster.new(obj, event, opts).emit
+      Broadcaster.(
+        obj,
+        event,
+        payload: opts[:payload] || opts[:data],
+        recipients: opts[opts[:for] ? :for : :to]
+      )
     end
 
-    def emit_to(recipient, data)
-      Sender.new(recipient, data).emit
+    def emit_to(recipient_s, data)
+      Sender.(recipient_s, data)
     end
 
     def add_hub(name, members = [])
-      Hub.new(name, members).save
+      Hub.set(name, members)
     end
 
     def get_hub(name)
-      Hub.get name
+      Hub.get(name)
     end
 
     def del_hub(name)
-      hub = Hub.get name
+      hub = Hub.get(name)
       return false if hub.nil?
 
       hub.destroy

data/lib/loco/hub.rb

@@ -2,71 +2,64 @@
 
 module Loco
   class Hub
-    PREFIX = 'loco:hub:'
-
-    attr_reader :raw_members
-
-    def initialize(name, members = [])
-      @name = "#{PREFIX}#{name}"
-      @raw_members = members.map { |m| serialize m }
-    end
+    PREFIX = 'hub:'
 
     class << self
+      def set(name, members)
+        new(name, members)
+      end
+
       def get(name)
-        hub = WsConnectionStorage.current.get "#{PREFIX}#{name}"
-        return nil if hub.blank?
+        return nil if WsConnectionStorage.current.type("s:#{full_name(name)}") != 'set'
 
-        new name, JSON.parse(hub)
+        new(name)
       end
+
+      def full_name(val)
+        "#{PREFIX}#{val}"
+      end
+    end
+
+    def initialize(name, members = [])
+      @name = self.class.full_name(name)
+      members.map { |member| add_member(member) }
     end
 
     def name
-      @name.split(PREFIX).last
+      full_name.split(PREFIX).last
     end
 
-    def add_member(member)
-      serialized = serialize member
-      return raw_members if raw_members.include? serialized
+    def full_name
+      @name
+    end
 
-      raw_members << serialized
-      save
-      raw_members
+    def add_member(member)
+      WsConnectionStorage.current.add(@name, WsConnectionIdentifier.(member))
     end
 
     def del_member(member)
-      serialized = serialize member
-      return nil unless raw_members.include? serialized
-
-      raw_members.delete serialized
-      save
-      serialized
+      WsConnectionStorage.current.rem(@name, WsConnectionIdentifier.(member))
     end
 
     def destroy
-      WsConnectionStorage.current.del @name
-      true
+      WsConnectionStorage.current.members(@name).each do |member|
+        WsConnectionStorage.current.rem(@name, member)
+      end
     end
 
-    def save
-      WsConnectionStorage.current.set @name, raw_members.to_json
-      self
+    def include?(resource)
+      WsConnectionStorage.current.member?(@name, WsConnectionIdentifier.(resource))
     end
 
-    def include?(resource)
-      raw_members.include? serialize(resource)
+    def raw_members
+      WsConnectionStorage.current.members(@name)
     end
 
     def members
-      raw_members.map do |str|
-        klass, id = str.split ':'
-        klass.classify.constantize.find_by id: id
+      raw_members.map do |serialized|
+        klass, id = serialized.split(':')
+        klass.classify.constantize.find_by(id: id)
       end
     end
-
-    private
-
-    def serialize(member)
-      WsConnectionManager.new(member).identifier
-    end
   end
 end

data/lib/loco/permissions_presenter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Loco
+  module PermissionsPresenter
+    module_function
+
+    def indexed(loco_permissions, opts = {})
+      h = signed_in(loco_permissions).index_by do |o|
+        o.class.name.downcase.to_sym
+      end
+      if opts[:except] == :uuid
+        h.reject { |k, _| k == :string }
+      else
+        h
+      end
+    end
+
+    def signed_in(loco_permissions, opts = {})
+      arr = loco_permissions.compact
+      if opts[:except] == :uuid
+        arr.reject { |e| e.is_a?(String) }
+      else
+        arr
+      end
+    end
+  end
+end

data/lib/loco/sender.rb

@@ -2,43 +2,60 @@
 
 module Loco
   class Sender
-    def initialize(recipient, data = {})
-      @recipients = [*recipient]
-      @data = data
+    class << self
+      def call(recipient_s, payload = {})
+        payload = with_idempotency_key(payload)
+        recipients = recipient_s.is_a?(Array) ? recipient_s : [recipient_s]
+        new.(recipients, payload)
+      end
+
+      private
+
+      def with_idempotency_key(payload)
+        hash = payload.clone
+        hash[:loco] ||= {}
+        hash[:loco][:idempotency_key] ||= hash[:idempotency_key] || SecureRandom.hex
+        hash.delete(:idempotency_key)
+        hash
+      end
+    end
+
+    def initialize
+      @uuids = []
     end
 
-    def emit
-      uuids.each do |uuid|
-        NotificationCenterChannel.broadcast_to(uuid, payload)
+    def call(recipients, payload)
+      recipients.each do |recipient|
+        case recipient
+        when String then broadcast_to(recipient, payload)
+        when Hash then process_hash(recipient, payload)
+        else find_and_broadcast_to(recipient, payload)
+        end
       end
       payload[:loco][:idempotency_key]
     end
 
     private
 
-    def uuids
-      @recipients.map do |r|
-        if r.is_a? String
-          r
-        elsif r.is_a? Hub
-          recipients_from_hub r
-        else
-          WsConnectionManager.new(r).connected_uuids
-        end
-      end.flatten.uniq
+    def process_hash(recipient, payload)
+      if recipient.key?('token')
+        find_and_broadcast_to(recipient['token'], payload)
+      elsif recipient.key?('class')
+        find_and_broadcast_to(recipient['class'].constantize, payload)
+      end
     end
 
-    def recipients_from_hub(hub)
-      hub.raw_members.map do |m|
-        WsConnectionManager.new(m).connected_uuids
-      end.flatten.uniq
+    def find_and_broadcast_to(recipient, payload)
+      WsConnectionFinder.(recipient) do |uuid|
+        broadcast_to(uuid, payload)
+      end
     end
 
-    def payload
-      @data[:loco] ||= {}
-      @data[:loco][:idempotency_key] ||= @data[:idempotency_key] || SecureRandom.hex
-      @data.delete(:idempotency_key)
-      @data
+    def broadcast_to(uuid, payload)
+      return if @uuids.include?(uuid)
+
+      @uuids << uuid
+      NotificationCenterChannel.broadcast_to(uuid, payload)
     end
   end
 end

data/lib/loco/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loco
-  VERSION = '4.1.1'
+  VERSION = '5.0.0'
 end

data/lib/loco/ws_connection_checker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Loco
+  module WsConnectionChecker
+    module_function
+
+    def call(identifier, skip: nil)
+      WsConnectionStorage.current.members(identifier).each do |uuid|
+        next if uuid == skip
+        next if WsConnectionStorage.current.get(uuid) == 'ok'
+
+        WsConnectionManager.new(identifier, identifier: true).del(uuid, skip_checker: true)
+      end
+    end
+  end
+end

data/lib/loco/ws_connection_finder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Loco
+  class WsConnectionFinder
+    class << self
+      def call(resources, &block)
+        storage = WsConnectionStorage.current
+        resources = [resources] unless resources.is_a?(Array)
+        resources.each do |resource|
+          case resource
+          when :all then storage.scan(all: true, &block)
+          when Hub then search_the_hub(resource, &block)
+          when Class
+            storage.scan(match: "#{WsConnectionIdentifier.(resource)}:*", &block)
+          else
+            storage.members(WsConnectionIdentifier.(resource)).each(&block)
+          end
+        end
+      end
+
+      private
+
+      def search_the_hub(resource, &block)
+        WsConnectionStorage.current.members(resource.full_name).map do |serialized|
+          WsConnectionStorage.current.members(serialized).each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/loco/ws_connection_identifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Loco
+  module WsConnectionIdentifier
+    module_function
+
+    def call(resource)
+      case resource
+      when String then resource
+      when Class then resource.name.downcase
+      else "#{resource.class.name.downcase}:#{resource.id}"
+      end
+    end
+  end
+end

data/lib/loco/ws_connection_manager.rb

@@ -2,92 +2,38 @@
 
 module Loco
   class WsConnectionManager
-    def initialize(resource)
-      @resource = resource
-    end
-
-    def identifier
-      return @resource if @resource.is_a?(String)
-
-      "#{@resource.class.name.downcase}:#{@resource.id}"
-    end
-
-    def connected?(uuid)
-      connected_uuids.include? uuid
-    end
+    EXPIRATION = 60 * 3
 
-    def connected_uuids
-      data.find_all { |_, v| v.is_a? String }.to_h.keys
+    def initialize(resource, opts = {})
+      if opts[:identifier]
+        @identifier = resource
+      else
+        @resource = resource
+      end
     end
 
     def add(uuid)
-      update uuid
-      check_connections
+      WsConnectionStorage.current.add(identifier, uuid)
+      WsConnectionStorage.current.add("uuid:#{uuid}", identifier)
+      update(uuid)
+      WsConnectionChecker.(identifier, skip: uuid)
     end
 
-    def del(uuid)
-      save(data.tap { |h| h.delete uuid })
-      check_connections
+    def del(uuid, skip_checker: false)
+      WsConnectionStorage.current.rem(identifier, uuid)
+      WsConnectionStorage.current.rem("uuid:#{uuid}", identifier)
+      WsConnectionStorage.current.del(uuid)
+      WsConnectionChecker.(identifier) unless skip_checker
     end
 
     def update(uuid)
-      save(data.tap { |h| h[uuid] = current_time })
+      WsConnectionStorage.current.set(uuid, 'ok', ex: EXPIRATION)
     end
 
-    def destroy
-      WsConnectionStorage.current.del identifier
-    end
-
-    protected
-
-    def data
-      serialized_uuids = WsConnectionStorage.current.get identifier
-      return {} if serialized_uuids.blank?
-
-      JSON.parse serialized_uuids
-    end
-
-    def uuids
-      data.keys
-    end
+    private
 
-    def save(hash)
-      WsConnectionStorage.current.set identifier, hash.to_json
-    end
-
-    def check_connections
-      hash = data.to_a.map do |arr|
-        uuid, val = check_connection arr.first, arr.last
-        [uuid, val]
-      end.to_h.compact
-      save hash
-    end
-
-    def check_connection(uuid, val)
-      case val
-      when String
-        val = check_connection_str uuid, val
-      when Hash
-        uuid, val = check_connection_hash uuid, val
-      end
-      [uuid, val]
-    end
-
-    def check_connection_str(uuid, val)
-      return val if Time.zone.parse(val) >= 3.minutes.ago
-
-      SenderJob.perform_later uuid, loco: { connection_check: true }
-      { 'check' => current_time }
-    end
-
-    def check_connection_hash(uuid, val)
-      return [uuid, val] if Time.zone.parse(val['check']) >= 5.seconds.ago
-
-      [nil, nil]
-    end
-
-    def current_time
-      Time.current.iso8601(6)
+    def identifier
+      @identifier ||= WsConnectionIdentifier.(@resource)
     end
   end
 end

data/lib/loco/ws_connection_storage.rb

@@ -13,37 +13,77 @@ module Loco
     end
 
     def initialize
-      @storage = Config.redis_instance || {}
+      @storage = Config.redis_instance
     end
 
-    def get(key)
-      case @storage
-      when Hash
-        storage[proper_key(key)]
+    def type(key)
+      storage.type(proper_key(key))
+    end
+
+    def exists?(key)
+      storage.exists?(proper_key(key))
+    end
+
+    def get(key, hkey = nil)
+      if !hkey.nil?
+        storage.hget(proper_key("h:#{key}"), hkey)
       else
-        storage.get proper_key(key)
+        storage.get(proper_key("k:#{key}"))
       end
     end
 
-    def set(key, val)
-      case @storage
-      when Hash
-        storage[proper_key(key)] = val
+    def set(key, val, opts = {})
+      if val.is_a?(Hash)
+        storage.hset(proper_key("h:#{key}"), val)
       else
-        storage.set proper_key(key), val
+        storage.set(proper_key("k:#{key}"), val, ex: opts[:ex])
       end
     end
 
-    def del(key)
-      case @storage
-      when Hash
-        storage.delete proper_key(key)
+    def del(key, hkey = nil)
+      if !hkey.nil?
+        storage.hdel(proper_key("h:#{key}"), hkey)
       else
-        storage.del proper_key(key)
+        storage.del(proper_key("k:#{key}"))
+      end
+    end
+
+    def scan(match: nil, all: false, &block)
+      match = 'uuid:*' if all
+      storage.scan_each(match: "#{proper_key('s:')}#{match}").each do |key|
+        if all
+          yield(key.split('uuid:').last)
+        else
+          storage.smembers(key).each(&block)
+        end
       end
     end
 
-    protected
+    def scan_hash(key, &block)
+      storage.hscan_each(proper_key("h:#{key}"), &block)
+    end
+
+    def hlen(key)
+      storage.hlen(proper_key("h:#{key}"))
+    end
+
+    def add(key, val)
+      storage.sadd(proper_key("s:#{key}"), val)
+    end
+
+    def members(key)
+      storage.smembers(proper_key("s:#{key}"))
+    end
+
+    def member?(key, val)
+      storage.sismember(proper_key("s:#{key}"), val)
+    end
+
+    def rem(key, val)
+      storage.srem(proper_key("s:#{key}"), val)
+    end
+
+    private
 
     def proper_key(key)
       "#{Config.app_name}:#{key}"