ably 0.8.15 → 1.0.0

data/lib/ably/realtime/client/outgoing_message_dispatcher.rb

@@ -74,7 +74,12 @@ module Ably::Realtime
 
       def setup_event_handlers
         connection.unsafe_on(:connected) do
-          deliver_queued_protocol_messages
+          # Give connection manager enough time to prevent message delivery if necessary
+          # For example, if reconnecting and connection and channel state is lost,
+          # then the queued messages must be NACK'd
+          EventMachine.next_tick do
+            deliver_queued_protocol_messages
+          end
         end
       end
     end

data/lib/ably/realtime/connection.rb

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Ably
   module Realtime
     # The Connection class represents the connection associated with an Ably Realtime instance.
@@ -25,8 +27,6 @@ module Ably
     #   Connection::STATE.Closed
     #   Connection::STATE.Failed
     #
-    # Connection emit errors - use `on(:error)` to subscribe to errors
-    #
     # @example
     #    client = Ably::Realtime::Client.new('key.id:secret')
     #    client.connection.on(:connected) do
@@ -42,7 +42,8 @@ module Ably
       include Ably::Modules::SafeYield
       extend Ably::Modules::Enum
 
-      # Valid Connection states
+      # ConnectionState
+      # The permited states for this connection
       STATE = ruby_enum('STATE',
         :initialized,
         :connecting,
@@ -53,6 +54,13 @@ module Ably
         :closed,
         :failed
       )
+
+      # ConnectionEvent
+      # The permitted connection events that are emitted for this connection
+      EVENT = ruby_enum('EVENT',
+        STATE.to_sym_arr + [:update]
+      )
+
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
       ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
@@ -62,11 +70,13 @@ module Ably
 
       # Defaults for automatic connection recovery and timeouts
       DEFAULTS = {
+        channel_retry_timeout:      15, # when a channel becomes SUSPENDED, after this delay in seconds, the channel will automatically attempt to reattach if the connection is CONNECTED
         disconnected_retry_timeout: 15, # when the connection enters the DISCONNECTED state, after this delay in milliseconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
         suspended_retry_timeout:    30, # when the connection enters the SUSPENDED state, after this delay in milliseconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
         connection_state_ttl:       120, # the duration that Ably will persist the connection state when a Realtime client is abruptly disconnected
-        max_connection_state_ttl:   nil, # allow a max TTL to be passed in for CI test purposes thus overiding any connection_state_ttl sent from Ably
+        max_connection_state_ttl:   nil, # allow a max TTL to be passed in, usually for CI test purposes thus overiding any connection_state_ttl sent from Ably
         realtime_request_timeout:   10,  # default timeout when establishing a connection, or sending a HEARTBEAT, CONNECT, ATTACH, DETACH or CLOSE ProtocolMessage
+        websocket_heartbeats_disabled: false,
       }.freeze
 
       # A unique public identifier for this connection, used to identify this member in presence events and messages
@@ -122,9 +132,9 @@ module Ably
       # @api public
       def initialize(client, options)
         @client                        = client
-        @client_serial                 = -1
         @__outgoing_message_queue__    = []
         @__pending_message_ack_queue__ = []
+        reset_client_serial
 
         @defaults = DEFAULTS.dup
         options.each do |key, val|
@@ -150,7 +160,9 @@ module Ably
       #
       def close(&success_block)
         unless closing? || closed?
-          raise exception_for_state_change_to(:closing) unless can_transition_to?(:closing)
+          unless can_transition_to?(:closing)
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:closing))
+          end
           transition_state_machine :closing
         end
         deferrable_for_state_change_to(STATE.Closed, &success_block)
@@ -170,8 +182,11 @@ module Ably
       #
       def connect(&success_block)
         unless connecting? || connected?
-          raise exception_for_state_change_to(:connecting) unless can_transition_to?(:connecting)
-          transition_state_machine :connecting
+          unless can_transition_to?(:connecting)
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:connecting))
+          end
+          # If connect called in a suspended block, we want to ensure the other callbacks have finished their work first
+          EventMachine.next_tick { transition_state_machine :connecting if can_transition_to?(:connecting) }
         end
 
         Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
@@ -181,12 +196,12 @@ module Ably
           succeed_callback = deferrable.method(:succeed)
           fail_callback    = deferrable.method(:fail)
 
-          once(:connected) do
+          unsafe_once(:connected) do
             deferrable.succeed
             off(&fail_callback)
           end
 
-          once(:failed, :closed, :closing) do
+          unsafe_once(:failed, :closed, :closing) do
             deferrable.fail
             off(&succeed_callback)
           end
@@ -206,38 +221,53 @@ module Ably
       #      puts "Ping took #{elapsed_s}s"
       #    end
       #
-      # @return [void]
+      # @return [Ably::Util::SafeDeferrable]
       #
       def ping(&block)
-        raise RuntimeError, 'Cannot send a ping when connection is not open' if initialized?
-        raise RuntimeError, 'Cannot send a ping when connection is in a closed or failed state' if closed? || failed?
+        if initialized? || suspended? || closing? || closed? || failed?
+          error = Ably::Models::ErrorInfo.new(message: "Cannot send a ping when the connection is #{state}", code: 80003)
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+        end
 
-        started = nil
-        finished = false
+        Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
+          started = nil
+          finished = false
+          ping_id = SecureRandom.hex(16)
+          heartbeat_action = Ably::Models::ProtocolMessage::ACTION.Heartbeat
+
+          wait_for_ping = Proc.new do |protocol_message|
+            next if finished
+            if protocol_message.action == heartbeat_action && protocol_message.id == ping_id
+              finished = true
+              __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
+              time_passed = Time.now.to_f - started.to_f
+              deferrable.succeed time_passed
+              safe_yield block, time_passed if block_given?
+            end
+          end
 
-        wait_for_ping = Proc.new do |protocol_message|
-          next if finished
-          if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
-            finished = true
-            __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-            time_passed = Time.now.to_f - started.to_f
-            safe_yield block, time_passed if block_given?
+          once_or_if(STATE.Connected) do
+            next if finished
+            started = Time.now
+            send_protocol_message action: heartbeat_action.to_i, id: ping_id
+            __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
           end
-        end
 
-        once_or_if(STATE.Connected) do
-          next if finished
-          started = Time.now
-          send_protocol_message action: Ably::Models::ProtocolMessage::ACTION.Heartbeat.to_i
-          __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
-        end
+          once_or_if([:suspended, :closing, :closed, :failed]) do
+            next if finished
+            finished = true
+            deferrable.fail Ably::Models::ErrorInfo.new(message: "Ping failed as connection has changed state to #{state}", code: 80003)
+          end
 
-        EventMachine.add_timer(defaults.fetch(:realtime_request_timeout)) do
-          next if finished
-          finished = true
-          __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-          logger.warn "Ping timed out after #{defaults.fetch(:realtime_request_timeout)}s"
-          safe_yield block, nil if block_given?
+          EventMachine.add_timer(defaults.fetch(:realtime_request_timeout)) do
+            next if finished
+            finished = true
+            __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
+            error_msg = "Ping timed out after #{defaults.fetch(:realtime_request_timeout)}s"
+            logger.warn { error_msg }
+            deferrable.fail Ably::Models::ErrorInfo.new(message: error_msg, code: 50003)
+            safe_yield block, nil if block_given?
+          end
         end
       end
 
@@ -364,7 +394,7 @@ module Ably
           Ably::Models::ProtocolMessage.new(protocol_message, logger: logger).tap do |message|
             add_message_to_outgoing_queue message
             notify_message_dispatcher_of_new_message message
-            logger.debug("Connection: Prot msg queued =>: #{message.action} #{message}")
+            logger.debug { "Connection: Prot msg queued =>: #{message.action} #{message}" }
           end
         end
       end
@@ -387,21 +417,24 @@ module Ably
           client.auth.auth_params.tap do |auth_deferrable|
             auth_deferrable.callback do |auth_params|
               url_params = auth_params.merge(
-                format:    client.protocol,
-                echo:      client.echo_messages,
-                v:         Ably::PROTOCOL_VERSION,
-                lib:       client.rest_client.lib_version_id,
+                format:     client.protocol,
+                echo:       client.echo_messages,
+                v:          Ably::PROTOCOL_VERSION,
+                lib:        client.rest_client.lib_version_id,
               )
 
+              # Use native websocket heartbeats if possible
+              url_params['heartbeats'] = 'false' unless defaults.fetch(:websocket_heartbeats_disabled)
+
               url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?
 
               if connection_resumable?
                 url_params.merge! resume: key, connection_serial: serial
-                logger.debug "Resuming connection key #{key} with serial #{serial}"
+                logger.debug { "Resuming connection key #{key} with serial #{serial}" }
               elsif connection_recoverable?
-                url_params.merge! recover: connection_recover_parts[:recover], connection_serial: connection_recover_parts[:connection_serial]
-                logger.debug "Recovering connection with key #{client.recover}"
-                once(:connected, :closed, :failed) do
+                url_params.merge! recover: connection_recover_parts[:recover], connectionSerial: connection_recover_parts[:connection_serial]
+                logger.debug { "Recovering connection with key #{client.recover}" }
+                unsafe_once(:connected, :closed, :failed) do
                   client.disable_automatic_connection_recovery
                 end
               end
@@ -412,7 +445,7 @@ module Ably
 
               determine_host do |host|
                 begin
-                  logger.debug "Connection: Opening socket connection to #{host}:#{port}/#{url.path}?#{url.query}"
+                  logger.debug { "Connection: Opening socket connection to #{host}:#{port}/#{url.path}?#{url.query}" }
                   @transport = create_transport(host, port, url) do |websocket_transport|
                     websocket_deferrable.succeed websocket_transport
                   end
@@ -451,7 +484,7 @@ module Ably
 
       # Executes registered callbacks for a successful connection resume event
       # @api private
-      def resumed
+      def trigger_resumed
         resume_callbacks.each(&:call)
       end
 
@@ -490,6 +523,33 @@ module Ably
         @connection_state_ttl = val
       end
 
+      # @api private
+      def heartbeat_interval
+        # See RTN23a
+        (details && details.max_idle_interval).to_i +
+          defaults.fetch(:realtime_request_timeout)
+      end
+
+      # Resets the client serial (msgSerial) sent to Ably for each new {Ably::Models::ProtocolMessage}
+      # (see #client_serial)
+      # @api private
+      def reset_client_serial
+        @client_serial = -1
+      end
+
+      # When a hearbeat or any other message from Ably is received
+      # we know it's alive, see #RTN23
+      # @api private
+      def set_connection_confirmed_alive
+        @last_liveness_event = Time.now
+        manager.reset_liveness_timer
+      end
+
+      # @api private
+      def time_since_connection_confirmed_alive?
+        Time.now.to_i - @last_liveness_event.to_i
+      end
+
       # As we are using a state machine, do not allow change_state to be used
       # #transition_state_machine must be used instead
       private :change_state
@@ -500,9 +560,8 @@ module Ably
       # Note that this is different to the connection serial that contains the last known serial number
       # received from the server.
       #
-      # A client serial number therefore does not guarantee a message has been received, only sent.
-      # A connection serial guarantees the server has received the message and is thus used for connection
-      # recovery and resumes.
+      # A message serial number does not guarantee a message has been received, only sent.
+      # A connection serial guarantees the server has received the message and is thus used for connection recovery and resumes.
       # @return [Integer] starting at -1 indicating no messages sent, 0 when the first message is sent
       def client_serial
         @client_serial

data/lib/ably/realtime/connection/connection_manager.rb

@@ -12,13 +12,12 @@ module Ably::Realtime
     class ConnectionManager
       # Error codes from the server that can potentially be resolved
       RESOLVABLE_ERROR_CODES = {
-        token_expired: Ably::Rest::Middleware::Exceptions::TOKEN_EXPIRED_CODE
+        token_expired: Ably::Exceptions::TOKEN_EXPIRED_CODE
       }
 
       def initialize(connection)
         @connection     = connection
         @timers         = Hash.new { |hash, key| hash[key] = [] }
-        @renewing_token = false
 
         connection.unsafe_on(:closed) do
           connection.reset_resume_info
@@ -48,7 +47,7 @@ module Ably::Realtime
           return
         end
 
-        logger.debug 'ConnectionManager: Opening a websocket transport connection'
+        logger.debug { 'ConnectionManager: Opening a websocket transport connection' }
 
         connection.create_websocket_transport.tap do |socket_deferrable|
           socket_deferrable.callback do |websocket_transport|
@@ -60,7 +59,7 @@ module Ably::Realtime
           end
         end
 
-        logger.debug "ConnectionManager: Setting up automatic connection timeout timer for #{realtime_request_timeout}s"
+        logger.debug { "ConnectionManager: Setting up automatic connection timeout timer for #{realtime_request_timeout}s" }
         create_timeout_timer_whilst_in_state(:connecting, realtime_request_timeout) do
           connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{realtime_request_timeout}s", nil, 80014)
         end
@@ -70,34 +69,72 @@ module Ably::Realtime
       #
       # @api private
       def connection_opening_failed(error)
-        if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
-          client.connection.transition_state_machine :failed, reason: error
-          return
+        if error.kind_of?(Ably::Exceptions::BaseAblyException)
+          # Authentication errors that indicate the authentication failure is terminal should move to the failed state
+          if ([401, 403].include?(error.status) && !RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)) ||
+             (error.code == Ably::Exceptions::INVALID_CLIENT_ID)
+            connection.transition_state_machine :failed, reason: error
+            return
+          end
         end
 
-        logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
+        logger.warn { "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}" }
         next_state = get_next_retry_state_info
-        connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
+        connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000, error)
       end
 
       # Called whenever a new connection is made
       #
       # @api private
       def connected(protocol_message)
+        # ClientID validity is already checked as part of the incoming message processing
+        client.auth.configure_client_id protocol_message.connection_details.client_id
+
+        # Update the connection details and any associated defaults
+        connection.set_connection_details protocol_message.connection_details
+
         if connection.key
           if protocol_message.connection_id == connection.id
-            logger.debug "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}"
-            EventMachine.next_tick { connection.resumed }
+            logger.debug { "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}" }
+            EventMachine.next_tick { connection.trigger_resumed }
+            resend_pending_message_ack_queue
           else
-            logger.debug "ConnectionManager: Connection was not resumed, old connection ID #{connection.id} has been updated with new connect ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}"
-            detach_attached_channels protocol_message.error
+            logger.debug { "ConnectionManager: Connection was not resumed, old connection ID #{connection.id} has been updated with new connection ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}" }
+            connection.reset_client_serial
+            nack_messages_on_all_channels protocol_message.error
+            force_reattach_on_channels protocol_message.error
           end
         else
-          logger.debug "ConnectionManager: New connection created with ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}"
+          logger.debug { "ConnectionManager: New connection created with ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}" }
+          connection.reset_client_serial
         end
+
+        reattach_suspended_channels protocol_message.error
+
         connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
       end
 
+      # When connection is CONNECTED and receives an update
+      # Update the Connection details and emit an UPDATE event #RTN4h
+      def connected_update(protocol_message)
+        # ClientID validity is already checked as part of the incoming message processing
+        client.auth.configure_client_id protocol_message.connection_details.client_id
+
+        # Update the connection details and any associated defaults
+        connection.set_connection_details protocol_message.connection_details
+
+        connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
+
+        state_change = Ably::Models::ConnectionStateChange.new(
+          current: connection.state,
+          previous: connection.state,
+          event: Ably::Realtime::Connection::EVENT(:update),
+          reason: protocol_message.error,
+          protocol_message: protocol_message
+        )
+        connection.emit :update, state_change
+      end
+
       # Ensures the underlying transport has been disconnected and all event emitter callbacks removed
       #
       # @api private
@@ -109,6 +146,12 @@ module Ably::Realtime
         end
       end
 
+      # @api private
+      def release_and_establish_new_transport
+        destroy_transport
+        setup_transport
+      end
+
       # Reconnect the {Ably::Realtime::Connection::WebsocketTransport} if possible, otherwise set up a new transport
       #
       # @api private
@@ -143,9 +186,12 @@ module Ably::Realtime
       #
       # @api private
       def fail(error)
-        connection.logger.fatal "ConnectionManager: Connection failed - #{error}"
-        connection.manager.destroy_transport
-        connection.unsafe_once(:failed) { connection.emit :error, error }
+        connection.logger.fatal { "ConnectionManager: Connection failed - #{error}" }
+        destroy_transport
+        channels.each do |channel|
+          next if channel.detached? || channel.initialized?
+          channel.transition_state_machine :failed, reason: error if channel.can_transition_to?(:failed)
+        end
       end
 
       # When a connection is disconnected whilst connecting, attempt reconnect and/or set state to :suspended or :failed
@@ -153,12 +199,12 @@ module Ably::Realtime
       # @api private
       def respond_to_transport_disconnected_when_connecting(error)
         return unless connection.disconnected? || connection.suspended? # do nothing if state has changed through an explicit request
-        return unless can_retry_connection? # do not always reattempt connection or change state as client may be re-authorising
+        return if currently_renewing_token? # do not always reattempt connection or change state as client may be re-authorising
 
         if error.kind_of?(Ably::Models::ErrorInfo)
           if RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)
-            next_state = get_next_retry_state_info
-            logger.debug "ConnectionManager: Transport disconnected because of token expiry, pausing #{next_state.fetch(:pause)}s before reattempting to connect"
+            next_state = get_next_retry_state_info(1)
+            logger.debug { "ConnectionManager: Transport disconnected because of token expiry, pausing #{next_state.fetch(:pause)}s before reattempting to connect" }
             EventMachine.add_timer(next_state.fetch(:pause)) { renew_token_and_reconnect error }
             return
           end
@@ -179,14 +225,13 @@ module Ably::Realtime
       # @api private
       def respond_to_transport_disconnected_whilst_connected(error)
         unless connection.disconnected? || connection.suspended?
-          logger.warn "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly"
+          logger.warn { "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly" }
         else
-          logger.debug "ConnectionManager: Transport disconnected whilst connection in #{connection.state} state"
+          logger.debug { "ConnectionManager: Transport disconnected whilst connection in #{connection.state} state" }
         end
 
         if error.kind_of?(Ably::Models::ErrorInfo) && !RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)
-          connection.emit :error, error
-          logger.error "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}"
+          logger.error { "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}" }
         end
 
         destroy_transport
@@ -200,10 +245,10 @@ module Ably::Realtime
       def error_received_from_server(error)
         case error.code
         when RESOLVABLE_ERROR_CODES.fetch(:token_expired)
-          next_state = get_next_retry_state_info
+          next_state = get_next_retry_state_info(1)
           connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: error
         else
-          logger.error "ConnectionManager: Error #{error.class.name} code #{error.code} received from server '#{error.message}', transitioning to failed state"
+          logger.error { "ConnectionManager: Error #{error.class.name} code #{error.code} received from server '#{error.message}', transitioning to failed state" }
           connection.transition_state_machine :failed, reason: error
         end
       end
@@ -215,6 +260,71 @@ module Ably::Realtime
         retries_for_state(state, ignore_states: [:connecting]).count
       end
 
+      # Any message sent before an ACK/NACK was received on the previous transport
+      # need to be resent to the Ably service so that a subsequent ACK/NACK is received.
+      # It is up to Ably to ensure that duplicate messages are not retransmitted on the channel
+      # base on the serial numbers
+      #
+      # @api private
+      def resend_pending_message_ack_queue
+        connection.__pending_message_ack_queue__.delete_if do |protocol_message|
+          if protocol_message.ack_required?
+            connection.__outgoing_message_queue__ << protocol_message
+            connection.__outgoing_protocol_msgbus__.publish :protocol_message
+            true
+          end
+        end
+      end
+
+      # @api private
+      def suspend_active_channels(error)
+        channels.select do |channel|
+          channel.attached? || channel.attaching? || channel.detaching?
+        end.each do |channel|
+          channel.transition_state_machine! :suspended, reason: error
+        end
+      end
+
+      # @api private
+      def detach_active_channels
+        channels.select do |channel|
+          channel.attached? || channel.attaching? || channel.detaching?
+        end.each do |channel|
+          channel.transition_state_machine! :detaching # will always move to detached immediately if connection is closed
+        end
+      end
+
+      # @api private
+      def fail_active_channels(error)
+        channels.select do |channel|
+          channel.attached? || channel.attaching? || channel.detaching? || channel.suspended?
+        end.each do |channel|
+          channel.transition_state_machine! :failed, reason: error
+        end
+      end
+
+      # When continuity on a connection is lost all messages
+      # whether queued or awaiting an ACK must be NACK'd as we now have a new connection
+      def nack_messages_on_all_channels(error)
+        channels.each do |channel|
+          channel.manager.fail_messages_awaiting_ack error, immediately: true
+          channel.manager.fail_queued_messages error
+        end
+      end
+
+      # Liveness timer ensures a connection that has not heard from Ably in heartbeat_interval
+      # is moved to the disconnected state automatically
+      def reset_liveness_timer
+        @liveness_timer.cancel if @liveness_timer
+        @liveness_timer = EventMachine::Timer.new(connection.heartbeat_interval + 0.1) do
+          if connection.connected? && (connection.time_since_connection_confirmed_alive? >= connection.heartbeat_interval)
+            msg = "No activity seen from realtime in #{connection.heartbeat_interval}; assuming connection has dropped";
+            error = Ably::Exceptions::ConnectionTimeout.new(msg, 80003, 408)
+            connection.transition_state_machine! :disconnected, reason: error
+          end
+        end
+      end
+
       private
       def connection
         @connection
@@ -265,7 +375,7 @@ module Ably::Realtime
         timers.fetch(key, []).each(&:cancel)
       end
 
-      def get_next_retry_state_info
+      def get_next_retry_state_info(allow_extra_immediate_retries = 0)
         retry_state = if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
           :suspended
         else
@@ -273,14 +383,14 @@ module Ably::Realtime
         end
         {
           state: retry_state,
-          pause: next_retry_pause(retry_state)
+          pause: next_retry_pause(retry_state, allow_extra_immediate_retries)
         }
       end
 
-      def next_retry_pause(retry_state)
+      def next_retry_pause(retry_state, allow_extra_immediate_retries = 0)
         return nil unless state_has_retry_timeout?(retry_state)
 
-        if retries_for_state(retry_state, ignore_states: [:connecting]).empty?
+        if retries_for_state(retry_state, ignore_states: [:connecting]).count <= allow_extra_immediate_retries
           0
         else
           retry_timeout_for(retry_state)
@@ -302,10 +412,10 @@ module Ably::Realtime
       def connection_retry_for(from_state)
         if can_reattempt_connect_for_state?(from_state)
           if connection.state == :disconnected && retries_for_state(from_state, ignore_states: [:connecting]).empty?
-            logger.debug "ConnectionManager: Will attempt reconnect immediately as no previous reconnect attempts made in state #{from_state}"
+            logger.debug { "ConnectionManager: Will attempt reconnect immediately as no previous reconnect attempts made in state #{from_state}" }
             EventMachine.next_tick { connection.connect }
           else
-            logger.debug "ConnectionManager: Pausing for #{retry_timeout_for(from_state)}s before attempting to reconnect"
+            logger.debug { "ConnectionManager: Pausing for #{retry_timeout_for(from_state)}s before attempting to reconnect" }
             create_timeout_timer_whilst_in_state(from_state, retry_timeout_for(from_state)) do
               connection.connect if connection.state == from_state
             end
@@ -380,7 +490,7 @@ module Ably::Realtime
         transport.unsafe_on(:disconnected) do |reason|
           if connection.closing?
             connection.transition_state_machine :closed
-          elsif !connection.closed? && !connection.disconnected?
+          elsif !connection.closed? && !connection.disconnected? && !connection.failed? && !connection.suspended?
             exception = if reason
               Ably::Exceptions::TransportClosed.new(reason, nil, 80003)
             else
@@ -394,35 +504,21 @@ module Ably::Realtime
 
       def renew_token_and_reconnect(error)
         if client.auth.token_renewable?
-          if @renewing_token
-            logger.error 'ConnectionManager: Attempting to renew token whilst another token renewal is underway. Aborting current renew token request'
+          if currently_renewing_token?
+            logger.error { 'ConnectionManager: Attempting to renew token whilst another token renewal is underway. Aborting current renew token request' }
             return
           end
 
-          @renewing_token = true
-          logger.info "ConnectionManager: Token has expired and is renewable, renewing token now"
-
-          client.auth.authorise(nil, force: true).tap do |authorise_deferrable|
-            authorise_deferrable.callback do |token_details|
-              logger.info 'ConnectionManager: Token renewed succesfully following expiration'
-
-              connection.once_state_changed { @renewing_token = false }
+          logger.info { "ConnectionManager: Token has expired and is renewable, renewing token now" }
 
-              if token_details && !token_details.expired?
-                connection.connect
-              else
-                connection.transition_state_machine :failed, reason: error unless connection.failed?
-              end
-            end
-
-            authorise_deferrable.errback do |auth_error|
-              @renewing_token = false
-              logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
-              connection.transition_state_machine :failed, reason: auth_error
+          # Authorize implicitly reconnects, see #RTC8
+          client.auth.authorize.tap do |authorize_deferrable|
+            authorize_deferrable.callback do |token_details|
+              logger.info { 'ConnectionManager: Token renewed succesfully following expiration' }
             end
           end
         else
-          logger.error "ConnectionManager: Token has expired and is not renewable - #{error}"
+          logger.error { "ConnectionManager: Token has expired and is not renewable - #{error}" }
           connection.transition_state_machine :failed, reason: error
         end
       end
@@ -430,7 +526,7 @@ module Ably::Realtime
       def unsubscribe_from_transport_events(transport)
         transport.__incoming_protocol_msgbus__.unsubscribe
         transport.off
-        logger.debug "ConnectionManager: Unsubscribed from all events from current transport"
+        logger.debug { "ConnectionManager: Unsubscribed from all events from current transport" }
       end
 
       def close_connection_when_reactor_is_stopped
@@ -439,16 +535,26 @@ module Ably::Realtime
         end
       end
 
-      def can_retry_connection?
-        !@renewing_token
+      def currently_renewing_token?
+        client.auth.authorization_in_flight?
+      end
+
+      def reattach_suspended_channels(error)
+        channels.select do |channel|
+          channel.suspended?
+        end.each do |channel|
+          channel.transition_state_machine :attaching
+        end
       end
 
-      def detach_attached_channels(error)
+      # When continuity on a connection is lost all messages
+      # Channels in the ATTACHED or ATTACHING state should explicitly be re-attached
+      # by sending a new ATTACH to Ably
+      def force_reattach_on_channels(error)
         channels.select do |channel|
           channel.attached? || channel.attaching?
         end.each do |channel|
-          logger.warn "Force detaching channel '#{channel.name}': #{error}"
-          channel.manager.suspend error
+          channel.manager.request_reattach reason: error
         end
       end