cable_room 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 841a40a6a2460c6be5811f2fe24e6fffc1bb7291446029bf1e62497df24ee507
-  data.tar.gz: fff54424d08af52f0a35d23089f7437054b6d2e9a63ae66d620d7678edeadfdf
+  metadata.gz: 319532a2546c5bbd96b89ca34c9a44ba963a5bc97bc62e5faacf8417cb815783
+  data.tar.gz: 2d1c92b8e36af65a69182537ba25b2ba5652569e21d398f9bccbd91011e6e411
 SHA512:
-  metadata.gz: d44fa0d6f66a5905e20ad96b3df974d9d44e43e9c057a8de6316def16f3d577c8f3270254c27cc5c0e1fc4a3fab0be2307566f55b77ada20a53c04f946c1834b
-  data.tar.gz: ac558498e04bf2d82a9048a7ff1cab21324cc14c36fbcf9073311c3d7bc62cd1094e7df2a17b129cdd5e6bdb06e4befbec49bb6e57f310e4323aab4b2217d4e7
+  metadata.gz: 25afc8414cc55c14d41a72c2d8898c026d442f204744a1a67721e2fd6e6b6b9ea9013bfe727ba98984475c504b00eb95bda324fdf2c60a6e2b9269d5e3fb4e17
+  data.tar.gz: 903fa66437dec42ba12b87c49a0864b561b0b8b2f302de05f80482d8a086a1e7971ba5f03e04146e4905b6854f017c2d311e222393ba977cca9936d5b656f306

data/lib/cable_room/channel_base.rb

@@ -67,8 +67,11 @@ module CableRoom
       @mutex.synchronize do
         @current_state = :shutting_down
         stop_all_streams
-        @room.send(:_shutdown)
-        terminate!
+        begin
+          @room.send(:_shutdown)
+        ensure
+          terminate!
+        end
       end
     end
 
@@ -80,7 +83,9 @@ module CableRoom
     end
 
     def check_room_watchdog
-      return if state == :dead || state == :shutting_down
+      @mutex.synchronize do
+        return if state == :dead || state == :shutting_down
+      end
 
       relock = CableRoom.lock_manager.lock(@lock_info[:resource], @lock_duration.in_milliseconds, extend: @lock_info)
       unless relock
@@ -121,7 +126,7 @@ module CableRoom
       end
     end
 
-    def post_work(async: false, silent: false, &blk)
+    def _post_wrapped_work(async: false, silent: false, &blk)
       if async
         # Async stuff is mostly untracked - we just post it to the worker pool and forget about it
         worker_pool.executor.post(&blk)
@@ -137,6 +142,14 @@ module CableRoom
       end
     end
 
+    def post_work(**kwargs, &blk)
+      _post_wrapped_work(**kwargs) do
+        worker_pool.invoke(self, :instance_exec, connection: self, &blk)
+      rescue => e
+        logger.error "Error during work execution: #{e.class.name}: #{e.message}"
+      end
+    end
+
     def beat
       post_work(async: true) do
         check_room_watchdog
@@ -184,7 +197,7 @@ module CableRoom
 
   class DummyConnection
     attr_reader :channel
-    delegate :server, :logger, :tenant, :transmit, :post_work, to: :channel
+    delegate :server, :logger, :tenant, :transmit, :post_work, :_post_wrapped_work, to: :channel
     delegate :event_loop, :pubsub, :worker_pool, to: :server
 
     attr_reader :identifiers

data/lib/cable_room/channel_tracker.rb

@@ -96,7 +96,7 @@ module CableRoom
         ActionCable::Server::Worker.connection = pconn
       end
 
-      def async_invoke(receiver, method, *args, connection: receiver, async: nil, silent: false, &block)
+      def async_invoke(receiver, method, *args, connection: receiver, &block)
         # Instead of posting directly to the global pool, post to a dedicated queue for the room/"connection".
         #   This makes each rooms so that they can be processed by at-most-one thread at a time, while still
         #   allowing multiple rooms to be processed by the same thread-pool.
@@ -105,7 +105,7 @@ module CableRoom
 
         # "connection" here really references the Channel, since "Connections" in this context don't really exist
 
-        connection.post_work(async:, silent:) do
+        connection._post_wrapped_work(async: false) do
           invoke(receiver, method, *args, connection: connection, &block)
         end
       end

data/lib/cable_room/room/base.rb

@@ -50,15 +50,19 @@ module CableRoom
       end
 
       include Ports
+
       include Callbacks
       include Threading
       include ChannelAdapter
-      include InputHandling
+
       include Lifecycle
       include Reaping
+      include InputHandling
 
-      include MemberManagement
+      include PortScoping
+      include PortManagement
       include UserManagement
+      include Broadcasting
 
       attr_reader :key
 

data/lib/cable_room/room/broadcasting.rb

@@ -0,0 +1,13 @@
+module CableRoom
+  module Room
+    module Broadcasting
+      extend ActiveSupport::Concern
+
+      def broadcast(message, **kwargs)
+        with_port_scope!(**kwargs) do |client_port: nil|
+          ports[client_port || self.class::ROOM_OUT_CHANNEL] << message
+        end
+      end
+    end
+  end
+end

data/lib/cable_room/room/input_handling.rb

@@ -1,16 +1,58 @@
 module CableRoom
   module Room
+    thread_mattr_accessor :current_message
+
     module InputHandling
       extend ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+
+      class_methods do
+        def authorize_inbound(symbol_or_proc = nil, only: nil, except: nil, &blk)
+          raise ArgumentError, "Must provide either a symbol, proc, or block" unless symbol_or_proc ^ blk
+
+          only = Set.new(Array(only).map(&:to_sym)) if only
+          except = Set.new(Array(except).map(&:to_sym)) if except
+
+          blk = symbol_or_proc if symbol_or_proc.is_a?(Proc)
+          blk = -> { send(symbol_or_proc) } if symbol_or_proc.is_a?(Symbol)
+
+          set_callback(:receive_message, :before) do
+            type = message['type'].to_s.underscore.to_sym
+            if (only && !only.include?(type)) || (except && except.include?(type))
+              next
+            end
+
+            unless instance_exec(message, &blk)
+              logger.warn "Dropping unauthorized message: #{message.inspect}"
+              throw :abort
+            end
+          end
+        end
+      end
 
       included do
+        define_callbacks :receive_message
+
+        set_callback(:receive_message, :before) do
+          logger.debug "Received message: #{message.inspect}"
+        end
+
+        set_callback(:receive_message, :before) do
+          if message == "KILL"
+            shutdown!
+            throw :abort
+          end
+        end
+
         before_startup do
           ports[self.class::ROOM_IN_CHANNEL].stream do |message|
-            logger.debug "Received message: #{message.inspect}"
-            if message == "KILL"
-              shutdown!
-            else
-              handle_received_message(message)
+            begin
+              Room.current_message = message
+              run_callbacks :receive_message do
+                handle_received_message(message)
+              end
+            ensure
+              Room.current_message = nil
             end
           end
         end
@@ -18,6 +60,10 @@ module CableRoom
 
       protected
 
+      def message
+        Room.current_message
+      end
+
       def handle_received_message(message)
         sym = :"on_#{message['type'].underscore.to_s.downcase}"
         if respond_to?(sym, true)

data/lib/cable_room/room/port_management.rb

@@ -0,0 +1,295 @@
+module CableRoom
+  module Room
+    module PortManagement
+      extend ActiveSupport::Concern
+
+      PORT_TIMEOUT = 30.seconds
+
+      class_methods do
+        def inbound_require_tag(tag, **kwargs)
+          tag_array = Array(tag).map(&:to_sym)
+          authorize_inbound(**kwargs) do |message|
+            (tag_array - origin_tags).empty?
+          end
+        end
+
+        def inbound_tag_policy(**kwargs, &blk)
+          if blk
+            self._port_policy_blocks = [*(_port_policy_blocks || []), {
+              **kwargs,
+              block: blk,
+            }]
+          else
+            @_tag_policy ||= TagPolicy.new().tap do |pol|
+              (_port_policy_blocks || []).each do |p|
+                pol.evaluate(**p.except(:block), &p[:block])
+              end
+            end
+            @_tag_policy
+          end
+        end
+
+        def on_port_connected(...)
+          set_callback(:port_connected, :before, ...)
+        end
+
+        def on_port_disconnected(...)
+          set_callback(:port_disconnected, :after, ...)
+        end
+      end
+
+      included do
+        class_attribute :_port_policy_blocks, instance_writer: false, default: {}
+
+        periodically :check_port_inactivity, every: PORT_TIMEOUT
+
+        define_callbacks :port_connected, :port_disconnected
+
+        set_callback(:receive_message, :around) do |_, blk|
+          previous_mtok = @current_message_origin
+          begin
+            mtok = message['mtok']
+            @current_message_origin = mtok
+            blk.call
+          ensure
+            @current_message_origin = previous_mtok
+          end
+        end
+
+        authorize_inbound do |message|
+          msg_type = message['type'].to_s.underscore.to_sym
+          next true if %i[port_connected port_disconnected].include?(msg_type)
+          policy_allows?(msg_type)
+        end
+
+        inbound_tag_policy(priority: -10) do
+          allow :*, :connect
+        end
+      end
+
+      def initialize(...)
+        super
+        @port_data = {}
+      end
+
+      def _apply_port_scope(client_port: nil, tag: nil, **kwargs)
+        if client_port && tag
+          throw :abort unless port_data(client_port)[:tags]&.include?(tag)
+        end
+
+        { client_port: client_port || tag, **kwargs }
+      end
+
+      def reply(message = nil, **kwargs)
+        raise ArgumentError, "Can only use reply when handling a message" unless origin_port
+        raise ArgumentError, "Must provide message or block" unless message || block_given?
+        raise ArgumentError, "Cannot specify client_port: when using reply" if kwargs.key?(:client_port)
+
+        if block_given?
+          with_port_scope(client_port: origin_port) do
+            yield
+          end
+        else
+          broadcast(message, **kwargs, client_port: origin_port)
+        end
+      end
+
+      protected
+
+      def policy_allows?(method)
+        self.class.inbound_tag_policy.pass?(method, origin_tags)
+      end
+
+      def on_port_disconnected(); end
+
+      def on_port_connected(); end
+
+      def touch_port_activity(mtok = nil)
+        port_data(mtok)[:last_seen_at] = Time.now
+      end
+
+      def port_data(mtok = nil)
+        mtok ||= @current_message_origin
+        @port_data[mtok] ||= HashWithIndifferentAccess.new
+      end
+
+      def origin_port
+        @current_message_origin
+      end
+
+      def origin_tags
+        port_data[:tags] || []
+      end
+
+      def origin_tagged?(tag)
+        origin_tags.include?(tag)
+      end
+
+      def tag_origin!(*tags)
+        port_data[:tags] ||= Set.new
+        port_data[:tags].merge(tags.flatten.map(&:to_sym))
+      end
+
+      def handle_received_message(message)
+        case message['type']
+        when 'port_connected'
+          mdata = port_data
+          mdata[:last_seen_at] = Time.now
+          touch_port_activity
+
+          mdata.merge! ::ActiveJob::Arguments.deserialize(message['extra'])[0] if message['extra'].present?
+          tag_origin!(message['tags'])
+
+          if self.class.inbound_tag_policy.pass?(message['type'].to_sym, origin_tags)
+            run_callbacks :port_connected do
+              on_port_connected
+            end
+          else
+            @port_data.delete(origin_port)
+          end
+        when 'port_disconnected'
+          if self.class.inbound_tag_policy.pass?(message['type'].to_sym, origin_tags)
+            run_callbacks :port_disconnected do
+              on_port_disconnected
+            end
+          end
+          @port_data.delete(origin_port)
+        when 'port_ping'
+          touch_port_activity
+        else
+          super
+        end
+      end
+
+      def check_port_inactivity
+        return unless @port_data
+
+        threshold = PORT_TIMEOUT.ago
+        @port_data.each do |mtok, data|
+          next unless data[:last_seen_at] && data[:last_seen_at] < threshold
+
+          run_callbacks :port_disconnected do
+            on_port_disconnected
+          end
+          @port_data.delete(mtok)
+        end
+      end
+
+      class TagPolicy
+        ALIASES = {}
+
+        def self.define_tag_alias(key, implies)
+          Array(implies).each do |i|
+            ALIASES[i] ||= Set.new
+            ALIASES[i] << key
+          end
+        end
+
+        define_tag_alias :connect, [:port_connected, :port_ping, :port_disconnected]
+
+        def initialize()
+          @policy_rules = []
+          @fallback_rule = { action: :allow, priority: -100, tag: :*, methods: :* }
+          append_rule(@fallback_rule)
+        end
+
+        def pass?(method, user_tags)
+          user_tags = Set.new(Array(user_tags).map(&:to_sym))
+          find_rules_for(method).each do |r|
+            if r[:tag] == :* || user_tags.include?(r[:tag])
+              return r[:action] == :allow
+            end
+          end
+
+          false
+        end
+
+        def evaluate(priority: 10, &blk)
+          @fallback_rule[:action] = :deny if priority > 0
+
+          p = @rule_priority
+          @rule_priority = priority
+          instance_exec(&blk)
+        ensure
+          @rule_priority = p
+        end
+
+        protected
+
+        def allow(tag = :*, methods = :*)
+          append_rule({
+            action: :allow,
+            tag: tag,
+            methods: methods,
+          })
+        end
+
+        def deny(tag = :*, methods = :*)
+          append_rule({
+            action: :deny,
+            tag: tag,
+            methods: methods,
+          })
+        end
+
+        private
+
+        def append_rule(rule)
+          rule[:methods] = Set.new(Array(rule[:methods]).map(&:to_sym))
+          rule[:priority] ||= @rule_priority || 10
+          @policy_rules << rule
+        end
+
+        def find_rules_for(method)
+          rules ||= select_ruleset(@policy_rules, method).presence
+          rules ||= []
+
+          rules.sort_by! { |r| -r[:priority] }
+
+          rules
+        end
+
+        def select_ruleset(set, method)
+          all_aliases = Set.new
+          all_aliases << method
+
+          bfs(method) do |m|
+            all_aliases.merge(ALIASES[m] || [])
+            ALIASES[m]
+          end
+
+          all_aliases << :*
+
+          rules = set.select { |r| (Set.new(r[:methods]) & all_aliases).count > 0 }.sort_by { |r| -r[:priority] }
+
+          rules
+        end
+
+        def bfs(base, children = nil)
+          q = [base]
+          seen = Set.new
+          until q.empty?
+            n = q.shift
+            next if seen.include?(n)
+            seen << n
+
+            catch :end_branch do
+              value = catch :found do
+                result = yield n
+                next_set = children ? children.call(n) : Array(result)
+                (next_set || []).each do |c|
+                  q << c unless seen.include?(c)
+                end
+                throw :end_branch
+              end
+
+              return value || n
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/cable_room/room/port_scoping.rb

@@ -0,0 +1,40 @@
+module CableRoom
+  module Room
+    thread_mattr_accessor :current_port_scope
+
+    module PortScoping
+      extend ActiveSupport::Concern
+
+      def without_port_scope(&blk)
+        prev = Room.current_port_scope
+        Room.current_port_scope = nil
+        yield
+      ensure
+        Room.current_port_scope = prev
+      end
+
+      # Wrap the passed block with a specific messaging scope
+      def with_port_scope(**kwargs, &blk)
+        prev = Room.current_port_scope
+        Room.current_port_scope = prev ? prev.merge(kwargs) : kwargs
+        yield
+      ensure
+        Room.current_port_scope = prev
+      end
+
+      # Similar to with_port_scope, but won't call the block if no ports match
+      def with_port_scope!(**kwargs, &blk)
+        if kwargs.empty?
+          catch :abort do
+            remaining = _apply_port_scope(**Room.current_port_scope || {})
+            blk.call(**remaining)
+          end
+        else
+          with_port_scope(**kwargs) do
+            with_port_scope!(&blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cable_room/room/user_management.rb

@@ -3,65 +3,104 @@ module CableRoom
     module UserManagement
       extend ActiveSupport::Concern
 
-      def initialize(...)
-        @_user_state_map = {}
-        @_user_map_mutex = Monitor.new
-        super
+      class_methods do
+        def on_user_joined(...)
+          set_callback(:user_joined, :before, ...)
+        end
+
+        def on_user_left(...)
+          set_callback(:user_left, :after, ...)
+        end
       end
 
-      def on_user_left(user); end
+      included do
+        set_callback(:port_connected, :before, :_handle_user_setup_during_connection)
+        set_callback(:port_disconnected, :after, :_handle_user_cleanup_after_disconnection)
 
-      def on_member_left(mtok)
-        _user_state_transaction do |usm, u|
-          next unless usm.present?
-          usm[:member_tokens].delete(mtok)
-          if usm[:member_tokens].empty?
-            @_user_state_map.delete(u)
-            on_user_left(u)
-          end
+        define_callbacks :user_joined, :user_left
+
+        inbound_tag_policy(priority: -10) do
+          allow :*, :join
         end
 
+        PortManagement::TagPolicy.define_tag_alias :join, [:connect, :user_joined, :user_left]
+      end
+
+      def initialize(...)
+        @_user_state_map = {}
+        @_user_map_mutex = Monitor.new
         super
       end
 
-      def on_user_joined(user); end
+      def on_user_left; end
+
+      def on_user_joined; end
 
-      def on_member_joined(mtok)
+      protected
+
+      def _handle_user_setup_during_connection
         _user_state_transaction do |usm, u|
           if usm.nil?
             usm = @_user_state_map[u] = {
-              member_tokens: Set.new,
+              port_tokens: Set.new,
             }
             is_new = true
           end
-          usm[:member_tokens] << mtok
-          on_user_joined(u) if is_new
+          usm[:port_tokens] << origin_port
+          if is_new
+            run_callbacks :user_joined do
+              on_user_joined
+            end
+          end
         end
+      end
 
-        super
+      def _handle_user_cleanup_after_disconnection
+        _user_state_transaction do |usm, u|
+          next unless usm.present?
+          usm[:port_tokens].delete(origin_port)
+          if usm[:port_tokens].empty?
+            run_callbacks :user_left do
+              on_user_left
+            end
+            @_user_state_map.delete(u)
+          end
+        end
       end
 
       def connected_users
-        _user_state_map.keys
+        @_user_state_map.keys
       end
 
-      def transmit_to_user(msg, user: nil)
-        raise "No user specified" if user.nil? && current_user.nil?
-        user ||= current_user
+      def origin_user
+        port_data[:as]
+      end
 
-        _user_state_map[user][:member_tokens].each do |mtok|
-          ports[mtok] << msg
+      def all_user_tags(user = nil)
+        user ||= origin_user
+        raw_ports = @_user_state_map[user]&.[](:port_tokens) || []
+        tags = Set.new
+        raw_ports.each do |ptok|
+          tags.merge(port_data(ptok)&.[](:tags) || [])
         end
+        tags
       end
 
-      def current_user
-        member_data[:as]
+      def _apply_port_scope(user: nil, tag: nil, **kwargs)
+        if user && tag
+          user_tags = all_user_tags(user) || []
+          throw :abort unless user_tags.include?(tag)
+        end
+
+        super(tag: user || tag, **kwargs)
       end
 
       private
 
-      def _user_state_transaction(user = current_user)
+      def _user_state_transaction(user = origin_user)
         return unless user.present?
+        return unless policy_allows?(:join)
+
         @_user_map_mutex.synchronize do
           usm = @_user_state_map[user]
           yield usm, user

data/lib/cable_room/room.rb

@@ -5,16 +5,18 @@ module CableRoom
     eager_autoload do
       autoload :Base
 
-      # autoload :Ports
       autoload :Callbacks
       autoload :Threading
       autoload :ChannelAdapter
-      autoload :InputHandling
+
       autoload :Lifecycle
       autoload :Reaping
+      autoload :InputHandling
 
-      autoload :MemberManagement
+      autoload :PortScoping
+      autoload :PortManagement
       autoload :UserManagement
+      autoload :Broadcasting
     end
   end
 end