cable_room 0.6.2 → 0.7.0.beta1

data/lib/cable_room/channel_tracker.rb

@@ -1,130 +0,0 @@
-module CableRoom
-  class ChannelTracker
-    def self.instance
-      @instance ||= new
-    end
-
-    BEAT_INTERVAL = 5.seconds
-
-    delegate :logger, :pubsub, :event_loop, :config, to: :cable_server
-
-    attr_reader :room_channels, :scheduler
-
-    def initialize
-      @room_channels = Set.new
-      @monitor = Monitor.new
-
-      @scheduler = Rufus::Scheduler.new
-
-      at_exit do
-        logger.info "Shutting down CableRoom"
-        shutdown!
-      end
-
-      scheduler.every(BEAT_INTERVAL) do
-        each_room_channel do |chan|
-          chan.beat
-        end
-      end
-    end
-
-    def worker_pool
-      # TODO Pin Rooms to a specific thread so that they never have to worry about thread safety?
-      @worker_pool || @monitor.synchronize { @worker_pool ||= ThreadPool.new(max_size: config.worker_pool_size) }
-    end
-
-    def track_room_channel(chan)
-      raise "Cannot add Room after shutdown" if @shutdown
-      @room_channels << chan
-    end
-
-    def untrack_room_channel(chan)
-      @room_channels.delete(chan)
-    end
-
-    def shutdown?
-      @shutdown
-    end
-
-    def shutdown!
-      @monitor.synchronize do
-        @shutdown = true
-
-        scheduler.shutdown
-
-        shutdown_rooms!
-
-        worker_pool.executor.shutdown
-        worker_pool.executor.wait_for_termination(5)
-        worker_pool.executor.kill
-      end
-    end
-
-    def shutdown_rooms!
-      @monitor.synchronize do
-        each_room_channel do |chan|
-          chan.initiate_shutdown("Server shutting down")
-        end
-      end
-
-      count = 0
-      loop do
-        break if @room_channels.empty? || count >= 15
-        sleep 1
-        count += 1
-      end
-    end
-
-    def each_room_channel(&blk)
-      @room_channels.dup.each(&blk)
-    end
-
-    private
-
-    def cable_server
-      ActionCable.server
-    end
-
-    class ThreadPool < ActionCable::Server::Worker
-      set_callback :work, :around do |_, blk|
-        pconn = ActionCable::Server::Worker.connection
-        ActionCable::Server::Worker.connection = connection
-        blk.call
-      ensure
-        ActionCable::Server::Worker.connection = pconn
-      end
-
-      # ActionCable's Worker#invoke reduces every exception to a log line and a no-argument
-      # `handle_exception` call, which discards the error itself. Rooms run all of their work
-      # through here, so report it properly instead.
-      def invoke(receiver, method, *args, connection:, &block)
-        work(connection) do
-          receiver.send method, *args, &block
-        rescue Exception => e
-          if connection.respond_to?(:report_work_error)
-            connection.report_work_error(e)
-          else
-            logger.error "There was an exception - #{e.class}(#{e.message})"
-            logger.error Array(e.backtrace).join("\n")
-            CableRoom.report_error(e, connection: connection)
-          end
-        end
-      end
-
-      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.
-
-        # TODO Implement more of a round-robin approach so that no room can starve out others?
-
-        # "connection" here really references the Channel, since "Connections" in this context don't really exist
-
-        connection._post_wrapped_work(async: false) do
-          invoke(receiver, method, *args, connection: connection, &block)
-        end
-      end
-    end
-
-  end
-end

data/lib/cable_room/room/channel_adapter.rb

@@ -1,18 +0,0 @@
-module CableRoom
-  module Room
-    module ChannelAdapter
-      extend ActiveSupport::Concern
-
-      Channel = CableRoom::ChannelBase
-
-      class_methods do
-        def inherited(subclass)
-          # Descend from *this* class's Channel, so periodic timers and other channel-level
-          # configuration survive multiple levels of subclassing
-          subclass.const_set(:Channel, Class.new(self::Channel))
-          super
-        end
-      end
-    end
-  end
-end