ably-rest 0.9.3 → 1.0.0

data/lib/submodules/ably-ruby/lib/ably/modules/state_emitter.rb

@@ -4,7 +4,8 @@ module Ably::Modules
   # module, and the class is an {EventEmitter}.  It then emits state changes.
   #
   # It also ensures the EventEmitter is configured to retrict permitted events to the
-  # the available STATEs and :error.
+  # the available STATEs or EVENTs if defined i.e. if EVENTs includes an additional type such as
+  # :update, then it will support all EVENTs being emitted. EVENTs must be a superset of STATEs
   #
   # @note This module requires that the method #logger is defined.
   #
@@ -51,7 +52,7 @@ module Ably::Modules
     # @api private
     def state=(new_state, *args)
       if state != new_state
-        logger.debug("#{self.class}: StateEmitter changed from #{state} => #{new_state}") if respond_to?(:logger, true)
+        logger.debug { "#{self.class}: StateEmitter changed from #{state} => #{new_state}" } if respond_to?(:logger, true)
         @state = STATE(new_state)
         emit @state, *args
       end
@@ -153,8 +154,10 @@ module Ably::Modules
 
     def self.included(klass)
       klass.configure_event_emitter coerce_into: Proc.new { |event|
-        if event == :error
-          :error
+        # Special case allows EVENT instead of STATE to be emitted
+        # Relies on the assumption that EVENT is a superset of STATE
+        if klass.const_defined?(:EVENT)
+          klass::EVENT(event)
         else
           klass::STATE(event)
         end

data/lib/submodules/ably-ruby/lib/ably/modules/state_machine.rb

@@ -18,14 +18,12 @@ module Ably::Modules
 
     # Alternative to Statesman's #transition_to that:
     # * log state change failures to {Logger}
-    # * raise an exception on the {Ably::Realtime::Channel}
     #
     # @return [void]
     def transition_state(state, *args)
-      unless result = transition_to(state, *args)
+      unless result = transition_to(state.to_sym, *args)
         exception = exception_for_state_change_to(state)
-        object.emit :error, exception
-        logger.fatal "#{self.class}: #{exception.message}"
+        logger.fatal { "#{self.class}: #{exception.message}" }
       end
       result
     end

data/lib/submodules/ably-ruby/lib/ably/modules/uses_state_machine.rb

@@ -67,15 +67,19 @@ module Ably::Modules
 
     def log_state_machine_state_change
       if state_machine.previous_state
-        logger.debug "#{self.class.name}: Transitioned from #{state_machine.previous_state} => #{state_machine.current_state}"
+        logger.debug { "#{self.class.name}: Transitioned from #{state_machine.previous_state} => #{state_machine.current_state}" }
       else
-        logger.debug "#{self.class.name}: Transitioned to #{state_machine.current_state}"
+        logger.debug { "#{self.class.name}: Transitioned to #{state_machine.current_state}" }
       end
     end
 
     def emit_object(new_state, emit_params)
       if self.class.emits_klass
-        self.class.emits_klass.new((emit_params || {}).merge(current: STATE(new_state), previous: STATE(state_machine.current_state)))
+        self.class.emits_klass.new((emit_params || {}).merge(
+          current: STATE(new_state),
+          previous: STATE(state_machine.current_state),
+          event: EVENT(new_state)
+        ))
       else
         emit_params
       end

data/lib/submodules/ably-ruby/lib/ably/realtime.rb

@@ -11,6 +11,8 @@ require 'ably/realtime/client'
 require 'ably/realtime/connection'
 require 'ably/realtime/presence'
 
+require 'ably/models/message_encoders/base'
+
 Dir.glob(File.expand_path("models/*.rb", File.dirname(__FILE__))).each do |file|
   require file
 end

data/lib/submodules/ably-ruby/lib/ably/realtime/auth.rb

@@ -44,13 +44,15 @@ module Ably
       def_delegators :auth_sync, :using_basic_auth?, :using_token_auth?
       def_delegators :auth_sync, :token_renewable?, :authentication_security_requirements_met?
       def_delegators :client, :logger
+      def_delegators :client, :connection
 
       def initialize(client)
         @client = client
         @auth_sync = client.rest_client.auth
       end
 
-      # Ensures valid auth credentials are present for the library instance. This may rely on an already-known and valid token, and will obtain a new token if necessary.
+      # For new connections, ensures valid auth credentials are present for the library instance. This may rely on an already-known and valid token, and will obtain a new token if necessary.
+      # If a connection is already established, the connection will be upgraded with a new token
       #
       # In the event that a new token request is made, the provided options are used
       #
@@ -68,41 +70,86 @@ module Ably
       #    end
       #
       def authorize(token_params = nil, auth_options = nil, &success_callback)
-        async_wrap(success_callback) do
-          auth_sync.authorize(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
-        end.tap do |deferrable|
-          deferrable.errback do |error|
-            client.connection.transition_state_machine :failed, reason: error if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
+        Ably::Util::SafeDeferrable.new(logger).tap do |authorize_method_deferrable|
+          # Wrap the sync authorize method and wait for the result from the deferrable
+          async_wrap do
+            authorize_sync(token_params, auth_options)
+          end.tap do |auth_operation|
+            # Authorize operation succeeded and we have a new token, now let's perform inline authentication
+            auth_operation.callback do |token|
+              case connection.state.to_sym
+              when :initialized, :disconnected, :suspended, :closed, :closing, :failed
+                connection.connect
+              when :connected
+                perform_inline_auth token
+              when :connecting
+                # Fail all current connection attempts and try again with the new token, see #RTC8b
+                connection.manager.release_and_establish_new_transport
+              else
+                logger.fatal { "Auth#authorize: unsupported state #{connection.state}" }
+                authorize_method_deferrable.fail Ably::Exceptions::InvalidState.new("Unsupported state #{connection.state} for Auth#authorize")
+                next
+              end
+
+              # Indicate success or failure based on response from realtime, see #RTC8b1
+              auth_deferrable_resolved = false
+
+              connection.unsafe_once(:connected, :update) do
+                auth_deferrable_resolved = true
+                authorize_method_deferrable.succeed token
+              end
+              connection.unsafe_once(:suspended, :closed, :failed) do |state_change|
+                auth_deferrable_resolved = true
+                authorize_method_deferrable.fail state_change.reason
+              end
+            end
+
+            # Authorize failed, likely due to auth_url or auth_callback failing
+            auth_operation.errback do |error|
+              client.connection.transition_state_machine :failed, reason: error if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
+              authorize_method_deferrable.fail error
+            end
+          end
+
+          # Call the block provided to this method upon success of this deferrable
+          authorize_method_deferrable.callback do |token|
+            yield token if block_given?
           end
         end
       end
 
       # @deprecated Use {#authorize} instead
       def authorise(*args, &block)
-        logger.warn "Auth#authorise is deprecated and will be removed in 1.0. Please use Auth#authorize instead"
+        logger.warn { "Auth#authorise is deprecated and will be removed in 1.0. Please use Auth#authorize instead" }
         authorize(*args, &block)
       end
 
       # Synchronous version of {#authorize}. See {Ably::Auth#authorize} for method definition
+      # Please note that authorize_sync will however not upgrade the current connection's token as this requires
+      # an synchronous operation to send the new authentication details to Ably over a realtime connection
+      #
       # @param (see Ably::Auth#authorize)
       # @option (see Ably::Auth#authorize)
       # @return [Ably::Models::TokenDetails]
       #
       def authorize_sync(token_params = nil, auth_options = nil)
-        auth_sync.authorize(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
+        @authorization_in_flight = true
+        auth_sync.authorize(token_params, auth_options)
+      ensure
+        @authorization_in_flight = false
+      end
+
+      # @api private
+      def authorization_in_flight?
+        @authorization_in_flight
       end
 
       # @deprecated Use {#authorize_sync} instead
       def authorise_sync(*args)
-        logger.warn "Auth#authorise_sync is deprecated and will be removed in 1.0. Please use Auth#authorize_sync instead"
+        logger.warn { "Auth#authorise_sync is deprecated and will be removed in 1.0. Please use Auth#authorize_sync instead" }
         authorize_sync(*args)
       end
 
-      # def_delegator :auth_sync, :request_token, :request_token_sync
-      # def_delegator :auth_sync, :create_token_request, :create_token_request_sync
-      # def_delegator :auth_sync, :auth_header, :auth_header_sync
-      # def_delegator :auth_sync, :auth_params, :auth_params_sync
-
       # Request a {Ably::Models::TokenDetails} which can be used to make authenticated token based requests
       #
       # @param (see Ably::Auth#request_token)
@@ -186,7 +233,16 @@ module Ably
       # @yield [Hash] Auth params for a new Realtime connection
       #
       def auth_params(&success_callback)
-        async_wrap(success_callback) do
+        fail_callback = Proc.new do |error, deferrable|
+          logger.error { "Failed to authenticate: #{error}" }
+          if error.kind_of?(Ably::Exceptions::BaseAblyException)
+            # Use base exception if it exists carrying forward the status codes
+            deferrable.fail Ably::Exceptions::AuthenticationFailed.new(error.message, nil, nil, error)
+          else
+            deferrable.fail Ably::Exceptions::AuthenticationFailed.new(error.message, 500, 80019)
+          end
+        end
+        async_wrap(success_callback, fail_callback) do
           auth_params_sync
         end
       end
@@ -209,22 +265,14 @@ module Ably
         @client
       end
 
-      # If authorize is called with true, this block is executed so that it
-      # can perform the authentication upgrade
-      def upgrade_authentication_block(new_token)
-        # This block is called if the authorisation was forced
-        if client.connection.connected? || client.connection.connecting?
-          logger.debug "Realtime::Auth - authorize was called so forcibly disconnecting transport to initiate auth upgrade"
-          block = Proc.new do
-            if client.connection.transport
-              logger.debug "Realtime::Auth - current transport disconnected"
-              client.connection.transport.disconnect
-            else
-              EventMachine.add_timer(0.1, &block)
-            end
-          end
-          block.call
-        end
+      # Sends an AUTH ProtocolMessage on the existing connection triggering
+      # an inline AUTH process, see #RTC8a
+      def perform_inline_auth(token)
+        logger.debug { "Performing inline AUTH with Ably using token #{token}" }
+        connection.send_protocol_message(
+          action: Ably::Models::ProtocolMessage::ACTION.Auth.to_i,
+          auth: { access_token: token.token }
+        )
       end
     end
   end

data/lib/submodules/ably-ruby/lib/ably/realtime/channel.rb

@@ -23,8 +23,6 @@ module Ably
     #   Channel::STATE.Detached
     #   Channel::STATE.Failed
     #
-    # Channels emit errors - use +on(:error)+ to subscribe to errors
-    #
     # @!attribute [r] state
     #   @return {Ably::Realtime::Connection::STATE} channel state
     #
@@ -36,14 +34,24 @@ module Ably
       include Ably::Modules::MessageEmitter
       extend Ably::Modules::Enum
 
+      # ChannelState
+      # The permited states for this channel
       STATE = ruby_enum('STATE',
         :initialized,
         :attaching,
         :attached,
         :detaching,
         :detached,
+        :suspended,
         :failed
       )
+
+      # ChannelEvent
+      # The permitted channel events that are emitted for this channel
+      EVENT = ruby_enum('EVENT',
+        STATE.to_sym_arr + [:update]
+      )
+
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
       ensure_state_machine_emits 'Ably::Models::ChannelStateChange'
@@ -138,11 +146,14 @@ module Ably
       #   end
       #
       def publish(name, data = nil, attributes = {}, &success_block)
-        raise Ably::Exceptions::ChannelInactive.new('Cannot publish messages on a detached channel') if detached? || detaching?
-        raise Ably::Exceptions::ChannelInactive.new('Cannot publish messages on a failed channel') if failed?
+        if detached? || detaching? || failed?
+          error = Ably::Exceptions::ChannelInactive.new("Cannot publish messages on a channel in state #{state}")
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+        end
 
         if !connection.can_publish_messages?
-          raise Ably::Exceptions::MessageQueueingDisabled.new("Message cannot be published. Client is configured to disallow queueing of messages and connection is currently #{connection.state}")
+          error = Ably::Exceptions::MessageQueueingDisabled.new("Message cannot be published. Client is configured to disallow queueing of messages and connection is currently #{connection.state}")
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
         end
 
         messages = if name.kind_of?(Enumerable)
@@ -192,10 +203,19 @@ module Ably
       #
       def attach(&success_block)
         if connection.closing? || connection.closed? || connection.suspended? || connection.failed?
-          raise Ably::Exceptions::InvalidStateChange.new("Cannot ATTACH channel when the connection is in a closed, suspended or failed state. Connection state: #{connection.state}")
+          error = Ably::Exceptions::InvalidStateChange.new("Cannot ATTACH channel when the connection is in a closed, suspended or failed state. Connection state: #{connection.state}")
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+        end
+
+        if !attached?
+          if detaching?
+            # Let the pending operation complete (#RTL4h)
+            once_state_changed { transition_state_machine :attaching if can_transition_to?(:attaching) }
+          else
+            transition_state_machine :attaching if can_transition_to?(:attaching)
+          end
         end
 
-        transition_state_machine :attaching if can_transition_to?(:attaching)
         deferrable_for_state_change_to(STATE.Attached, &success_block)
       end
 
@@ -207,14 +227,24 @@ module Ably
       def detach(&success_block)
         if initialized?
           success_block.call if block_given?
-          return Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
-            EventMachine.next_tick { deferrable.succeed }
-          end
+          return Ably::Util::SafeDeferrable.new_and_succeed_immediately(logger)
+        end
+
+        if failed? || connection.closing? || connection.failed?
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:detaching))
         end
 
-        raise exception_for_state_change_to(:detaching) if failed?
+        if !detached?
+          if attaching?
+            # Let the pending operation complete (#RTL5i)
+            once_state_changed { transition_state_machine :detaching if can_transition_to?(:detaching) }
+          elsif can_transition_to?(:detaching)
+            transition_state_machine :detaching
+          else
+            transition_state_machine! :detached
+          end
+        end
 
-        transition_state_machine :detaching if can_transition_to?(:detaching)
         deferrable_for_state_change_to(STATE.Detached, &success_block)
       end
 
@@ -244,7 +274,10 @@ module Ably
       #
       def history(options = {}, &callback)
         if options.delete(:until_attach)
-          raise ArgumentError, 'option :until_attach is invalid as the channel is not attached' unless attached?
+          unless attached?
+            error = Ably::Exceptions::InvalidRequest.new('option :until_attach is invalid as the channel is not attached' )
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
           options[:from_serial] = attached_serial
         end
 
@@ -263,7 +296,7 @@ module Ably
       end
 
       # @api private
-      def set_failed_channel_error_reason(error)
+      def set_channel_error_reason(error)
         @error_reason = error
       end
 
@@ -288,25 +321,26 @@ module Ably
         client.logger
       end
 
+      # Internal queue used for messages published that cannot yet be enqueued on the connection
+      # @api private
+      def __queue__
+        @queue
+      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
 
       private
-      def queue
-        @queue
-      end
-
       def setup_event_handlers
         __incoming_msgbus__.subscribe(:message) do |message|
           message.decode(client.encoders, options) do |encode_error, error_message|
             client.logger.error error_message
-            emit :error, encode_error
           end
           emit_message message.name, message
         end
 
-        on(STATE.Attached) do
+        unsafe_on(STATE.Attached) do
           process_queue
         end
       end
@@ -319,15 +353,18 @@ module Ably
           create_message(raw_msg).tap do |message|
             next if message.client_id.nil?
             if message.client_id == '*'
-              raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages', 400, 40012)
+              raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages')
+            end
+            if message.client_id && !message.client_id.kind_of?(String)
+              raise Ably::Exceptions::IncompatibleClientId.new('client_id must be a String when publishing messages')
             end
             unless client.auth.can_assume_client_id?(message.client_id)
-              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
+              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'")
             end
           end
         end
 
-        queue.push(*messages)
+        __queue__.push(*messages)
 
         if attached?
           process_queue
@@ -369,14 +406,14 @@ module Ably
       end
 
       def messages_in_queue?
-        !queue.empty?
+        !__queue__.empty?
       end
 
       # Move messages from Channel Queue into Outgoing Connection Queue
       def process_queue
         condition = -> { attached? && messages_in_queue? }
         non_blocking_loop_while(condition) do
-          send_messages_within_protocol_message queue.shift(MAX_PROTOCOL_MESSAGE_BATCH_SIZE)
+          send_messages_within_protocol_message __queue__.shift(MAX_PROTOCOL_MESSAGE_BATCH_SIZE)
         end
       end
 
@@ -392,7 +429,6 @@ module Ably
         Ably::Models::Message(message.dup).tap do |msg|
           msg.encode(client.encoders, options) do |encode_error, error_message|
             client.logger.error error_message
-            emit :error, encode_error
           end
         end
       end

data/lib/submodules/ably-ruby/lib/ably/realtime/channel/channel_manager.rb

@@ -12,8 +12,6 @@ module Ably::Realtime
       def initialize(channel, connection)
         @channel    = channel
         @connection = connection
-
-        setup_connection_event_handlers
       end
 
       # Commence attachment
@@ -25,64 +23,130 @@ module Ably::Realtime
       end
 
       # Commence attachment
-      def detach(error = nil)
+      def detach(error, previous_state)
         if connection.closed? || connection.connecting? || connection.suspended?
           channel.transition_state_machine :detached, reason: error
         elsif can_transition_to?(:detached)
-          send_detach_protocol_message
+          send_detach_protocol_message previous_state
         end
       end
 
       # Channel is attached, notify presence if sync is expected
       def attached(attached_protocol_message)
-        if attached_protocol_message.has_presence_flag?
-          channel.presence.manager.sync_expected
-        else
-          channel.presence.manager.sync_not_expected
+        # If no attached ProtocolMessage then this attached request was triggered by the client
+        # library, such as returning to attached whne detach has failed
+        if attached_protocol_message
+          update_presence_sync_state_following_attached attached_protocol_message
+          channel.set_attached_serial attached_protocol_message.channel_serial
         end
-        channel.set_attached_serial attached_protocol_message.channel_serial
       end
 
       # An error has occurred on the channel
-      def emit_error(error)
-        logger.error "ChannelManager: Channel '#{channel.name}' error: #{error}"
-        channel.emit :error, error
+      def log_channel_error(error)
+        logger.error { "ChannelManager: Channel '#{channel.name}' error: #{error}" }
       end
 
-      # Detach a channel as a result of an error
-      def suspend(error)
-        channel.transition_state_machine! :detaching, reason: error
+      # Request channel to be reattached by sending an attach protocol message
+      # @param [Hash] options
+      # @option options [Ably::Models::ErrorInfo]  :reason
+      def request_reattach(options = {})
+        reason = options[:reason]
+        send_attach_protocol_message
+        logger.debug { "Explicit channel reattach request sent to Ably due to #{reason}" }
+        channel.set_channel_error_reason(reason) if reason
+        channel.transition_state_machine! :attaching, reason: reason unless channel.attaching?
       end
 
-      # When a channel is no longer attached or has failed,
-      # all messages awaiting an ACK response should fail immediately
-      def fail_messages_awaiting_ack(error)
-        # Allow a short time for other queued operations to complete before failing all messages
-        EventMachine.add_timer(0.1) do
-          error = Ably::Exceptions::MessageDeliveryFailed.new("Channel cannot publish messages whilst state is '#{channel.state}'") unless error
+      def duplicate_attached_received(protocol_message)
+        if protocol_message.error
+          channel.set_channel_error_reason protocol_message.error
+          log_channel_error protocol_message.error
+        end
+
+        if protocol_message.has_channel_resumed_flag?
+          logger.debug { "ChannelManager: Additional resumed ATTACHED message received for #{channel.state} channel '#{channel.name}'" }
+        else
+          channel.emit :update, Ably::Models::ChannelStateChange.new(
+            current: channel.state,
+            previous: channel.state,
+            event: Ably::Realtime::Channel::EVENT(:update),
+            reason: protocol_message.error,
+            resumed: false,
+          )
+          update_presence_sync_state_following_attached protocol_message
+        end
+
+        channel.set_attached_serial protocol_message.channel_serial
+      end
+
+      # Handle DETACED messages, see #RTL13 for server-initated detaches
+      def detached_received(reason)
+        case channel.state.to_sym
+        when :detaching
+          channel.transition_state_machine :detached, reason: reason
+        when :attached, :suspended
+          channel.transition_state_machine :attaching, reason: reason
+        else
+          logger.debug { "ChannelManager: DETACHED ProtocolMessage received, but no action to take as not DETACHING, ATTACHED OR SUSPENDED" }
+        end
+      end
+
+      # When continuity on the connection is interrupted or channel becomes suspended (implying loss of continuity)
+      # then all messages published but awaiting an ACK from Ably should be failed with a NACK
+      # @param [Hash] options
+      # @option options [Boolean]  :immediately
+      def fail_messages_awaiting_ack(error, options = {})
+        immediately = options[:immediately] || false
+
+        fail_proc = Proc.new do
+          error = Ably::Exceptions::MessageDeliveryFailed.new("Continuity of connection was lost so published messages awaiting ACK have failed") unless error
           fail_messages_in_queue connection.__pending_message_ack_queue__, error
-          fail_messages_in_queue connection.__outgoing_message_queue__, error
         end
+
+        # Allow a short time for other queued operations to complete before failing all messages
+        if immediately
+          fail_proc.call
+        else
+          EventMachine.add_timer(0.1) { fail_proc.call }
+        end
+      end
+
+      # When a channel becomes detached, suspended or failed,
+      # all queued messages should be failed immediately as we don't queue in
+      # any of those states
+      def fail_queued_messages(error)
+        error = Ably::Exceptions::MessageDeliveryFailed.new("Queued messages on channel '#{channel.name}' in state '#{channel.state}' will never be delivered") unless error
+        fail_messages_in_queue connection.__outgoing_message_queue__, error
+        channel.__queue__.each do |message|
+          nack_message message, error
+        end
+        channel.__queue__.clear
       end
 
       def fail_messages_in_queue(queue, error)
         queue.delete_if do |protocol_message|
-          if protocol_message.channel == channel.name
-            nack_messages protocol_message, error
-            true
+          if protocol_message.action.match_any?(:presence, :message)
+            if protocol_message.channel == channel.name
+              nack_messages protocol_message, error
+              true
+            end
           end
         end
       end
 
       def nack_messages(protocol_message, error)
         (protocol_message.messages + protocol_message.presence).each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
-          message.fail error
+          nack_message message, error, protocol_message
         end
-        logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}"
+        logger.debug { "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}" }
         protocol_message.fail error
       end
 
+      def nack_message(message, error, protocol_message = nil)
+        logger.debug { "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json} #{"protocol message: #{protocol_message}" if protocol_message}" }
+        message.fail error
+      end
+
       def drop_pending_queue_from_ack(ack_protocol_message)
         message_serial_up_to = ack_protocol_message.message_serial + ack_protocol_message.count - 1
         connection.__pending_message_ack_queue__.drop_while do |protocol_message|
@@ -93,7 +157,23 @@ module Ably::Realtime
         end
       end
 
+      # If the connection is still connected and the channel still suspended after
+      # channel_retry_timeout has passed, then attempt to reattach automatically, see #RTL13b
+      def start_attach_from_suspended_timer
+        cancel_attach_from_suspended_timer
+        if connection.connected?
+          channel.unsafe_once { |event| cancel_attach_from_suspended_timer unless event == :update }
+          connection.unsafe_once { |event| cancel_attach_from_suspended_timer unless event == :update }
+
+          @attach_from_suspended_timer = EventMachine::Timer.new(channel_retry_timeout) do
+            channel.transition_state_machine! :attaching
+          end
+        end
+      end
+
       private
+      attr_reader :pending_state_change_timer
+
       def channel
         @channel
       end
@@ -104,63 +184,72 @@ module Ably::Realtime
 
       def_delegators :channel, :can_transition_to?
 
+      def cancel_attach_from_suspended_timer
+        @attach_from_suspended_timer.cancel if @attach_from_suspended_timer
+        @attach_from_suspended_timer = nil
+      end
+
       # If the connection has not previously connected, connect now
       def connect_if_connection_initialized
         connection.connect if connection.initialized?
       end
 
-      def send_attach_protocol_message
-        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Attach
+      def realtime_request_timeout
+        connection.defaults.fetch(:realtime_request_timeout)
       end
 
-      def send_detach_protocol_message
-        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Detach
+      def channel_retry_timeout
+        connection.defaults.fetch(:channel_retry_timeout)
       end
 
-      def send_state_change_protocol_message(state)
-        connection.send_protocol_message(
-          action:  state.to_i,
-          channel: channel.name
-        )
+      def send_attach_protocol_message
+        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Attach, :suspended # move to suspended
       end
 
-      # Any message sent before an ACK/NACK was received on the previous transport
-      # needs 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
-      #
-      # TODO: Move this into the Connection class, it does not belong in a Channel class
-      #
-      # @api private
-      def resend_pending_message_ack_queue
-        connection.__pending_message_ack_queue__.delete_if do |protocol_message|
-          if protocol_message.channel == channel.name
-            connection.__outgoing_message_queue__ << protocol_message
-            connection.__outgoing_protocol_msgbus__.publish :protocol_message
-            true
-          end
-        end
+      def send_detach_protocol_message(previous_state)
+        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Detach, previous_state # return to previous state if failed
       end
 
-      def setup_connection_event_handlers
-        connection.unsafe_on(:closed) do
-          channel.transition_state_machine :detaching if can_transition_to?(:detaching)
+      def send_state_change_protocol_message(new_state, state_if_failed)
+        state_at_time_of_request = channel.state
+        @pending_state_change_timer = EventMachine::Timer.new(realtime_request_timeout) do
+          if channel.state == state_at_time_of_request
+            error = Ably::Models::ErrorInfo.new(code: 90007, message: "Channel #{new_state} operation failed (timed out)")
+            channel.transition_state_machine state_if_failed, reason: error
+          end
         end
 
-        connection.unsafe_on(:suspended) do |error|
-          if can_transition_to?(:detaching)
-            channel.transition_state_machine :detaching, reason: Ably::Exceptions::ConnectionSuspended.new('Connection suspended', nil, 80002, error)
-          end
+        channel.once_state_changed do
+          @pending_state_change_timer.cancel if @pending_state_change_timer
+          @pending_state_change_timer = nil
         end
 
-        connection.unsafe_on(:failed) do |error|
-          if can_transition_to?(:failed) && !channel.detached?
-            channel.transition_state_machine :failed, reason: Ably::Exceptions::ConnectionFailed.new('Connection failed', nil, 80002, error)
+        resend_if_disconnected_and_connected = Proc.new do
+          connection.unsafe_once(:disconnected) do
+            next unless pending_state_change_timer
+            connection.unsafe_once(:connected) do
+              next unless pending_state_change_timer
+              connection.send_protocol_message(
+                action:  new_state.to_i,
+                channel: channel.name
+              )
+              resend_if_disconnected_and_connected.call
+            end
           end
         end
+        resend_if_disconnected_and_connected.call
 
-        connection.unsafe_on(:connected) do |error|
-          resend_pending_message_ack_queue
+        connection.send_protocol_message(
+          action:  new_state.to_i,
+          channel: channel.name
+        )
+      end
+
+      def update_presence_sync_state_following_attached(attached_protocol_message)
+        if attached_protocol_message.has_presence_flag?
+          channel.presence.manager.sync_expected
+        else
+          channel.presence.manager.sync_not_expected
         end
       end