cable_room 0.1.0

data/lib/cable_room/room/member_management.rb

@@ -0,0 +1,67 @@
+module CableRoom
+  module Room
+    module MemberManagement
+      extend ActiveSupport::Concern
+
+      MEMBER_TIMEOUT = 30.seconds
+
+      included do
+        periodically :check_member_inactivity, every: MEMBER_TIMEOUT
+      end
+
+      protected
+
+      def on_member_left(mtok); end
+
+      def on_member_joined(mtok); end
+
+      def touch_member_activity(mtok)
+        member_data(mtok)[:last_seen_at] = Time.now
+      end
+
+      def member_data(mtok = @current_message_member_token)
+        @member_data ||= {}
+        @member_data[mtok] ||= HashWithIndifferentAccess.new
+      end
+
+      def handle_received_message(message)
+        mtok = message['mtok']
+
+        previous_mtok = @current_message_member_token
+        @current_message_member_token = mtok
+
+        case message['type']
+        when 'member_joined'
+          mdata = member_data(mtok)
+          mdata[:last_seen_at] = Time.now
+          touch_member_activity(mtok)
+
+          mdata.merge! ::ActiveJob::Arguments.deserialize(message['extra'])[0] if message['extra'].present?
+
+          on_member_joined(mtok)
+        when 'member_left'
+          on_member_left(mtok)
+          @member_data.delete(mtok)
+        when 'member_ping'
+          touch_member_activity(mtok)
+        else
+          super
+        end
+      ensure
+        @current_message_member_token = previous_mtok
+      end
+
+      def check_member_inactivity
+        return unless @member_data
+
+        threshold = MEMBER_TIMEOUT.ago
+        @member_data.each do |mtok, data|
+          next unless data[:last_seen_at] && data[:last_seen_at] < threshold
+
+          on_member_left(mtok)
+          @member_data.delete(mtok)
+        end
+      end
+    end
+  end
+end

data/lib/cable_room/room/reaping.rb

@@ -0,0 +1,84 @@
+module CableRoom
+  module Room
+    module Reaping
+      extend ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+
+      included do
+        # { key: nil, interval: 10.seconds, block: ->{} }
+        class_attribute :reaper_checkers, instance_writer: false, instance_predicate: false, default: []
+
+        after_startup do
+          cfgs = self.class.reaper_checkers
+
+          states = _reaper_states
+          cfgs.each do |cfg|
+            state = states[cfg] ||= {}
+            state[:timer] = start_periodic_timer(->{
+              if instance_exec(&cfg[:block])
+                shutdown!
+              else
+                ping_watchdog
+              end
+            }, every: cfg[:interval])
+          end
+        end
+
+        before_shutdown do
+          _reaper_states.each do |_, state|
+            state[:timer]&.shutdown
+          end
+        end
+      end
+
+      class_methods do
+        def reap_when(grace: 30.seconds, interval: 10.seconds, key: nil, &blk)
+          cfg = { interval: interval, key: key }
+
+          cfg[:block] = -> {
+            state = _reaper_states[cfg]
+            result = instance_exec(&blk)
+
+            next true if result == :reap
+
+            if result
+              next true unless grace && grace > 0
+              state[:last_keep_at] ||= Time.current
+              next true if (Time.current - state[:last_keep_at]) > grace
+            else
+              state[:last_keep_at] = Time.current
+            end
+
+            false
+          }
+
+          reaper_checkers << cfg
+        end
+      end
+
+      protected
+
+      def ping_watchdog
+        @cable_channel.ping_watchdog
+      end
+
+      def check_reapers_now!
+        reaper_config = self.class.reaper_checkers
+        return if reaper_config.empty?
+
+        if reaper_config.any? { |cfg| instance_exec(&cfg[:block]) }
+          shutdown!
+          return
+        end
+
+        ping_watchdog
+      end
+
+      private
+
+      def _reaper_states
+        @_reaper_states ||= {}
+      end
+    end
+  end
+end

data/lib/cable_room/room/threading.rb

@@ -0,0 +1,13 @@
+module CableRoom
+  module Room
+    module Threading
+      extend ActiveSupport::Concern
+
+      # Run the given block in the background, so as not to block other operations w/i the Room
+      # (By default, rooms are single-threaded, so any work will block all other work from occurring.)
+      def async(&blk)
+        @cable_channel.post_work(thread_safe: true, &blk)
+      end
+    end
+  end
+end

data/lib/cable_room/room/user_management.rb

@@ -0,0 +1,72 @@
+module CableRoom
+  module Room
+    module UserManagement
+      extend ActiveSupport::Concern
+
+      def initialize(...)
+        @_user_state_map = {}
+        @_user_map_mutex = Monitor.new
+        super
+      end
+
+      def on_user_left(user); end
+
+      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
+
+        super
+      end
+
+      def on_user_joined(user); end
+
+      def on_member_joined(mtok)
+        _user_state_transaction do |usm, u|
+          if usm.nil?
+            usm = @_user_state_map[u] = {
+              member_tokens: Set.new,
+            }
+            is_new = true
+          end
+          usm[:member_tokens] << mtok
+          on_user_joined(u) if is_new
+        end
+
+        super
+      end
+
+      def connected_users
+        _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
+
+        _user_state_map[user][:member_tokens].each do |mtok|
+          ports[mtok] << msg
+        end
+      end
+
+      def current_user
+        member_data[:as]
+      end
+
+      private
+
+      def _user_state_transaction(user = current_user)
+        return unless user.present?
+        @_user_map_mutex.synchronize do
+          usm = @_user_state_map[user]
+          yield usm, user
+        end
+      end
+    end
+  end
+end

data/lib/cable_room/room.rb

@@ -0,0 +1,20 @@
+module CableRoom
+  module Room
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Base
+
+      # autoload :Ports
+      autoload :Callbacks
+      autoload :Threading
+      autoload :ChannelAdapter
+      autoload :InputHandling
+      autoload :Lifecycle
+      autoload :Reaping
+
+      autoload :MemberManagement
+      autoload :UserManagement
+    end
+  end
+end

data/lib/cable_room/room_member.rb

@@ -0,0 +1,170 @@
+module CableRoom
+  module RoomMember
+    extend ActiveSupport::Concern
+
+    included do
+      periodically :ping_room_memberships, every: 10.seconds
+
+      after_unsubscribe do
+        to_close = _room_memberships.to_a
+        _room_memberships.clear
+        to_close.each(&:leave!)
+      end
+    end
+
+    def _room_memberships
+      @_room_memberships ||= Set.new
+    end
+
+    protected
+
+    def join_room(room_class, room_key = nil, as: :not_given, forward: false, **kwargs, &blk)
+      if forward
+        # raise ArgumentError, "Cannot specify both `forward: true` and `on_message:`" if kwargs[:on_message]
+        original_on_message = kwargs[:on_message]
+        kwargs[:on_message] = ->(msg) {
+          original_on_message&.call(msg)
+          transmit(msg)
+        }
+      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
+        kwargs[:extra] ||= {}
+        kwargs[:extra][:as] = as
+      end
+
+      RoomMembership.new(self, room_class, room_key, **kwargs)
+    end
+
+    def ping_room_memberships
+      _room_memberships.each(&:ping!)
+    end
+  end
+
+  class RoomMembership
+    include Ports
+
+    attr_reader :room_class
+
+    def initialize(
+      cable_channel,
+      room_class,
+      room_key,
+      create: false,
+      on_closed: nil,
+      on_opened: nil,
+      on_message: nil,
+      extra: nil
+    )
+      @token = SecureRandom.hex(16)
+      @has_left = false
+
+      @cable_channel = cable_channel
+      @room_class = room_class
+      @room_key = room_key
+      @allow_create = create
+
+      @on_opened = on_opened
+      @on_closed = on_closed
+      @on_message = on_message
+
+      @extra = extra
+
+      @cable_channel._room_memberships << self
+
+      # Listen to public/broadcast channel
+      stream_port(room_class::ROOM_OUT_CHANNEL) do |message|
+        handle_received_message(message)
+      end
+
+      # Listen to private channel
+      stream_port(@token) do |message|
+        handle_received_message(message)
+      end
+
+      transmit_member_joined
+
+      maybe_provision_room
+    end
+
+    delegate :logger, to: :@cable_channel
+
+    def <<(data)
+      port_transmit(room_class::ROOM_IN_CHANNEL, data)
+    end
+
+    def left?
+      @has_left
+    end
+
+    def ping!
+      return if left?
+
+      self << { type: 'member_ping' }
+      maybe_provision_room
+    end
+
+    def leave!
+      return if left?
+
+      close_streamed_ports!
+      @cable_channel._room_memberships.delete(self)
+      self << { type: 'member_left' }
+      @has_left = true
+      @on_closed&.call(self)
+    end
+
+    def key; @room_key; end
+
+    protected
+
+    def port_transmit(port, data)
+      data[:mtok] = @token
+      super
+    end
+
+    def room_port_key(port)
+      room_class.room_port_key(@room_key, port)
+    end
+
+    def handle_received_message(message)
+      return leave! if message == "KILL"
+
+      case message['type']
+      when 'room_opened'
+        transmit_member_joined
+        @on_opened&.call(self)
+      when 'room_closed'
+        @on_closed&.call(self)
+        maybe_provision_room
+      else
+        logger.warn "Unknown room message type: #{message['type'].inspect}" unless @on_message
+      end
+
+      @on_message&.call(message)
+    end
+
+    private
+
+    def transmit_member_joined
+      msg = { type: 'member_joined' }
+      msg[:extra] = ::ActiveJob::Arguments.serialize([@extra]) if @extra
+      self << msg
+    end
+
+    def maybe_provision_room
+      return if left?
+      return unless @allow_create
+      return if ChannelTracker.instance.shutdown?
+
+      @room_class.ensure(@room_key)
+    end
+  end
+end

data/lib/cable_room/version.rb

@@ -0,0 +1,3 @@
+module CableRoom
+  VERSION = "0.1.0".freeze
+end

data/lib/cable_room.rb

@@ -0,0 +1,36 @@
+
+require 'active_support/concern'
+require 'active_support/time'
+require 'active_support/core_ext/module'
+
+require 'action_cable'
+require 'redlock'
+require 'rufus-scheduler'
+
+require_relative 'cable_room/railtie'
+
+require_relative 'cable_room/channel_base'
+require_relative 'cable_room/channel_tracker'
+require_relative 'cable_room/ports'
+require_relative 'cable_room/room_member'
+require_relative 'cable_room/room/'
+require_relative 'cable_room/version'
+
+module CableRoom
+  class << self
+    def redis_pool
+      require 'rediconn'
+      @redis_pool ||= RediConn::RedisConnection.create(env_prefix: "CABLEROOM")
+    end
+
+    def redis(&blk)
+      redis_pool.lazy_with(&blk)
+    end
+
+    def lock_manager
+      @lock_manager ||= Redlock::Client.new([
+        CableRoom.redis,
+      ])
+    end
+  end
+end

data/spec/cable_room/room_member_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+
+RSpec.describe CableRoom::RoomMember do
+  RUN_KEY = SecureRandom.hex(8)
+
+  class TestRoom < CableRoom::Room::Base
+    cattr_accessor :latest_instance
+
+    after_startup do
+      self.class.latest_instance = self
+      self << { type: "custom_started" }
+    end
+
+    before_shutdown do
+
+    end
+  end
+
+  class TestChannel < ApplicationCable::Channel
+    include CableRoom::RoomMember
+
+    attr_reader :room
+
+    def subscribed
+      key = RUN_KEY + (params[:key] || SecureRandom.hex(8))
+      @room = join_room(TestRoom, key, create: params[:create])
+    end
+
+    def unsubscribed
+      @room.leave!
+    end
+  end
+
+  describe TestChannel, type: :channel do
+    before do
+      stub_connection current_user: nil
+    end
+
+    it "provisions a room if it doesn't exist" do
+      expect {
+        subscribe create: true
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(1)
+      unsubscribe
+    end
+
+    it "opens the expected streams" do
+      key = 'ABC'
+      subscribe key:, create: true
+      expect(subscription).to be_confirmed
+      expect(subscription).to have_stream_from(/TestRoom:\w+ABC:from_room/)
+      expect(subscription).to have_stream_from(/TestRoom:\w+ABC:\w+/)
+      unsubscribe
+    end
+
+    it "does not provision a room if `create: false`" do
+      expect {
+        subscribe create: false
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
+    end
+
+    it "does not provision a duplicate room" do
+      key = SecureRandom.hex(8)
+      expect {
+        subscribe key: key, create: true
+        subscribe key: key, create: true
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(1)
+      unsubscribe
+    end
+
+    it "can provision multiple rooms" do
+      expect {
+        subscribe key: 'A', create: true
+        subscribe key: 'B', create: true
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(2)
+      unsubscribe
+    end
+
+    it "does not shutdown immediately on unsubscribe" do
+      subscribe create: true
+      expect {
+        unsubscribe
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
+    end
+
+    it "shuts down when the room receives a KILL message" do
+      subscribe create: true
+      expect {
+        room = subscription.room
+        TestRoom.send_message(room.key, "KILL", port: :to_room)
+        sleep 0.1
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(-1)
+    end
+
+    it "shuts down when the room is idle" do
+      subscribe create: true
+      unsubscribe
+
+      room = TestRoom.latest_instance
+      vchan = room.instance_variable_get(:@cable_channel)
+      expect {
+        room.send(:ping_watchdog)
+        vchan.send(:check_room_watchdog)
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
+
+      vchan.instance_variable_set(:@last_watchdog_ping_at, 1.hour.ago)
+
+      expect {
+        vchan.send(:check_room_watchdog)
+        sleep 0.1
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(-1)
+    end
+  end
+end

data/spec/internal/config/cable.yml

@@ -0,0 +1,2 @@
+test:
+  adapter: test

data/spec/internal/config/database.yml

@@ -0,0 +1,5 @@
+test:
+  database: cable-room-test
+  adapter: postgresql
+  encoding: unicode
+  pool: 15

data/spec/internal/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  # Add your own routes here, or remove this file if you don't have need for it.
+end

data/spec/internal/config/storage.yml

@@ -0,0 +1,3 @@
+test:
+  service: Disk
+  root: /Users/eknapp/code/CableRoom/tmp/storage

data/spec/internal/db/schema.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  # Set up any tables you need to exist for your test suite that don't belong
+  # in migrations.
+end