cable_room 0.7.0.beta3 → 0.8.0.beta1

data/lib/cable_room/room_member.rb

@@ -1,8 +1,4 @@
 module CableRoom
-  # Raised at subscribe time when `join_room` asks for something AnyCable can't deliver
-  # (see RoomMember#refuse_unsupported_under_anycable!).
-  class AnyCableUnsupported < ArgumentError; end
-
   module RoomMember
     extend ActiveSupport::Concern
 
@@ -13,19 +9,17 @@ module CableRoom
     # ~30% of all room messages at 10 s with no skipping.
     PING_INTERVAL = 15.seconds
 
+    # A dropped announcement is invisible to the port. The room's inbound subscription is
+    # registered asynchronously — and the room may live in another process entirely — so a
+    # port_connected sent before the room is listening is discarded with no error. Re-announce on
+    # a doubling backoff from here until the room acknowledges, rather than waiting out a whole
+    # PING_INTERVAL. port_connected is idempotent on the room side (the port is merged,
+    # user_joined fires only once), so a redundant re-announcement costs one message.
+    REANNOUNCE_INITIAL_DELAY = 0.1.seconds
+
     included do
       periodically :ping_room_memberships, every: PING_INTERVAL
 
-      # Where MembershipStore::AnyCable keeps the memberships between anycable-rails' per-call
-      # channel instances. `state_attr_accessor` only exists once anycable-rails is loaded; without
-      # it the channel lives for the socket and the in-memory store is all there is. Private
-      # because every public method of a channel is an action a client can perform, and a client
-      # that could write this could claim another member's token.
-      if respond_to?(:state_attr_accessor)
-        state_attr_accessor MembershipStore::AnyCable::STATE_ATTRIBUTE
-        private MembershipStore::AnyCable::STATE_ATTRIBUTE, :"#{MembershipStore::AnyCable::STATE_ATTRIBUTE}="
-      end
-
       after_unsubscribe do
         to_close = _room_memberships.to_a
         _room_memberships.clear
@@ -33,51 +27,13 @@ module CableRoom
       end
     end
 
-    # The channel's memberships (a MembershipStore). RoomMembership registers itself here, so this
-    # has to stay public; treat it as internal and read `room_memberships` instead.
     def _room_memberships
-      @_room_memberships ||= MembershipStore.for(self)
-    end
-
-    # True when anycable-rails is handling this channel: the connection carries an AnyCable socket,
-    # this instance exists for one RPC call only, its streams are held by anycable-go, and its
-    # timers never run. `anycabled?` is what anycable-rails itself checks; it only exists once the
-    # gem is loaded. (Public methods are actions; performing this one is harmless.)
-    def anycable_channel?
-      connection.respond_to?(:anycabled?) && !!connection.anycabled?
-    end
-
-    # The `hello` channel action. The browser performs it once ActionCable has confirmed the
-    # subscription (`connected()` in the JS client), which is the first moment every stream this
-    # channel opened is guaranteed live. Each membership announces itself to its room in response;
-    # nothing is announced before then. A channel with no memberships ignores it.
-    #
-    # Public methods on a channel are its actions, so every RoomMember channel accepts
-    # `perform("hello")` without further wiring.
-    def hello(_data = nil)
-      hello_room_memberships
-    end
-
-    # The `ping` channel action. Under ActionCable the channel's own timer pings, so a client that
-    # performs this is doing harmless extra work. Under AnyCable channel timers never run (there is
-    # no long-lived channel object to run them on), so the browser performs this every
-    # PING_INTERVAL and each membership turns it into port_ping. See README "Using AnyCable".
-    def ping(_data = nil)
-      ping_room_memberships
+      @_room_memberships ||= Set.new
     end
 
     protected
 
-    # The memberships `join_room` created on this channel. Under AnyCable the instance variable
-    # `subscribed` assigned is gone by the next call; this still has them, rebuilt from the
-    # channel state.
-    def room_memberships
-      _room_memberships
-    end
-
     def join_room(room_class, room_key = nil, as: :not_given, forward: false, **kwargs, &blk)
-      refuse_unsupported_under_anycable!(forward: forward, callbacks: kwargs, block: blk)
-
       if forward
         # raise ArgumentError, "Cannot specify both `forward: true` and `on_message:`" if kwargs[:on_message]
         original_on_message = kwargs[:on_message]
@@ -101,33 +57,13 @@ module CableRoom
       _room_memberships.each(&:ping!)
     end
 
-    # Under AnyCable, room→member broadcasts go anycable-go → socket and never pass through this
-    # process, and the channel object is rebuilt per call, so nothing here can run a proc when a
-    # message arrives. That rules out `forward: false` (nothing would deliver messages to the app),
-    # every `on_*:` callback, and a preconfigure block (custom stream handlers). Failing at
-    # subscribe time beats a join that silently never fires anything. RoomProxyChannel's own
-    # `forward` wrapper is added after this check, so it is exempt. Plain ActionCable: no-op.
-    UNSUPPORTED_UNDER_ANYCABLE_CALLBACKS = %i[on_joined on_message on_room_opened on_room_closed on_left].freeze
-
-    def refuse_unsupported_under_anycable!(forward:, callbacks:, block:)
-      return unless anycable_channel?
-
-      unsupported = []
-      unsupported << "forward: false" unless forward
-      unsupported.concat(UNSUPPORTED_UNDER_ANYCABLE_CALLBACKS.select { |cb| callbacks[cb] }.map { |cb| "#{cb}:" })
-      unsupported << "a preconfigure block" if block
-      return if unsupported.empty?
-
-      raise AnyCableUnsupported,
-        "join_room used #{unsupported.join(', ')} on an AnyCable-backed channel (#{self.class.name}). " \
-        "Under AnyCable room messages never pass through this process, so these can't work; " \
-        "use forward: true without callbacks (see README, \"Using AnyCable\")."
-    end
-
-    # Server-side entry point for the hello signal, for channels that learn the client is ready
-    # some other way than the `hello` action (a custom handshake message, for instance).
-    def hello_room_memberships
-      _room_memberships.each(&:hello!)
+    def transmit_subscription_confirmation(...)
+      super
+      memberships = _room_memberships.to_a
+      memberships.each(&:streams_live!)
+      connection.worker_pool.async_exec(self, connection: connection) do
+        memberships.each(&:transmit_port_connected)
+      end
     end
   end
 
@@ -148,28 +84,21 @@ module CableRoom
       on_left: nil,
       tags: [],
       extra: nil,
-      tenant: nil,
       &preconfigure
     )
       @mutex = Monitor.new
 
       @has_left = false
       @has_established = false
-      @hello_received = false
+      @streams_live = false
+      @reannounce_delay = nil
+      @reannounce_job = nil
 
       @cable_channel = cable_channel
       @room_class = room_class
       @room_key = room_key
       @allow_create = create
 
-      # Defaults to the ambient tenant right here, at join_room's own call site -- the member's
-      # own request thread, the last point before this room's work moves to a Host thread with no
-      # request of its own to derive one from (see Runner#initialize). An app only needs to pass
-      # `tenant:` explicitly to ask for something other than "whatever tenant this join is
-      # happening under", which is the common case. nil isn't a real tenant either way, so it
-      # doubles as "not given".
-      @tenant = tenant || (Apartment::Tenant.current if defined?(Apartment))
-
       @on_room_opened = on_room_opened
       @on_joined = on_joined
       @on_message = on_message
@@ -197,95 +126,11 @@ module CableRoom
       @mutex.synchronize { @has_left }
     end
 
-    def hello_received?
-      @hello_received
-    end
-
-    # Whether room→member traffic reaches this object. Under ActionCable the streams opened in
-    # initiate_connection dispatch into handle_received_message. Under AnyCable anycable-go holds
-    # the streams and delivers them straight to the socket, so this process never sees a room
-    # message: acknowledgements, room_opened, and room_closed are invisible here, and none of the
-    # on_* callbacks can fire.
-    def hears_room?
-      !@cable_channel.anycable_channel?
-    end
-
-    # Whether the room has acknowledged this port, as far as this process can tell. Under
-    # ActionCable that is the acknowledgement itself. Under AnyCable the acknowledgement went to
-    # the socket, so the most this process knows is that hello went out; the browser, which does
-    # see port_acknowledged, owns the retry (README "Using AnyCable").
-    def presumed_established?
-      hears_room? ? @has_established : @hello_received
-    end
-
-    # Whether client input can be handed to the room. Under ActionCable input waits for the
-    # acknowledgement, because until then the room has no port to attribute it to. Under AnyCable
-    # it goes as soon as hello has: hello's port_connected and the input travel the same Bus
-    # channel from the same process, so the room sees them in that order, and a room that doesn't
-    # exist yet drops both the way ActionCable would have dropped the input.
-    def accepts_input?
-      !left? && presumed_established?
-    end
-
-    # What MembershipStore::AnyCable writes into the channel state: enough to rebuild this
-    # membership on a later RPC call (see .restore). Callbacks are procs and can't go; `extra`
-    # travels in the ActiveJob-serialized form the room deserializes, which needs no lookup here.
-    def persisted_identity
-      {
-        "token" => @token,
-        "room_class" => room_class.name,
-        "room_key" => @room_key,
-        "tags" => @tags,
-        "extra" => serialized_extra,
-        "create" => @allow_create,
-        "hello_received" => @hello_received,
-        "tenant" => @tenant,
-      }
-    end
-
-    # The inverse of #persisted_identity, for a channel instance anycable-rails built for one RPC
-    # call. The result can hello!, ping!, leave!, and forward input with the token the subscribe
-    # call created. It does not open streams (anycable-go still holds the ones subscribe opened)
-    # and does not announce itself (only hello! does); it carries no callbacks.
-    def self.restore(cable_channel, record)
-      membership = allocate
-      membership.send(:restore_from, cable_channel, record)
-      membership
-    end
-
-    # The client has said hello: its subscription is confirmed, so every stream this membership
-    # opened is live and the room's acknowledgement has somewhere to land. This is the only thing
-    # that lets port_connected go out — a membership that never hears hello never announces.
-    #
-    # Hello is remembered for the life of the membership, across rejoin!: the browser says it
-    # once per subscription, and a rejoin happens server-side without the browser knowing.
-    def hello!
-      return if left?
-
-      ActiveSupport::Notifications.instrument(
-        "hello_received.cable_room",
-        { membership: self, room_class: room_class, room_key: @room_key, channel: @cable_channel }
-      ) do
-        @hello_received = true
-        # Under AnyCable the next call starts from a fresh channel; it has to know hello happened.
-        @cable_channel._room_memberships.persist!
-        # A repeated hello re-announces, which is harmless: port_connected is idempotent room-side.
-        transmit_port_connected
-      end
-    end
-
     def ping!
       return if left?
-      if presumed_established?
-        # The room already heard from us if we sent anything since the last interval; the next
-        # ping lands within 2 x PING_INTERVAL of that, well inside PORT_TIMEOUT.
+      if @has_established
         port_transmit(room_class::ROOM_IN_CHANNEL, { type: 'port_ping' }, secure_context: true) unless recently_transmitted?
-      elsif @hello_received
-        # Announced but never acknowledged: the announcement or the acknowledgement was lost in
-        # transit, or the room did not exist yet. An unestablished membership silently drops
-        # everything the client sends (see RoomProxyChannel#receive), so re-announce instead of
-        # pinging: port_connected is idempotent on the room side (the port is merged, user_joined
-        # fires only once). Before hello there is nothing to heal — the client isn't ready.
+      else
         transmit_port_connected
       end
       @mutex.synchronize do
@@ -297,6 +142,7 @@ module CableRoom
       @mutex.synchronize do
         return if left?
 
+        stop_reannouncing
         close_streamed_ports!
         @cable_channel._room_memberships.delete(self)
         port_transmit(room_class::ROOM_IN_CHANNEL, { type: 'port_disconnected' }, secure_context: true)
@@ -316,11 +162,24 @@ module CableRoom
 
     def key; @room_key; end
 
-    # -- The member side of Ports ---------------------------------------------------------------
+    # @internal
+    def streams_live!
+      @streams_live = true
+    end
+
+    # @internal
+    def transmit_port_connected
+      msg = {
+        type: 'port_connected',
+        tags: @tags,
+      }
+      msg[:extra] = ::ActiveJob::Arguments.serialize([@extra]) if @extra
+      port_transmit(room_class::ROOM_IN_CHANNEL, msg, secure_context: true)
+      schedule_reannounce
+    end
+
+    protected
 
-    # Everything a member sends goes to its room, so it's published on the room's Bus channel for
-    # `port` (see Room::Base.inbound_channel). The room's Host is subscribed there and queues the
-    # message on the room. Public because `ports[:x] << msg` reaches it through a PortProxy.
     def port_transmit(port, data, secure_context: false)
       data[:mtok] = @token
 
@@ -332,31 +191,49 @@ module CableRoom
         end
       end
 
-      CableRoom.bus.publish(room_class.inbound_channel(@room_key, port), data)
+      super(port, data)
       # Pings don't count: a ping must never be the reason the next ping is skipped.
       @last_transmit_at = monotonic_now unless type == :port_ping
     end
 
-    # Room→member traffic arrives on ActionCable streams (the broadcaster publishes to them), so
-    # listening on a port is a plain stream_from on the member's channel.
-    #
-    # Subscribing is asynchronous: anything published to the port before the pubsub adapter
-    # confirms the subscription can be lost. ActionCable confirms the channel subscription to the
-    # client only after every stream is live, which is why members wait for the client's `hello`
-    # (see #hello!) rather than announcing themselves from here.
-    def stream_port(port, auto_close: true, &blk)
-      @cable_channel.stream_from(room_port_key(port), coder: ActiveSupport::JSON, &blk)
-      _streamed_ports << port if auto_close
+    # Re-announce until the room acknowledges the port, doubling the wait each time. Handing off
+    # to ping! at PING_INTERVAL keeps a stuck membership from holding a timer open forever.
+    def schedule_reannounce
+      @mutex.synchronize do
+        cancel_reannounce
+        return if @has_established || @has_left
+        return if Host.instance.shutdown?
+
+        next_delay = @reannounce_delay ? @reannounce_delay * 2 : RoomMember::REANNOUNCE_INITIAL_DELAY
+        return if next_delay > RoomMember::PING_INTERVAL
+
+        @reannounce_delay = next_delay
+
+        # async_exec runs the block with `instance_exec` against the channel, so hold onto the
+        # membership rather than relying on `self`.
+        membership = self
+        channel = @cable_channel
+        @reannounce_job = Host.instance.scheduler.schedule_in(@reannounce_delay.to_f) do
+          channel.connection.worker_pool.async_exec(channel, connection: channel.connection) do
+            membership.transmit_port_connected unless membership.connected? || membership.left?
+          end
+        end
+      end
     end
 
-    def close_streamed_ports!
-      _streamed_ports.each do |port|
-        @cable_channel.stop_stream_from(room_port_key(port))
+    def cancel_reannounce
+      @mutex.synchronize do
+        @reannounce_job&.unschedule
+        @reannounce_job = nil
       end
-      _streamed_ports.clear
     end
 
-    protected
+    def stop_reannouncing
+      @mutex.synchronize do
+        cancel_reannounce
+        @reannounce_delay = nil
+      end
+    end
 
     def recently_transmitted?
       @last_transmit_at && (monotonic_now - @last_transmit_at) < RoomMember::PING_INTERVAL
@@ -378,12 +255,13 @@ module CableRoom
         # A re-announced port (see ping!) is re-acknowledged; only the first one is a join.
         first_acknowledgement = !@has_established
         @has_established = true
+        stop_reannouncing
         @on_joined&.call(self) if first_acknowledgement
       when 'room_opened'
-        # The room we were waiting for just came up. Announce again if the client is ready;
-        # before hello the announcement waits for hello itself, and a premature one would be
-        # acknowledged into a stream the client isn't listening on yet.
-        transmit_port_connected if @hello_received
+        # Only safe once our own streams are confirmed; otherwise the room may acknowledge on the
+        # private port before anyone is listening. If we are not live yet, the subscription
+        # confirmation hook will announce for us.
+        transmit_port_connected if @streams_live
         @on_room_opened&.call(self)
       when 'room_closed'
         leave!
@@ -403,14 +281,9 @@ module CableRoom
 
         @token = SecureRandom.hex(16)
         @has_established = false
+        stop_reannouncing
         @cable_channel._room_memberships << self
 
-        # Subscribing is asynchronous, and the room acknowledges on the private @token stream. We
-        # never announce here: port_connected waits for the client's hello (see hello!), which
-        # only arrives after ActionCable has confirmed the subscription — that is, after every one
-        # of these streams is live. A rejoin! is the exception: hello already happened for this
-        # socket, so announce now and let ping! repeat it if the room misses it.
-
         # Listen to public/broadcast channel
         stream_port(room_class::ROOM_OUT_CHANNEL) do |message|
           handle_received_message(message)
@@ -436,84 +309,20 @@ module CableRoom
 
         @preconfigure&.call(self)
 
-        transmit_port_connected if @hello_received
+        # Announcing here races the async stream subscriptions: the room can acknowledge on the
+        # private port before it is live and the ack is lost. transmit_subscription_confirmation
+        # announces instead, once every stream is confirmed.
 
         maybe_provision_room
       end
     end
 
-    def restore_from(cable_channel, record)
-      @mutex = Monitor.new
-      @has_left = false
-      # Never learned here (see #hears_room?); the browser sees the acknowledgement instead.
-      @has_established = false
-
-      @cable_channel = cable_channel
-      @room_class = record.fetch("room_class").constantize
-      @room_key = record.fetch("room_key")
-      @token = record.fetch("token")
-      @tags = Array(record["tags"]).map(&:to_sym)
-      @serialized_extra = record["extra"]
-      @allow_create = record["create"] == true
-      @hello_received = record["hello_received"] == true
-      @tenant = record["tenant"]
-    end
-
-    def transmit_port_connected
-      msg = {
-        type: 'port_connected',
-        tags: @tags,
-      }
-      msg[:extra] = serialized_extra if serialized_extra
-      port_transmit(room_class::ROOM_IN_CHANNEL, msg, secure_context: true)
-    end
-
-    # `extra` as the room receives it. Serialized once: a restored membership only ever has this
-    # form (see #persisted_identity), a fresh one builds it from what join_room was given.
-    def serialized_extra
-      return @serialized_extra if defined?(@serialized_extra)
-
-      @serialized_extra = @extra ? ::ActiveJob::Arguments.serialize([@extra]) : nil
-    end
-
-    # Ask the rooms hosts to start our room if `create: true` asked for it and nobody has
-    # acknowledged us yet. This never starts a room in the member's process: it publishes a
-    # `provision` request on the Bus, and every Host (the web process's own in :inline, the
-    # `cable_room server` fleet in :remote) hears it and races for the room's lock, the least
-    # loaded one first (see CableRoom::Placement). One code path, both modes.
-    #
-    # Called at join and again on every ping until the room acknowledges the port, so a lost
-    # request costs at most one ping interval, and a room whose host died comes back on the next
-    # ping from any member. Once acknowledged the room plainly exists, so we stop asking.
     def maybe_provision_room
       return if left?
       return unless @allow_create
-      return if @has_established
-
-      if CableRoom.config.inline?
-        # In :inline this process hosts rooms itself, so make sure its Host is up and listening
-        # before asking; otherwise the very first request in a fresh process would go unheard.
-        return if Host.instance.shutdown?
-      end
+      return if Host.instance.shutdown?
 
-      request = {
-        type: "provision",
-        room_class: room_class.name,
-        # Keys travel the way `extra` does, so a record key arrives on the host as the record
-        room_key: ::ActiveJob::Arguments.serialize([@room_key]),
-        requested_at: Time.current,
-        # Whatever `join_room` was given for `tenant:` (nil for a single-tenant app). The Host has
-        # no request of its own to derive this from, so a multi-tenant app has to hand it over
-        # explicitly here rather than have the Runner guess at ambient state (see Runner#initialize).
-        tenant: @tenant,
-      }
-
-      ActiveSupport::Notifications.instrument(
-        "provision_requested.cable_room",
-        { membership: self, room_class: room_class, room_key: @room_key, channel: @cable_channel, request: request }
-      ) do
-        CableRoom.bus.publish(Bus.provision_channel, request)
-      end
+      @room_class.ensure(@room_key)
     end
   end
 end

data/lib/cable_room/room_proxy_channel.rb

@@ -13,17 +13,12 @@ module CableRoom
       @room_membership = subscribe_to_room
     end
 
-    # The channel's actions are `hello` and `ping` (inherited from RoomMember: the client performs
-    # hello once its subscription is confirmed, and the membership announces itself to the room)
-    # and `receive`, which pipes everything else the client sends into the room. Until the room
-    # has acknowledged the membership (or, under AnyCable, until hello has gone out — see
-    # RoomMembership#accepts_input?) there is nowhere for input to go, so it is dropped.
     def receive(data)
-      room_membership << data if room_membership&.accepts_input?
+      @room_membership << data if @room_membership&.connected?
     end
 
     def unsubscribed
-      room_membership&.leave!
+      @room_membership&.leave!
     end
 
     protected
@@ -32,12 +27,6 @@ module CableRoom
       raise NotImplementedError
     end
 
-    # The membership `subscribed` created. Under AnyCable this channel instance may not be the one
-    # that ran `subscribed`, so fall back to the memberships rebuilt from the channel state.
-    def room_membership
-      @room_membership ||= room_memberships.first
-    end
-
     def join_room(*args, **kwargs, &blk)
       kwargs[:forward] = true
       super

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.7.0.beta3".freeze
+  VERSION = "0.8.0.beta1".freeze
 end

data/lib/cable_room.rb

@@ -8,18 +8,10 @@ require 'redlock'
 require 'rufus-scheduler'
 
 require_relative 'cable_room/railtie'
-require_relative 'cable_room/config'
-require_relative 'cable_room/broadcaster'
-
-require_relative 'cable_room/bus'
 
 require_relative 'cable_room/periodic_timer'
-require_relative 'cable_room/snapshot'
 require_relative 'cable_room/host'
-require_relative 'cable_room/placement'
-require_relative 'cable_room/migration'
 require_relative 'cable_room/ports'
-require_relative 'cable_room/membership_store'
 require_relative 'cable_room/room_member'
 require_relative 'cable_room/room_proxy_channel'
 require_relative 'cable_room/room/'
@@ -44,27 +36,6 @@ module CableRoom
       warn "CableRoom.error_handler raised #{handler_error.class}: #{handler_error.message}"
     end
 
-    # The active CableRoom::Config. Built on first use with the defaults plus any env
-    # overrides, so an app that never calls `configure` still gets a valid config.
-    def config
-      @config ||= Config.new.apply_env_overrides.validate!
-    end
-
-    # Yields the config so an app can set the knobs, then re-applies the env overrides
-    # (CABLE_ROOM_HOST, CABLE_ROOM_BROADCASTER) and checks every value. Bad values raise
-    # here, at boot, instead of somewhere deep in a room later.
-    def configure
-      cfg = @config || Config.new
-      yield cfg if block_given?
-      @config = cfg.apply_env_overrides.validate!
-    end
-
-    # Drops the current config so the next `config` call rebuilds it, which also makes
-    # `Broadcaster.current` rebuild (and forget any `Broadcaster.current=` override). Meant for specs.
-    def reset_config!
-      @config = nil
-    end
-
     def redis_pool
       require 'rediconn'
       @redis_pool ||= RediConn::RedisConnection.create(env_prefix: "CABLEROOM")
@@ -79,31 +50,5 @@ module CableRoom
         CableRoom.redis,
       ])
     end
-
-    # The process-wide Redis bus (see CableRoom::Bus). Built on first use.
-    def bus
-      @bus ||= Bus.new
-    end
-
-    # Call this in a child process right after `fork`, before it touches Redis or hosts a room.
-    # `cable_room server --workers N` does it for every worker (see Host::Supervisor).
-    #
-    # A forked child starts with copies of the parent's objects but only one thread, so anything
-    # that owns a socket or a thread is broken in the child: the Bus subscriber thread doesn't
-    # exist, its mutex may be held by nobody, and a Redis socket is shared with the parent, so
-    # both processes would read each other's replies. Dropping the memos means the next caller
-    # builds fresh ones. The connection pool and redis-client also notice the fork on their own
-    # (both hook `Process._fork` and drop inherited sockets), and Rails does the same for
-    # ActiveRecord, so those need nothing from us; this keeps the gem's rule simple: nothing
-    # Redis-backed survives a fork.
-    #
-    # The Host goes too. A parent that forks workers must never host rooms itself, and a Host
-    # copied from a parent would have no worker threads and no scheduler thread behind it.
-    def after_fork!
-      @bus = nil
-      @lock_manager = nil
-      @redis_pool = nil
-      Host.replace_current(nil)
-    end
   end
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: cable_room
 version: !ruby/object:Gem::Version
-  version: 0.7.0.beta3
+  version: 0.8.0.beta1
 platform: ruby
 authors:
 - Ethan Knapp
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -77,14 +77,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -101,29 +101,18 @@ dependencies:
         version: '3'
 email:
 - eknapp@instructure.com
-executables:
-- cable_room
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - README.md
 - cable_room.gemspec
-- exe/cable_room
 - lib/cable_room.rb
-- lib/cable_room/broadcaster.rb
-- lib/cable_room/bus.rb
-- lib/cable_room/cli.rb
-- lib/cable_room/config.rb
 - lib/cable_room/host.rb
-- lib/cable_room/host/bus_inbound.rb
+- lib/cable_room/host/action_cable_inbound.rb
 - lib/cable_room/host/runner.rb
-- lib/cable_room/host/supervisor.rb
 - lib/cable_room/host/worker_pool.rb
-- lib/cable_room/membership_store.rb
-- lib/cable_room/migration.rb
 - lib/cable_room/periodic_timer.rb
-- lib/cable_room/placement.rb
 - lib/cable_room/ports.rb
 - lib/cable_room/railtie.rb
 - lib/cable_room/room.rb
@@ -137,13 +126,10 @@ files:
 - lib/cable_room/room/port_policies.rb
 - lib/cable_room/room/port_scoping.rb
 - lib/cable_room/room/reaping.rb
-- lib/cable_room/room/snapshotting.rb
 - lib/cable_room/room/threading.rb
 - lib/cable_room/room/user_management.rb
-- lib/cable_room/room_harness.rb
 - lib/cable_room/room_member.rb
 - lib/cable_room/room_proxy_channel.rb
-- lib/cable_room/snapshot.rb
 - lib/cable_room/version.rb
 homepage: https://instructure.com
 licenses: []