ably 1.2.5 → 1.2.6

data/ably.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-instafail', '~> 1.0'
   spec.add_development_dependency 'bundler', '>= 1.3.0'
   spec.add_development_dependency 'webmock', '~> 3.11'
-  spec.add_development_dependency 'simplecov', '~> 0.21.2'
+  spec.add_development_dependency 'simplecov', '~> 0.22.0'
   spec.add_development_dependency 'simplecov-lcov', '~> 0.8.0'
   spec.add_development_dependency 'parallel_tests', '~> 3.8'
   spec.add_development_dependency 'pry', '~> 0.14.1'

data/lib/ably/auth.rb

@@ -414,13 +414,20 @@ module Ably
     #
     # @return [Hash] headers
     def extra_auth_headers
-      if client_id && using_basic_auth?
-        { 'X-Ably-ClientId' => Base64.urlsafe_encode64(client_id) }
+      if client_id_for_request
+        { 'X-Ably-ClientId' => Base64.urlsafe_encode64(client_id_for_request) }
       else
         {}
       end
     end
 
+    # ClientId that needs to be included with every rest/realtime request
+    # spec - RSA7e
+    # @return string
+    def client_id_for_request
+      options[:client_id]
+    end
+
     # Auth params used in URI endpoint for Realtime connections
     # Will reauthorize implicitly if required and capable
     #
@@ -482,15 +489,16 @@ module Ably
     #
     # @api private
     def configure_client_id(new_client_id)
-      # If new client ID from Ably is a wildcard, but preconfigured clientId is set, then keep the existing clientId
-      if has_client_id? && new_client_id == '*'
-        @client_id_validated = true
-        return
-      end
-
-      # If client_id is defined and not a wildcard, prevent it changing, this is not supported
-      if client_id && client_id != '*' &&  new_client_id != client_id
-        raise Ably::Exceptions::IncompatibleClientId.new("Client ID is immutable once configured for a client. Client ID cannot be changed to '#{new_client_id}'")
+      if has_client_id?
+        # If new client ID from Ably is a wildcard, but preconfigured clientId is set, then keep the existing clientId
+        if new_client_id == "*"
+          @client_id_validated = true
+          return
+        end
+        # If client_id is defined and not a wildcard, prevent it changing, this is not supported
+        if new_client_id != client_id
+          raise Ably::Exceptions::IncompatibleClientId.new("Client ID is immutable once configured for a client. Client ID cannot be changed to '#{new_client_id}'")
+        end
       end
       @client_id_validated = true
       @client_id = new_client_id

data/lib/ably/models/protocol_message.rb

@@ -20,8 +20,6 @@ module Ably::Models
   #   @return [String] Contains a serial number for a message on the current channel
   # @!attribute [r] connection_id
   #   @return [String] Contains a string private connection key used to recover this connection
-  # @!attribute [r] connection_serial
-  #   @return [Bignum] Contains a serial number for a message sent from the server to the client
   # @!attribute [r] message_serial
   #   @return [Bignum] Contains a serial number for a message sent from the client to the server
   # @!attribute [r] timestamp
@@ -129,12 +127,6 @@ module Ably::Models
       raise TypeError, "msg_serial '#{attributes[:msg_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
     end
 
-    def connection_serial
-      Integer(attributes[:connection_serial])
-    rescue TypeError
-      raise TypeError, "connection_serial '#{attributes[:connection_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
-    end
-
     def count
       [1, attributes[:count].to_i].max
     end
@@ -146,26 +138,12 @@ module Ably::Models
       false
     end
 
-    # @api private
-    def has_connection_serial?
-      connection_serial && true
+    def has_channel_serial?
+      channel_serial && true
     rescue TypeError
       false
     end
 
-    def serial
-      if has_connection_serial?
-        connection_serial
-      else
-        message_serial
-      end
-    end
-
-    # @api private
-    def has_serial?
-      has_connection_serial? || has_message_serial?
-    end
-
     def messages
       @messages ||=
         Array(attributes[:messages]).map do |message|
@@ -271,7 +249,7 @@ module Ably::Models
     # Return a JSON ready object from the underlying #attributes using Ably naming conventions for keys
     def as_json(*args)
       raise TypeError, ':action is missing, cannot generate a valid Hash for ProtocolMessage' unless action
-      raise TypeError, ':msg_serial or :connection_serial is missing, cannot generate a valid Hash for ProtocolMessage' if ack_required? && !has_serial?
+      raise TypeError, ':msg_serial is missing, cannot generate a valid Hash for ProtocolMessage' if ack_required? && !has_message_serial?
 
       attributes.dup.tap do |hash_object|
         hash_object['action']   = action.to_i
@@ -296,11 +274,12 @@ module Ably::Models
     end
 
     # True if the ProtocolMessage appears to be invalid, however this is not a guarantee
+    # Used for validating incoming protocol messages, so no need to add unnecessary checks
     # @return [Boolean]
     # @api private
     def invalid?
       action_enum = action rescue nil
-      !action_enum || (ack_required? && !has_serial?)
+      !action_enum
     end
 
     # @!attribute [r] logger

data/lib/ably/modules/safe_deferrable.rb

@@ -39,7 +39,7 @@ module Ably::Modules
       end
     end
 
-    # Mark the Deferrable as succeeded and trigger all callbacks.
+    # Mark the Deferrable as succeeded and trigger all success callbacks.
     # See http://www.rubydoc.info/gems/eventmachine/1.0.7/EventMachine/Deferrable#succeed-instance_method
     #
     # @return [void]
@@ -48,7 +48,7 @@ module Ably::Modules
       super(*args)
     end
 
-    # Mark the Deferrable as failed and trigger all callbacks.
+    # Mark the Deferrable as failed and trigger all error callbacks.
     # See http://www.rubydoc.info/gems/eventmachine/1.0.7/EventMachine/Deferrable#fail-instance_method
     #
     # @return [void]

data/lib/ably/modules/state_emitter.rb

@@ -3,7 +3,7 @@ module Ably::Modules
   # the instance variable @state is used exclusively, the {Enum} STATE is defined prior to inclusion of this
   # 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
+  # It also ensures the EventEmitter is configured to restrict permitted events to the
   # 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
   #

data/lib/ably/realtime/auth.rb

@@ -226,6 +226,10 @@ module Ably
         auth_sync.auth_header
       end
 
+      def client_id_for_request_sync
+        auth_sync.client_id_for_request
+      end
+
       # Auth params used in URI endpoint for Realtime connections
       # Will reauthorize implicitly if required and capable
       #

data/lib/ably/realtime/channel/channel_manager.rb

@@ -18,7 +18,7 @@ module Ably::Realtime
       def attach
         if can_transition_to?(:attached)
           connect_if_connection_initialized
-          send_attach_protocol_message
+          send_attach_protocol_message if connection.state?(:connected) # RTL4i
         end
       end
 
@@ -34,9 +34,9 @@ module Ably::Realtime
       # Channel is attached, notify presence if sync is expected
       def attached(attached_protocol_message)
         # If no attached ProtocolMessage then this attached request was triggered by the client
-        # library, such as returning to attached whne detach has failed
+        # library, such as returning to attached when detach has failed
         if attached_protocol_message
-          update_presence_sync_state_following_attached attached_protocol_message
+          channel.presence.manager.on_attach attached_protocol_message.has_presence_flag?
           channel.properties.set_attach_serial(attached_protocol_message.channel_serial)
           channel.options.set_modes_from_flags(attached_protocol_message.flags)
           channel.options.set_params(attached_protocol_message.params)
@@ -49,17 +49,16 @@ module Ably::Realtime
       end
 
       # 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}" }
+      # @param [Ably::Models::ErrorInfo] reason
+      def request_reattach(reason = nil)
         channel.set_channel_error_reason(reason) if reason
         channel.transition_state_machine! :attaching, reason: reason unless channel.attaching?
+        send_attach_protocol_message
+        logger.debug { "Explicit channel reattach request sent to Ably due to #{reason}" }
       end
 
       def duplicate_attached_received(protocol_message)
+        logger.debug { "Server initiated ATTACHED message received for channel '#{channel.name}' with state #{channel.state}" }
         if protocol_message.error
           channel.set_channel_error_reason protocol_message.error
           log_channel_error protocol_message.error
@@ -68,9 +67,7 @@ module Ably::Realtime
         channel.properties.set_attach_serial(protocol_message.channel_serial)
         channel.options.set_modes_from_flags(protocol_message.flags)
 
-        if protocol_message.has_channel_resumed_flag?
-          logger.debug { "ChannelManager: Additional resumed ATTACHED message received for #{channel.state} channel '#{channel.name}'" }
-        else
+        unless protocol_message.has_channel_resumed_flag?
           channel.emit :update, Ably::Models::ChannelStateChange.new(
             current: channel.state,
             previous: channel.state,
@@ -78,7 +75,7 @@ module Ably::Realtime
             reason: protocol_message.error,
             resumed: false,
           )
-          update_presence_sync_state_following_attached protocol_message
+          channel.presence.manager.on_attach protocol_message.has_presence_flag?
         end
       end
 
@@ -170,6 +167,12 @@ module Ably::Realtime
         end
       end
 
+      # RTL13c
+      def notify_state_change
+        @pending_state_change_timer.cancel if @pending_state_change_timer
+        @pending_state_change_timer = nil
+      end
+
       private
       attr_reader :pending_state_change_timer
 
@@ -209,56 +212,56 @@ module Ably::Realtime
           message_options[:flags] = message_options[:flags].to_i | Ably::Models::ProtocolMessage::ATTACH_FLAGS_MAPPING[:resume]
         end
 
-        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Attach, :suspended, message_options
-      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
+        message_options[:channelSerial] = channel.properties.channel_serial # RTL4c1
 
-      def send_state_change_protocol_message(new_state, state_if_failed, message_options = {})
         state_at_time_of_request = channel.state
+        attach_action = Ably::Models::ProtocolMessage::ACTION.Attach
+        # RTL4f
         @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: Ably::Exceptions::Codes::CHANNEL_OPERATION_FAILED_NO_RESPONSE_FROM_SERVER, message: "Channel #{new_state} operation failed (timed out)")
-            channel.transition_state_machine state_if_failed, reason: error
+            error = Ably::Models::ErrorInfo.new(code: Ably::Exceptions::Codes::CHANNEL_OPERATION_FAILED_NO_RESPONSE_FROM_SERVER, message: "Channel #{attach_action} operation failed (timed out)")
+            channel.transition_state_machine :suspended, reason: error # return to suspended state if failed
           end
         end
+        # Shouldn't queue attach message as per RTL4i, so message is added top of the queue
+        # to be sent immediately while processing next message
+        connection.send_protocol_message_immediately(
+          action:  attach_action.to_i,
+          channel: channel.name,
+          **message_options.to_h
+        )
+      end
 
-        channel.once_state_changed do
-          @pending_state_change_timer.cancel if @pending_state_change_timer
-          @pending_state_change_timer = nil
+      def send_detach_protocol_message(previous_state)
+        state_at_time_of_request = channel.state
+        detach_action = Ably::Models::ProtocolMessage::ACTION.Detach
+
+        @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: Ably::Exceptions::Codes::CHANNEL_OPERATION_FAILED_NO_RESPONSE_FROM_SERVER, message: "Channel #{detach_action} operation failed (timed out)")
+            channel.transition_state_machine previous_state, reason: error # return to previous state if failed
+          end
         end
 
-        resend_if_disconnected_and_connected = lambda do
+        on_disconnected_and_connected = lambda do |&block|
           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,
-                **message_options.to_h
-              )
-              resend_if_disconnected_and_connected.call
-            end
+              block.call if pending_state_change_timer
+            end if pending_state_change_timer
           end
         end
-        resend_if_disconnected_and_connected.call
-
-        connection.send_protocol_message(
-          action:  new_state.to_i,
-          channel: channel.name,
-          **message_options.to_h
-        )
-      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
+        send_detach_message = lambda do
+          on_disconnected_and_connected.call do
+            send_detach_message.call
+          end
+          connection.send_protocol_message(
+            action:  detach_action.to_i,
+            channel: channel.name
+          )
         end
+
+        send_detach_message.call
       end
 
       def logger

data/lib/ably/realtime/channel/channel_properties.rb

@@ -18,6 +18,15 @@ module Ably::Realtime
       #
       attr_reader :attach_serial
 
+      # ChannelSerial contains the channelSerial from latest ProtocolMessage of action type
+      # Message/PresenceMessage received on the channel.
+      #
+      # @spec CP2b, RTL15b
+      #
+      # @return [String]
+      #
+      attr_accessor :channel_serial
+
       def initialize(channel)
         @channel = channel
       end

data/lib/ably/realtime/channel/channel_state_machine.rb

@@ -29,6 +29,7 @@ module Ably::Realtime
       transition :from => :failed,       :to => [:attaching, :initialized]
 
       after_transition do |channel, transition|
+        channel.manager.notify_state_change # RTL13c
         channel.synchronize_state_with_statemachine
       end
 
@@ -55,6 +56,7 @@ module Ably::Realtime
       end
 
       after_transition(to: [:detached, :failed, :suspended]) do |channel, current_transition|
+        channel.properties.channel_serial = nil # RTP5a1
         err = error_from_state_change(current_transition)
         channel.manager.fail_queued_messages(err) if channel.failed? or channel.suspended? #RTL11
         channel.manager.log_channel_error err if err

data/lib/ably/realtime/channel.rb

@@ -42,7 +42,7 @@ module Ably
       #
       # @spec RTL2b
       #
-      # The permited states for this channel
+      # The permitted states for this channel
       STATE = ruby_enum('STATE',
         :initialized,
         :attaching,
@@ -332,6 +332,7 @@ module Ably
       # @return [Ably::Util::SafeDeferrable]
       #
       def history(options = {}, &callback)
+        # RTL10b
         if options.delete(:until_attach)
           unless attached?
             error = Ably::Exceptions::InvalidRequest.new('option :until_attach is invalid as the channel is not attached' )
@@ -363,8 +364,8 @@ module Ably
       # @return [Ably::Models::ChannelOptions]
       def set_options(channel_options)
         @options = Ably::Models::ChannelOptions(channel_options)
-
-        manager.request_reattach if need_reattach?
+        # RTL4i
+        manager.request_reattach if (need_reattach? and connection.state?(:connected))
       end
       alias options= set_options
 

data/lib/ably/realtime/channels.rb

@@ -46,6 +46,26 @@ module Ably
           @channels.delete(channel)
         end if @channels.has_key?(channel)
       end
+
+      # Sets channel serial to each channel from given serials hashmap
+      # @param [Hash] serials - map of channel name to respective channel serial
+      # @api private
+      def set_channel_serials(serials)
+        serials.each do |channel_name, channel_serial|
+          get(channel_name).properties.channel_serial = channel_serial
+        end
+      end
+
+      # @return [Hash] serials - map of channel name to respective channel serial
+      # @api private
+      def get_channel_serials
+        channel_serials = {}
+        self.each do |channel|
+          channel_serials[channel.name] = channel.properties.channel_serial if channel.state == :attached
+        end
+        channel_serials
+      end
+
     end
   end
 end

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

@@ -43,19 +43,24 @@ module Ably::Realtime
           raise ArgumentError, "Expected a ProtocolMessage. Received #{protocol_message}"
         end
 
-        unless protocol_message.action.match_any?(:nack, :error)
-          logger.debug { "#{protocol_message.action} received: #{protocol_message}" }
+        # RTL15b
+        if protocol_message.has_channel_serial? &&
+          (
+            protocol_message.action == :message ||
+              protocol_message.action == :presence ||
+              protocol_message.action == :attached
+          )
+          get_channel(protocol_message.channel).tap do |channel|
+            logger.info "Setting channel serial for channel #{channel.name}, " <<
+                          "Previous: #{channel.properties.channel_serial}, New: #{protocol_message.channel_serial}"
+            channel.properties.channel_serial = protocol_message.channel_serial
+          end
         end
 
-        if protocol_message.action.match_any?(:sync, :presence, :message)
-          if connection.serial && protocol_message.has_connection_serial? && protocol_message.connection_serial <= connection.serial
-            error_message = "Protocol error, duplicate message received for serial #{protocol_message.connection_serial}"
-            logger.error error_message
-            return
-          end
+        unless protocol_message.action.match_any?(:nack, :error)
+          logger.debug { "#{protocol_message.action} received: #{protocol_message}" }
         end
 
-        update_connection_recovery_info protocol_message
         connection.set_connection_confirmed_alive
 
         case protocol_message.action
@@ -172,10 +177,6 @@ module Ably::Realtime
         end
       end
 
-      def update_connection_recovery_info(protocol_message)
-        connection.update_connection_serial protocol_message.connection_serial if protocol_message.has_connection_serial?
-      end
-
       def ack_pending_queue_for_message_serial(ack_protocol_message)
         drop_pending_queue_from_ack(ack_protocol_message) do |protocol_message|
           ack_messages protocol_message.messages

data/lib/ably/realtime/client.rb

@@ -1,5 +1,6 @@
 require 'uri'
 require 'ably/realtime/channel/publisher'
+require 'ably/realtime/recovery_key_context'
 
 module Ably
   module Realtime
@@ -11,6 +12,7 @@ module Ably
       include Ably::Modules::Conversions
 
       extend Forwardable
+      using Ably::Util::AblyExtensions
 
       DOMAIN = 'realtime.ably.io'
 
@@ -120,17 +122,23 @@ module Ably
           acc[key.to_s] = value.to_s
         end
         @rest_client           = Ably::Rest::Client.new(options.merge(realtime_client: self))
-        @echo_messages         = rest_client.options.fetch(:echo_messages, true) == false ? false : true
-        @queue_messages        = rest_client.options.fetch(:queue_messages, true) == false ? false : true
+        @echo_messages         = rest_client.options.fetch_with_default(:echo_messages, true)
+        @queue_messages        = rest_client.options.fetch_with_default(:queue_messages, true)
         @custom_realtime_host  = rest_client.options[:realtime_host] || rest_client.options[:ws_host]
-        @auto_connect          = rest_client.options.fetch(:auto_connect, true) == false ? false : true
-        @recover               = rest_client.options[:recover]
-
-        raise ArgumentError, "Recovery key '#{recover}' is invalid" if recover && !recover.match(Connection::RECOVER_REGEX)
+        @auto_connect          = rest_client.options.fetch_with_default(:auto_connect, true)
+        @recover               = rest_client.options.fetch_with_default(:recover, '')
 
         @auth       = Ably::Realtime::Auth.new(self)
         @channels   = Ably::Realtime::Channels.new(self)
         @connection = Ably::Realtime::Connection.new(self, options)
+
+        unless @recover.nil_or_empty?
+          recovery_context = RecoveryKeyContext.from_json(@recover, logger)
+          unless recovery_context.nil?
+            @channels.set_channel_serials recovery_context.channel_serials # RTN16j
+            @connection.set_msg_serial_from_recover = recovery_context.msg_serial  # RTN16f
+          end
+        end
       end
 
       # Return a {Ably::Realtime::Channel Realtime Channel} for the given name

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

@@ -14,12 +14,14 @@ module Ably::Realtime
       RESOLVABLE_ERROR_CODES = {
         token_expired: Ably::Exceptions::TOKEN_EXPIRED_CODE
       }
+      using Ably::Util::AblyExtensions
 
       def initialize(connection)
         @connection     = connection
         @timers         = Hash.new { |hash, key| hash[key] = [] }
 
-        connection.unsafe_on(:closed) do
+        # RTN8c, RTN9c
+        connection.unsafe_on(:closing, :closed, :suspended, :failed) do
           connection.reset_resume_info
         end
 
@@ -111,23 +113,28 @@ module Ably::Realtime
         # Update the connection details and any associated defaults
         connection.set_connection_details protocol_message.connection_details
 
+        is_connection_resume_or_recover_attempt = !connection.key.nil_or_empty? || !client.recover.nil_or_empty?
+
+        # RTN15c7, RTN16d
+        failed_resume_or_recover = !protocol_message.connection_id == connection.id && !protocol_message.error.nil?
+        if is_connection_resume_or_recover_attempt and failed_resume_or_recover # RTN15c7
+          connection.reset_client_msg_serial
+        end
+        client.disable_automatic_connection_recovery # RTN16k, explicitly setting null, so it won't be used for subsequent connection requests
+
         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.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 connection ID #{protocol_message.connection_id} and key #{protocol_message.connection_details.connection_key}" }
             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_details.connection_key}" }
         end
 
-        reattach_suspended_channels protocol_message.error
-
-        connection.configure_new protocol_message.connection_id, protocol_message.connection_details.connection_key, protocol_message.connection_serial
+        connection.configure_new protocol_message.connection_id, protocol_message.connection_details.connection_key
+        force_reattach_on_channels protocol_message.error # irrespective of connection success/failure, reattach channels
       end
 
       # When connection is CONNECTED and receives an update
@@ -139,7 +146,7 @@ module Ably::Realtime
         # 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_details.connection_key, protocol_message.connection_serial
+        connection.configure_new protocol_message.connection_id, protocol_message.connection_details.connection_key
 
         state_change = Ably::Models::ConnectionStateChange.new(
           current: connection.state,
@@ -281,7 +288,7 @@ module Ably::Realtime
       # 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
+      # based on the message serial numbers
       #
       # @api private
       def resend_pending_message_ack_queue
@@ -568,22 +575,14 @@ module Ably::Realtime
         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
-
-      # 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
+      # When reconnected if channel is in ATTACHING, ATTACHED or SUSPENDED state
+      # it should explicitly be re-attached by sending a new ATTACH to Ably
+      # Spec : RTN15c6, RTN15c7
       def force_reattach_on_channels(error)
         channels.select do |channel|
-          channel.attached? || channel.attaching?
+          channel.attached? || channel.attaching? || channel.suspended?
         end.each do |channel|
-          channel.manager.request_reattach reason: error
+          channel.manager.request_reattach error
         end
       end