actioncable 5.0.0.beta3 → 5.0.0.beta4

data/lib/action_cable/server/broadcasting.rb

@@ -19,27 +19,28 @@ module ActionCable
     #       new Notification data['title'], body: data['body']
     module Broadcasting
       # Broadcast a hash directly to a named <tt>broadcasting</tt>. This will later be JSON encoded.
-      def broadcast(broadcasting, message)
-        broadcaster_for(broadcasting).broadcast(message)
+      def broadcast(broadcasting, message, coder: ActiveSupport::JSON)
+        broadcaster_for(broadcasting, coder: coder).broadcast(message)
       end
 
       # Returns a broadcaster for a named <tt>broadcasting</tt> that can be reused. Useful when you have an object that
       # may need multiple spots to transmit to a specific broadcasting over and over.
-      def broadcaster_for(broadcasting)
-        Broadcaster.new(self, broadcasting)
+      def broadcaster_for(broadcasting, coder: ActiveSupport::JSON)
+        Broadcaster.new(self, String(broadcasting), coder: coder)
       end
 
       private
         class Broadcaster
-          attr_reader :server, :broadcasting
+          attr_reader :server, :broadcasting, :coder
 
-          def initialize(server, broadcasting)
-            @server, @broadcasting = server, broadcasting
+          def initialize(server, broadcasting, coder:)
+            @server, @broadcasting, @coder = server, broadcasting, coder
           end
 
           def broadcast(message)
-            server.logger.info "[ActionCable] Broadcasting to #{broadcasting}: #{message}"
-            server.pubsub.broadcast broadcasting, ActiveSupport::JSON.encode(message)
+            server.logger.info "[ActionCable] Broadcasting to #{broadcasting}: #{message.inspect}"
+            encoded = coder ? coder.encode(message) : message
+            server.pubsub.broadcast broadcasting, encoded
           end
         end
     end

data/lib/action_cable/server/configuration.rb

@@ -4,9 +4,9 @@ module ActionCable
     # in a Rails config initializer.
     class Configuration
       attr_accessor :logger, :log_tags
-      attr_accessor :connection_class, :worker_pool_size
+      attr_accessor :use_faye, :connection_class, :worker_pool_size
       attr_accessor :disable_request_forgery_protection, :allowed_request_origins
-      attr_accessor :cable, :url
+      attr_accessor :cable, :url, :mount_path
 
       attr_accessor :channel_paths # :nodoc:
 
@@ -14,7 +14,7 @@ module ActionCable
         @log_tags = []
 
         @connection_class = ActionCable::Connection::Base
-        @worker_pool_size = 100
+        @worker_pool_size = 4
 
         @disable_request_forgery_protection = false
       end
@@ -43,6 +43,22 @@ module ActionCable
         adapter = 'PostgreSQL' if adapter == 'Postgresql'
         "ActionCable::SubscriptionAdapter::#{adapter}".constantize
       end
+
+      def event_loop_class
+        if use_faye
+          ActionCable::Connection::FayeEventLoop
+        else
+          ActionCable::Connection::StreamEventLoop
+        end
+      end
+
+      def client_socket_class
+        if use_faye
+          ActionCable::Connection::FayeClientSocket
+        else
+          ActionCable::Connection::ClientSocket
+        end
+      end
     end
   end
 end

data/lib/action_cable/server/connections.rb

@@ -21,9 +21,9 @@ module ActionCable
       # then can't rely on being able to communicate with the connection. To solve this, a 3 second heartbeat runs on all connections. If the beat fails, we automatically
       # disconnect.
       def setup_heartbeat_timer
-        @heartbeat_timer ||= Concurrent::TimerTask.new(execution_interval: BEAT_INTERVAL) do
-          Concurrent.global_io_executor.post { connections.map(&:beat) }
-        end.tap(&:execute)
+        @heartbeat_timer ||= event_loop.timer(BEAT_INTERVAL) do
+          event_loop.post { connections.map(&:beat) }
+        end
       end
 
       def open_connections_statistics

data/lib/action_cable/server/worker.rb

@@ -12,52 +12,52 @@ module ActionCable
       define_callbacks :work
       include ActiveRecordConnectionManagement
 
+      attr_reader :executor
+
       def initialize(max_size: 5)
-        @pool = Concurrent::ThreadPoolExecutor.new(
+        @executor = Concurrent::ThreadPoolExecutor.new(
           min_threads: 1,
           max_threads: max_size,
           max_queue: 0,
         )
       end
 
-      def async_invoke(receiver, method, *args)
-        @pool.post do
-          invoke(receiver, method, *args)
-        end
+      # Stop processing work: any work that has not already started
+      # running will be discarded from the queue
+      def halt
+        @executor.kill
       end
 
-      def invoke(receiver, method, *args)
-        begin
-          self.connection = receiver
+      def stopping?
+        @executor.shuttingdown?
+      end
 
-          run_callbacks :work do
-            receiver.send method, *args
-          end
-        rescue Exception => e
-          logger.error "There was an exception - #{e.class}(#{e.message})"
-          logger.error e.backtrace.join("\n")
+      def work(connection)
+        self.connection = connection
 
-          receiver.handle_exception if receiver.respond_to?(:handle_exception)
-        ensure
-          self.connection = nil
+        run_callbacks :work do
+          yield
         end
+      ensure
+        self.connection = nil
       end
 
-      def async_run_periodic_timer(channel, callback)
-        @pool.post do
-          run_periodic_timer(channel, callback)
+      def async_invoke(receiver, method, *args, connection: receiver)
+        @executor.post do
+          invoke(receiver, method, *args, connection: connection)
         end
       end
 
-      def run_periodic_timer(channel, callback)
-        begin
-          self.connection = channel.connection
+      def invoke(receiver, method, *args, connection:)
+        work(connection) do
+          begin
+            receiver.send method, *args
+          rescue Exception => e
+            logger.error "There was an exception - #{e.class}(#{e.message})"
+            logger.error e.backtrace.join("\n")
 
-          run_callbacks :work do
-            callback.respond_to?(:call) ? channel.instance_exec(&callback) : channel.send(callback)
+            receiver.handle_exception if receiver.respond_to?(:handle_exception)
           end
-        ensure
-          self.connection = nil
         end
       end
 

data/lib/action_cable/server/worker/active_record_connection_management.rb

@@ -1,7 +1,6 @@
 module ActionCable
   module Server
     class Worker
-      # Clear active connections between units of work so that way long-running channels or connection processes do not hoard connections.
       module ActiveRecordConnectionManagement
         extend ActiveSupport::Concern
 
@@ -13,8 +12,6 @@ module ActionCable
 
         def with_database_connections
           connection.logger.tag(ActiveRecord::Base.logger) { yield }
-        ensure
-          ActiveRecord::Base.clear_active_connections!
         end
       end
     end

data/lib/action_cable/subscription_adapter/async.rb

@@ -5,16 +5,21 @@ module ActionCable
     class Async < Inline # :nodoc:
       private
         def new_subscriber_map
-          AsyncSubscriberMap.new
+          AsyncSubscriberMap.new(server.event_loop)
         end
 
         class AsyncSubscriberMap < SubscriberMap
+          def initialize(event_loop)
+            @event_loop = event_loop
+            super()
+          end
+
           def add_subscriber(*)
-            Concurrent.global_io_executor.post { super }
+            @event_loop.post { super }
           end
 
           def invoke_callback(*)
-            Concurrent.global_io_executor.post { super }
+            @event_loop.post { super }
           end
         end
     end

data/lib/action_cable/subscription_adapter/evented_redis.rb

@@ -51,7 +51,11 @@ module ActionCable
           @redis_connection_for_subscriptions || @server.mutex.synchronize do
             @redis_connection_for_subscriptions ||= self.class.em_redis_connector.call(@server.config.cable).tap do |redis|
               redis.on(:reconnect_failed) do
-                @logger.info "[ActionCable] Redis reconnect failed."
+                @logger.error "[ActionCable] Redis reconnect failed."
+              end
+
+              redis.on(:failed) do
+                @logger.error "[ActionCable] Redis connection has failed."
               end
             end
           end

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -42,14 +42,15 @@ module ActionCable
 
       private
         def listener
-          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self) }
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
         end
 
         class Listener < SubscriberMap
-          def initialize(adapter)
+          def initialize(adapter, event_loop)
             super()
 
             @adapter = adapter
+            @event_loop = event_loop
             @queue = Queue.new
 
             @thread = Thread.new do
@@ -68,7 +69,7 @@ module ActionCable
                     case action
                     when :listen
                       pg_conn.exec("LISTEN #{pg_conn.escape_identifier channel}")
-                      Concurrent.global_io_executor << callback if callback
+                      @event_loop.post(&callback) if callback
                     when :unlisten
                       pg_conn.exec("UNLISTEN #{pg_conn.escape_identifier channel}")
                     when :shutdown
@@ -98,7 +99,7 @@ module ActionCable
           end
 
           def invoke_callback(*)
-            Concurrent.global_io_executor.post { super }
+            @event_loop.post { super }
           end
         end
     end

data/lib/action_cable/subscription_adapter/redis.rb

@@ -33,25 +33,30 @@ module ActionCable
       end
 
       def redis_connection_for_subscriptions
-        ::Redis.new(@server.config.cable)
+        redis_connection
       end
 
       private
         def listener
-          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self) }
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
         end
 
         def redis_connection_for_broadcasts
           @redis_connection_for_broadcasts || @server.mutex.synchronize do
-            @redis_connection_for_broadcasts ||= self.class.redis_connector.call(@server.config.cable)
+            @redis_connection_for_broadcasts ||= redis_connection
           end
         end
 
+        def redis_connection
+          self.class.redis_connector.call(@server.config.cable)
+        end
+
         class Listener < SubscriberMap
-          def initialize(adapter)
+          def initialize(adapter, event_loop)
             super()
 
             @adapter = adapter
+            @event_loop = event_loop
 
             @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
             @subscription_lock = Mutex.new
@@ -80,7 +85,7 @@ module ActionCable
 
                     if callbacks = @subscribe_callbacks[chan]
                       next_callback = callbacks.shift
-                      Concurrent.global_io_executor << next_callback if next_callback
+                      @event_loop.post(&next_callback) if next_callback
                       @subscribe_callbacks.delete(chan) if callbacks.empty?
                     end
                   end
@@ -129,7 +134,7 @@ module ActionCable
           end
 
           def invoke_callback(*)
-            Concurrent.global_io_executor.post { super }
+            @event_loop.post { super }
           end
 
           private

data/lib/assets/compiled/action_cable.js

@@ -3,17 +3,19 @@
 
   this.ActionCable = {
     INTERNAL: {
-      "identifiers": {
-        "ping": "_ping"
-      },
       "message_types": {
+        "welcome": "welcome",
+        "ping": "ping",
         "confirmation": "confirm_subscription",
         "rejection": "reject_subscription"
-      }
+      },
+      "default_mount_path": "/cable",
+      "protocols": ["actioncable-v1-json", "actioncable-unsupported"]
     },
     createConsumer: function(url) {
+      var ref;
       if (url == null) {
-        url = this.getConfig("url");
+        url = (ref = this.getConfig("url")) != null ? ref : this.INTERNAL.default_mount_path;
       }
       return new ActionCable.Consumer(this.createWebSocketURL(url));
     },
@@ -52,12 +54,149 @@
 
 }).call(this);
 (function() {
-  var message_types,
-    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+  var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  ActionCable.ConnectionMonitor = (function() {
+    var clamp, now, secondsSince;
+
+    ConnectionMonitor.pollInterval = {
+      min: 3,
+      max: 30
+    };
+
+    ConnectionMonitor.staleThreshold = 6;
+
+    function ConnectionMonitor(connection) {
+      this.connection = connection;
+      this.visibilityDidChange = bind(this.visibilityDidChange, this);
+      this.reconnectAttempts = 0;
+    }
+
+    ConnectionMonitor.prototype.start = function() {
+      if (!this.isRunning()) {
+        this.startedAt = now();
+        delete this.stoppedAt;
+        this.startPolling();
+        document.addEventListener("visibilitychange", this.visibilityDidChange);
+        return ActionCable.log("ConnectionMonitor started. pollInterval = " + (this.getPollInterval()) + " ms");
+      }
+    };
+
+    ConnectionMonitor.prototype.stop = function() {
+      if (this.isRunning()) {
+        this.stoppedAt = now();
+        this.stopPolling();
+        document.removeEventListener("visibilitychange", this.visibilityDidChange);
+        return ActionCable.log("ConnectionMonitor stopped");
+      }
+    };
+
+    ConnectionMonitor.prototype.isRunning = function() {
+      return (this.startedAt != null) && (this.stoppedAt == null);
+    };
+
+    ConnectionMonitor.prototype.recordPing = function() {
+      return this.pingedAt = now();
+    };
+
+    ConnectionMonitor.prototype.recordConnect = function() {
+      this.reconnectAttempts = 0;
+      this.recordPing();
+      delete this.disconnectedAt;
+      return ActionCable.log("ConnectionMonitor recorded connect");
+    };
+
+    ConnectionMonitor.prototype.recordDisconnect = function() {
+      this.disconnectedAt = now();
+      return ActionCable.log("ConnectionMonitor recorded disconnect");
+    };
+
+    ConnectionMonitor.prototype.startPolling = function() {
+      this.stopPolling();
+      return this.poll();
+    };
+
+    ConnectionMonitor.prototype.stopPolling = function() {
+      return clearTimeout(this.pollTimeout);
+    };
+
+    ConnectionMonitor.prototype.poll = function() {
+      return this.pollTimeout = setTimeout((function(_this) {
+        return function() {
+          _this.reconnectIfStale();
+          return _this.poll();
+        };
+      })(this), this.getPollInterval());
+    };
+
+    ConnectionMonitor.prototype.getPollInterval = function() {
+      var interval, max, min, ref;
+      ref = this.constructor.pollInterval, min = ref.min, max = ref.max;
+      interval = 5 * Math.log(this.reconnectAttempts + 1);
+      return Math.round(clamp(interval, min, max) * 1000);
+    };
+
+    ConnectionMonitor.prototype.reconnectIfStale = function() {
+      if (this.connectionIsStale()) {
+        ActionCable.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", pollInterval = " + (this.getPollInterval()) + " ms, time disconnected = " + (secondsSince(this.disconnectedAt)) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+        this.reconnectAttempts++;
+        if (this.disconnectedRecently()) {
+          return ActionCable.log("ConnectionMonitor skipping reopening recent disconnect");
+        } else {
+          ActionCable.log("ConnectionMonitor reopening");
+          return this.connection.reopen();
+        }
+      }
+    };
+
+    ConnectionMonitor.prototype.connectionIsStale = function() {
+      var ref;
+      return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
+    };
+
+    ConnectionMonitor.prototype.disconnectedRecently = function() {
+      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+    };
+
+    ConnectionMonitor.prototype.visibilityDidChange = function() {
+      if (document.visibilityState === "visible") {
+        return setTimeout((function(_this) {
+          return function() {
+            if (_this.connectionIsStale() || !_this.connection.isOpen()) {
+              ActionCable.log("ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = " + document.visibilityState);
+              return _this.connection.reopen();
+            }
+          };
+        })(this), 200);
+      }
+    };
+
+    now = function() {
+      return new Date().getTime();
+    };
+
+    secondsSince = function(time) {
+      return (now() - time) / 1000;
+    };
+
+    clamp = function(number, min, max) {
+      return Math.max(min, Math.min(max, number));
+    };
+
+    return ConnectionMonitor;
+
+  })();
+
+}).call(this);
+(function() {
+  var i, message_types, protocols, ref, supportedProtocols, unsupportedProtocol,
     slice = [].slice,
+    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
     indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
 
-  message_types = ActionCable.INTERNAL.message_types;
+  ref = ActionCable.INTERNAL, message_types = ref.message_types, protocols = ref.protocols;
+
+  supportedProtocols = 2 <= protocols.length ? slice.call(protocols, 0, i = protocols.length - 1) : (i = 0, []), unsupportedProtocol = protocols[i++];
 
   ActionCable.Connection = (function() {
     Connection.reopenDelay = 500;
@@ -65,7 +204,9 @@
     function Connection(consumer) {
       this.consumer = consumer;
       this.open = bind(this.open, this);
-      this.open();
+      this.subscriptions = this.consumer.subscriptions;
+      this.monitor = new ActionCable.ConnectionMonitor(this);
+      this.disconnected = true;
     }
 
     Connection.prototype.send = function(data) {
@@ -78,29 +219,38 @@
     };
 
     Connection.prototype.open = function() {
-      if (this.isAlive()) {
-        ActionCable.log("Attemped to open WebSocket, but existing socket is " + (this.getState()));
+      if (this.isActive()) {
+        ActionCable.log("Attempted to open WebSocket, but existing socket is " + (this.getState()));
         throw new Error("Existing connection must be closed before opening");
       } else {
-        ActionCable.log("Opening WebSocket, current state is " + (this.getState()));
+        ActionCable.log("Opening WebSocket, current state is " + (this.getState()) + ", subprotocols: " + protocols);
         if (this.webSocket != null) {
           this.uninstallEventHandlers();
         }
-        this.webSocket = new WebSocket(this.consumer.url);
+        this.webSocket = new WebSocket(this.consumer.url, protocols);
         this.installEventHandlers();
+        this.monitor.start();
         return true;
       }
     };
 
-    Connection.prototype.close = function() {
-      var ref;
-      return (ref = this.webSocket) != null ? ref.close() : void 0;
+    Connection.prototype.close = function(arg) {
+      var allowReconnect, ref1;
+      allowReconnect = (arg != null ? arg : {
+        allowReconnect: true
+      }).allowReconnect;
+      if (!allowReconnect) {
+        this.monitor.stop();
+      }
+      if (this.isActive()) {
+        return (ref1 = this.webSocket) != null ? ref1.close() : void 0;
+      }
     };
 
     Connection.prototype.reopen = function() {
       var error, error1;
       ActionCable.log("Reopening WebSocket, current state is " + (this.getState()));
-      if (this.isAlive()) {
+      if (this.isActive()) {
         try {
           return this.close();
         } catch (error1) {
@@ -115,25 +265,35 @@
       }
     };
 
+    Connection.prototype.getProtocol = function() {
+      var ref1;
+      return (ref1 = this.webSocket) != null ? ref1.protocol : void 0;
+    };
+
     Connection.prototype.isOpen = function() {
       return this.isState("open");
     };
 
-    Connection.prototype.isAlive = function() {
-      return (this.webSocket != null) && !this.isState("closing", "closed");
+    Connection.prototype.isActive = function() {
+      return this.isState("open", "connecting");
+    };
+
+    Connection.prototype.isProtocolSupported = function() {
+      var ref1;
+      return ref1 = this.getProtocol(), indexOf.call(supportedProtocols, ref1) >= 0;
     };
 
     Connection.prototype.isState = function() {
-      var ref, states;
+      var ref1, states;
       states = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-      return ref = this.getState(), indexOf.call(states, ref) >= 0;
+      return ref1 = this.getState(), indexOf.call(states, ref1) >= 0;
     };
 
     Connection.prototype.getState = function() {
-      var ref, state, value;
+      var ref1, state, value;
       for (state in WebSocket) {
         value = WebSocket[state];
-        if (value === ((ref = this.webSocket) != null ? ref.readyState : void 0)) {
+        if (value === ((ref1 = this.webSocket) != null ? ref1.readyState : void 0)) {
           return state.toLowerCase();
         }
       }
@@ -157,170 +317,55 @@
 
     Connection.prototype.events = {
       message: function(event) {
-        var identifier, message, ref, type;
-        ref = JSON.parse(event.data), identifier = ref.identifier, message = ref.message, type = ref.type;
+        var identifier, message, ref1, type;
+        if (!this.isProtocolSupported()) {
+          return;
+        }
+        ref1 = JSON.parse(event.data), identifier = ref1.identifier, message = ref1.message, type = ref1.type;
         switch (type) {
+          case message_types.welcome:
+            this.monitor.recordConnect();
+            return this.subscriptions.reload();
+          case message_types.ping:
+            return this.monitor.recordPing();
           case message_types.confirmation:
-            return this.consumer.subscriptions.notify(identifier, "connected");
+            return this.subscriptions.notify(identifier, "connected");
           case message_types.rejection:
-            return this.consumer.subscriptions.reject(identifier);
+            return this.subscriptions.reject(identifier);
           default:
-            return this.consumer.subscriptions.notify(identifier, "received", message);
+            return this.subscriptions.notify(identifier, "received", message);
         }
       },
       open: function() {
-        ActionCable.log("WebSocket onopen event");
+        ActionCable.log("WebSocket onopen event, using '" + (this.getProtocol()) + "' subprotocol");
         this.disconnected = false;
-        return this.consumer.subscriptions.reload();
+        if (!this.isProtocolSupported()) {
+          ActionCable.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+          return this.close({
+            allowReconnect: false
+          });
+        }
       },
-      close: function() {
+      close: function(event) {
         ActionCable.log("WebSocket onclose event");
-        return this.disconnect();
+        if (this.disconnected) {
+          return;
+        }
+        this.disconnected = true;
+        this.monitor.recordDisconnect();
+        return this.subscriptions.notifyAll("disconnected", {
+          willAttemptReconnect: this.monitor.isRunning()
+        });
       },
       error: function() {
-        ActionCable.log("WebSocket onerror event");
-        return this.disconnect();
+        return ActionCable.log("WebSocket onerror event");
       }
     };
 
-    Connection.prototype.disconnect = function() {
-      if (this.disconnected) {
-        return;
-      }
-      this.disconnected = true;
-      return this.consumer.subscriptions.notifyAll("disconnected");
-    };
-
     return Connection;
 
   })();
 
-}).call(this);
-(function() {
-  var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
-
-  ActionCable.ConnectionMonitor = (function() {
-    var clamp, now, secondsSince;
-
-    ConnectionMonitor.pollInterval = {
-      min: 3,
-      max: 30
-    };
-
-    ConnectionMonitor.staleThreshold = 6;
-
-    ConnectionMonitor.prototype.identifier = ActionCable.INTERNAL.identifiers.ping;
-
-    function ConnectionMonitor(consumer) {
-      this.consumer = consumer;
-      this.visibilityDidChange = bind(this.visibilityDidChange, this);
-      this.consumer.subscriptions.add(this);
-      this.start();
-    }
-
-    ConnectionMonitor.prototype.connected = function() {
-      this.reset();
-      this.pingedAt = now();
-      delete this.disconnectedAt;
-      return ActionCable.log("ConnectionMonitor connected");
-    };
-
-    ConnectionMonitor.prototype.disconnected = function() {
-      return this.disconnectedAt = now();
-    };
-
-    ConnectionMonitor.prototype.received = function() {
-      return this.pingedAt = now();
-    };
-
-    ConnectionMonitor.prototype.reset = function() {
-      return this.reconnectAttempts = 0;
-    };
-
-    ConnectionMonitor.prototype.start = function() {
-      this.reset();
-      delete this.stoppedAt;
-      this.startedAt = now();
-      this.poll();
-      document.addEventListener("visibilitychange", this.visibilityDidChange);
-      return ActionCable.log("ConnectionMonitor started, pollInterval is " + (this.getInterval()) + "ms");
-    };
-
-    ConnectionMonitor.prototype.stop = function() {
-      this.stoppedAt = now();
-      document.removeEventListener("visibilitychange", this.visibilityDidChange);
-      return ActionCable.log("ConnectionMonitor stopped");
-    };
-
-    ConnectionMonitor.prototype.poll = function() {
-      return setTimeout((function(_this) {
-        return function() {
-          if (!_this.stoppedAt) {
-            _this.reconnectIfStale();
-            return _this.poll();
-          }
-        };
-      })(this), this.getInterval());
-    };
-
-    ConnectionMonitor.prototype.getInterval = function() {
-      var interval, max, min, ref;
-      ref = this.constructor.pollInterval, min = ref.min, max = ref.max;
-      interval = 5 * Math.log(this.reconnectAttempts + 1);
-      return clamp(interval, min, max) * 1000;
-    };
-
-    ConnectionMonitor.prototype.reconnectIfStale = function() {
-      if (this.connectionIsStale()) {
-        ActionCable.log("ConnectionMonitor detected stale connection, reconnectAttempts = " + this.reconnectAttempts);
-        this.reconnectAttempts++;
-        if (this.disconnectedRecently()) {
-          return ActionCable.log("ConnectionMonitor skipping reopen because recently disconnected at " + this.disconnectedAt);
-        } else {
-          ActionCable.log("ConnectionMonitor reopening");
-          return this.consumer.connection.reopen();
-        }
-      }
-    };
-
-    ConnectionMonitor.prototype.connectionIsStale = function() {
-      var ref;
-      return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
-    };
-
-    ConnectionMonitor.prototype.disconnectedRecently = function() {
-      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
-    };
-
-    ConnectionMonitor.prototype.visibilityDidChange = function() {
-      if (document.visibilityState === "visible") {
-        return setTimeout((function(_this) {
-          return function() {
-            if (_this.connectionIsStale() || !_this.consumer.connection.isOpen()) {
-              ActionCable.log("ConnectionMonitor reopening stale connection after visibilitychange to " + document.visibilityState);
-              return _this.consumer.connection.reopen();
-            }
-          };
-        })(this), 200);
-      }
-    };
-
-    now = function() {
-      return new Date().getTime();
-    };
-
-    secondsSince = function(time) {
-      return (now() - time) / 1000;
-    };
-
-    clamp = function(number, min, max) {
-      return Math.max(min, Math.min(max, number));
-    };
-
-    return ConnectionMonitor;
-
-  })();
-
 }).call(this);
 (function() {
   var slice = [].slice;
@@ -332,25 +377,29 @@
     }
 
     Subscriptions.prototype.create = function(channelName, mixin) {
-      var channel, params;
+      var channel, params, subscription;
       channel = channelName;
       params = typeof channel === "object" ? channel : {
         channel: channel
       };
-      return new ActionCable.Subscription(this, params, mixin);
+      subscription = new ActionCable.Subscription(this.consumer, params, mixin);
+      return this.add(subscription);
     };
 
     Subscriptions.prototype.add = function(subscription) {
       this.subscriptions.push(subscription);
+      this.consumer.ensureActiveConnection();
       this.notify(subscription, "initialized");
-      return this.sendCommand(subscription, "subscribe");
+      this.sendCommand(subscription, "subscribe");
+      return subscription;
     };
 
     Subscriptions.prototype.remove = function(subscription) {
       this.forget(subscription);
       if (!this.findAll(subscription.identifier).length) {
-        return this.sendCommand(subscription, "unsubscribe");
+        this.sendCommand(subscription, "unsubscribe");
       }
+      return subscription;
     };
 
     Subscriptions.prototype.reject = function(identifier) {
@@ -360,14 +409,15 @@
       for (i = 0, len = ref.length; i < len; i++) {
         subscription = ref[i];
         this.forget(subscription);
-        results.push(this.notify(subscription, "rejected"));
+        this.notify(subscription, "rejected");
+        results.push(subscription);
       }
       return results;
     };
 
     Subscriptions.prototype.forget = function(subscription) {
       var s;
-      return this.subscriptions = (function() {
+      this.subscriptions = (function() {
         var i, len, ref, results;
         ref = this.subscriptions;
         results = [];
@@ -379,6 +429,7 @@
         }
         return results;
       }).call(this);
+      return subscription;
     };
 
     Subscriptions.prototype.findAll = function(identifier) {
@@ -436,14 +487,10 @@
     Subscriptions.prototype.sendCommand = function(subscription, command) {
       var identifier;
       identifier = subscription.identifier;
-      if (identifier === ActionCable.INTERNAL.identifiers.ping) {
-        return this.consumer.connection.isOpen();
-      } else {
-        return this.consumer.send({
-          command: command,
-          identifier: identifier
-        });
-      }
+      return this.consumer.send({
+        command: command,
+        identifier: identifier
+      });
     };
 
     return Subscriptions;
@@ -455,15 +502,13 @@
   ActionCable.Subscription = (function() {
     var extend;
 
-    function Subscription(subscriptions, params, mixin) {
-      this.subscriptions = subscriptions;
+    function Subscription(consumer, params, mixin) {
+      this.consumer = consumer;
       if (params == null) {
         params = {};
       }
       this.identifier = JSON.stringify(params);
       extend(this, mixin);
-      this.subscriptions.add(this);
-      this.consumer = this.subscriptions.consumer;
     }
 
     Subscription.prototype.perform = function(action, data) {
@@ -483,7 +528,7 @@
     };
 
     Subscription.prototype.unsubscribe = function() {
-      return this.subscriptions.remove(this);
+      return this.consumer.subscriptions.remove(this);
     };
 
     extend = function(object, properties) {
@@ -508,13 +553,28 @@
       this.url = url;
       this.subscriptions = new ActionCable.Subscriptions(this);
       this.connection = new ActionCable.Connection(this);
-      this.connectionMonitor = new ActionCable.ConnectionMonitor(this);
     }
 
     Consumer.prototype.send = function(data) {
       return this.connection.send(data);
     };
 
+    Consumer.prototype.connect = function() {
+      return this.connection.open();
+    };
+
+    Consumer.prototype.disconnect = function() {
+      return this.connection.close({
+        allowReconnect: false
+      });
+    };
+
+    Consumer.prototype.ensureActiveConnection = function() {
+      if (!this.connection.isActive()) {
+        return this.connection.open();
+      }
+    };
+
     return Consumer;
 
   })();