cable_room 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 841a40a6a2460c6be5811f2fe24e6fffc1bb7291446029bf1e62497df24ee507
-  data.tar.gz: fff54424d08af52f0a35d23089f7437054b6d2e9a63ae66d620d7678edeadfdf
+  metadata.gz: 020faa2e6a7e8cd1027b4d5c7303d57ef1282ab4f298800df26d6336587082dc
+  data.tar.gz: fae6de782ad1a15d7e065fbef53e71665ebb4606ecd75748fa7e574bd63ae393
 SHA512:
-  metadata.gz: d44fa0d6f66a5905e20ad96b3df974d9d44e43e9c057a8de6316def16f3d577c8f3270254c27cc5c0e1fc4a3fab0be2307566f55b77ada20a53c04f946c1834b
-  data.tar.gz: ac558498e04bf2d82a9048a7ff1cab21324cc14c36fbcf9073311c3d7bc62cd1094e7df2a17b129cdd5e6bdb06e4befbec49bb6e57f310e4323aab4b2217d4e7
+  metadata.gz: 24de44e3b78d19d72af29783069bf8ddd6ed87d03bb185c4e2fae9b79e159f6c2da7701f2a575cf54cb2a6baaf0a66ea4e4d65c7e84048694f33c8d6c19e2dd4
+  data.tar.gz: 178caf0566a1420f7cb705d9076ae39a5cd664cd42da23619f9312f1feccc34b8afb55563aeb5acf8af700fe4046b6cad5f901b34c6d9bf2947d8c2f6ff08529

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,136 @@
+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 on_port_connected(...)
+          set_callback(:port_connected, :before, ...)
+        end
+
+        def on_port_disconnected(...)
+          set_callback(:port_disconnected, :after, ...)
+        end
+      end
+
+      included do
+        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
+      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 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 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?
+          mdata[:tags] = Array(message['tags']).map(&:to_sym) if message['tags'].present?
+
+          run_callbacks :port_connected do
+            on_port_connected
+          end
+        when 'port_disconnected'
+          run_callbacks :port_disconnected do
+            on_port_disconnected
+          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
+    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,64 +3,95 @@ 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
-        end
+        define_callbacks :user_joined, :user_left
+      end
 
+      def initialize(...)
+        @_user_state_map = {}c
+        @_user_map_mutex = Monitor.new
         super
       end
 
-      def on_user_joined(user); end
+      def on_user_left; end
 
-      def on_member_joined(mtok)
+      def on_user_joined; end
+
+      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?
         @_user_map_mutex.synchronize do
           usm = @_user_state_map[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

data/lib/cable_room/room_member.rb

@@ -28,11 +28,6 @@ module CableRoom
         }
       end
 
-      if blk
-        raise ArgumentError, "Cannot specify both a block and `on_opened:`" if kwargs[:on_opened]
-        kwargs[:on_opened] = blk
-      end
-
       as = respond_to?(:current_user) ? current_user : nil if as == :not_given
 
       if as
@@ -40,7 +35,7 @@ module CableRoom
         kwargs[:extra][:as] = as
       end
 
-      RoomMembership.new(self, room_class, room_key, **kwargs)
+      RoomMembership.new(self, room_class, room_key, **kwargs, &blk)
     end
 
     def ping_room_memberships
@@ -61,7 +56,9 @@ module CableRoom
       on_closed: nil,
       on_opened: nil,
       on_message: nil,
-      extra: nil
+      tags: [],
+      extra: nil,
+      &preconfigure
     )
       @token = SecureRandom.hex(16)
       @has_left = false
@@ -75,6 +72,7 @@ module CableRoom
       @on_closed = on_closed
       @on_message = on_message
 
+      @tags = Array(tags).map(&:to_sym)
       @extra = extra
 
       @cable_channel._room_memberships << self
@@ -89,7 +87,22 @@ module CableRoom
         handle_received_message(message)
       end
 
-      transmit_member_joined
+      # Listen to user-specific channel
+      if extra && extra[:as]
+        stream_port(extra[:as]) do |message|
+          handle_received_message(message)
+        end
+      end
+
+      @tags.each do |tag|
+        stream_port(tag) do |message|
+          handle_received_message(message)
+        end
+      end
+
+      preconfigure&.call(self)
+
+      transmit_port_connected
 
       maybe_provision_room
     end
@@ -107,7 +120,7 @@ module CableRoom
     def ping!
       return if left?
 
-      self << { type: 'member_ping' }
+      self << { type: 'port_ping' }
       maybe_provision_room
     end
 
@@ -116,7 +129,7 @@ module CableRoom
 
       close_streamed_ports!
       @cable_channel._room_memberships.delete(self)
-      self << { type: 'member_left' }
+      self << { type: 'port_disconnected' }
       @has_left = true
       @on_closed&.call(self)
     end
@@ -139,7 +152,7 @@ module CableRoom
 
       case message['type']
       when 'room_opened'
-        transmit_member_joined
+        transmit_port_connected
         @on_opened&.call(self)
       when 'room_closed'
         @on_closed&.call(self)
@@ -153,8 +166,11 @@ module CableRoom
 
     private
 
-    def transmit_member_joined
-      msg = { type: 'member_joined' }
+    def transmit_port_connected
+      msg = {
+        type: 'port_connected',
+        tags: @tags,
+      }
       msg[:extra] = ::ActiveJob::Arguments.serialize([@extra]) if @extra
       self << msg
     end

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.1.2".freeze
+  VERSION = "0.2.0".freeze
 end