ably 0.6.2 → 0.7.0

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

@@ -0,0 +1,68 @@
+require 'ably/modules/state_machine'
+
+module Ably::Realtime
+  class Channel
+    # Internal class to manage channel state for {Ably::Realtime::Channel}
+    #
+    # @api private
+    #
+    class ChannelStateMachine
+      include Ably::Modules::StateMachine
+
+      # States supported by this StateMachine match #{Channel::STATE}s
+      #   :initialized
+      #   :attaching
+      #   :attached
+      #   :detaching
+      #   :detached
+      #   :failed
+      Channel::STATE.each_with_index do |state_enum, index|
+        state state_enum.to_sym, initial: index == 0
+      end
+
+      transition :from => :initialized,  :to => [:attaching]
+      transition :from => :attaching,    :to => [:attached, :detaching, :failed]
+      transition :from => :attached,     :to => [:detaching, :failed]
+      transition :from => :detaching,    :to => [:detached, :attaching, :failed]
+      transition :from => :failed,       :to => [:attaching]
+
+      after_transition do |channel, transition|
+        channel.synchronize_state_with_statemachine
+      end
+
+      after_transition(to: [:attaching]) do |channel|
+        channel.manager.attach
+      end
+
+      before_transition(to: [:attached]) do |channel, current_transition|
+        channel.manager.sync current_transition.metadata
+      end
+
+      after_transition(to: [:detaching]) do |channel|
+        channel.manager.detach
+      end
+
+      after_transition(to: [:failed]) do |channel, current_transition|
+        channel.manager.failed current_transition.metadata
+      end
+
+      # Transitions responsible for updating channel#error_reason
+      before_transition(to: [:failed]) do |channel, current_transition|
+        channel.set_failed_channel_error_reason current_transition.metadata
+      end
+
+      before_transition(to: [:attached, :detached]) do |channel, current_transition|
+        channel.set_failed_channel_error_reason nil
+      end
+
+      private
+      def channel
+        object
+      end
+
+      def logger
+        channel.logger
+      end
+    end
+  end
+end

data/lib/ably/realtime/client.rb

@@ -2,8 +2,6 @@ module Ably
   module Realtime
     # Client for the Ably Realtime API
     #
-    # @!attribute [r] auth
-    #   (see Ably::Rest::Client#auth)
     # @!attribute [r] client_id
     #   (see Ably::Rest::Client#client_id)
     # @!attribute [r] auth_options
@@ -12,28 +10,50 @@ module Ably
     #   (see Ably::Rest::Client#environment)
     # @!attribute [r] channels
     #   @return [Aby::Realtime::Channels] The collection of {Ably::Realtime::Channel}s that have been created
-    # @!attribute [r] rest_client
-    #   @return [Ably::Rest::Client] The {Ably::Rest::Client REST client} instantiated with the same credentials and configuration that is used for all REST operations such as authentication
-    # @!attribute [r] echo_messages
-    #   @return [Boolean] If false, suppresses messages originating from this connection being echoed back on the same connection.  Defaults to true
     # @!attribute [r] encoders
     #   (see Ably::Rest::Client#encoders)
     # @!attribute [r] protocol
     #   (see Ably::Rest::Client#protocol)
     # @!attribute [r] protocol_binary?
     #   (see Ably::Rest::Client#protocol_binary?)
+    #
     class Client
       include Ably::Modules::AsyncWrapper
       extend Forwardable
 
       DOMAIN = 'realtime.ably.io'
 
-      attr_reader :channels, :auth, :rest_client, :echo_messages
+      # The collection of {Ably::Realtime::Channel}s that have been created
+      # @return [Aby::Realtime::Channels]
+      attr_reader :channels
+
+      # (see Ably::Rest::Client#auth)
+      attr_reader :auth
+
+      # The {Ably::Rest::Client REST client} instantiated with the same credentials and configuration that is used for all REST operations such as authentication
+      # @return [Ably::Rest::Client]
+      attr_reader :rest_client
+
+      # When false the client suppresses messages originating from this connection being echoed back on the same connection.  Defaults to true
+      # @return [Boolean]
+      attr_reader :echo_messages
+
+      # The custom realtime websocket host that is being used if it was provided with the option `:ws_host` when the {Client} was created
+      # @return [String,Nil]
+      attr_reader :custom_realtime_host
+
+      # When true, as soon as the client library is instantiated it will connect to Ably.  If this attribute is false, a connection must be opened explicitly
+      # @return [Boolean]
+      attr_reader :connect_automatically
+
+      # When a recover option is specified a connection inherits the state of a previous connection that may have existed under a different instance of the Realtime library, please refer to the API documentation for further information on connection state recovery
+      # @return [String,Nil]
+      attr_reader :recover
+
       def_delegators :auth, :client_id, :auth_options
       def_delegators :@rest_client, :encoders
-      def_delegators :@rest_client, :environment, :use_tls?, :protocol, :protocol_binary?
+      def_delegators :@rest_client, :environment, :use_tls?, :protocol, :protocol_binary?, :custom_host
       def_delegators :@rest_client, :log_level
-      def_delegators :@rest_client, :time, :stats
 
       # Creates a {Ably::Realtime::Client Realtime Client} and configures the {Ably::Auth} object for the connection.
       #
@@ -41,7 +61,8 @@ module Ably
       # @option options (see Ably::Rest::Client#initialize)
       # @option options [Boolean] :queue_messages If false, this disables the default behaviour whereby the library queues messages on a connection in the disconnected or connecting states
       # @option options [Boolean] :echo_messages  If false, prevents messages originating from this connection being echoed back on the same connection
-      # @option options [String]  :recover        This option allows a connection to inherit the state of a previous connection that may have existed under an different instance of the Realtime library.
+      # @option options [String]  :recover        When a recover option is specified a connection inherits the state of a previous connection that may have existed under a different instance of the Realtime library, please refer to the API documentation for further information on connection state recovery
+      # @option options [Boolean] :connect_automatically  By default as soon as the client library is instantiated it will connect to Ably. You can optionally set this to false and explicitly connect.
       #
       # @yield (see Ably::Rest::Client#initialize)
       # @yieldparam (see Ably::Rest::Client#initialize)
@@ -56,12 +77,16 @@ module Ably
       #    # create a new client and configure a client ID used for presence
       #    client = Ably::Realtime::Client.new(api_key: 'key.id:secret', client_id: 'john')
       #
-      def initialize(options, &auth_block)
-        @rest_client        = Ably::Rest::Client.new(options, &auth_block)
-        @auth               = @rest_client.auth
-        @channels           = Ably::Realtime::Channels.new(self)
-        @echo_messages      = @rest_client.options.fetch(:echo_messages, true) == false ? false : true
-        @custom_socket_host = @rest_client.options[:ws_host]
+      def initialize(options, &token_request_block)
+        @rest_client           = Ably::Rest::Client.new(options, &token_request_block)
+        @auth                  = @rest_client.auth
+        @channels              = Ably::Realtime::Channels.new(self)
+        @echo_messages         = @rest_client.options.fetch(:echo_messages, true) == false ? false : true
+        @custom_realtime_host  = @rest_client.options[:realtime_host] || @rest_client.options[:ws_host]
+        @connect_automatically = @rest_client.options.fetch(:connect_automatically, true) == false ? false : true
+        @recover               = @rest_client.options[:recover]
+
+        raise ArgumentError, "Recovery key is invalid" if @recover && !@recover.match(Connection::RECOVER_REGEX)
       end
 
       # Return a {Ably::Realtime::Channel Realtime Channel} for the given name
@@ -103,10 +128,7 @@ module Ably
       # @!attribute [r] endpoint
       # @return [URI::Generic] Default Ably Realtime endpoint used for all requests
       def endpoint
-        URI::Generic.build(
-          scheme: use_tls? ? "wss" : "ws",
-          host:   custom_socket_host || [environment, DOMAIN].compact.join('-')
-        )
+        endpoint_for_host(custom_realtime_host || [environment, DOMAIN].compact.join('-'))
       end
 
       # @!attribute [r] connection
@@ -115,12 +137,6 @@ module Ably
         @connection ||= Connection.new(self)
       end
 
-      # @!attribute [r] custom_socket_host
-      # @return [String,NilClass] Returns the custom socket host that is being used if it was provided with the option :ws_host when the {Client} was created
-      def custom_socket_host
-        @custom_socket_host
-      end
-
       # (see Ably::Rest::Client#register_encoder)
       def register_encoder(encoder)
         rest_client.register_encoder encoder
@@ -130,6 +146,34 @@ module Ably
       def logger
         @logger ||= Ably::Logger.new(self, log_level, rest_client.logger.custom_logger)
       end
+
+      # Disable connection recovery, typically used after a connection has been recovered
+      # @return [void]
+      # @api private
+      def disable_automatic_connection_recovery
+        @recover = nil
+      end
+
+      # @!attribute [r] fallback_endpoint
+      # @return [URI::Generic] Fallback endpoint used to connect to the realtime Ably service. Note, after each connection attempt, a new random {Ably::FALLBACK_HOSTS fallback host} is used
+      # @api private
+      def fallback_endpoint
+        unless @fallback_endpoints
+          @fallback_endpoints = Ably::FALLBACK_HOSTS.shuffle.map { |fallback_host| endpoint_for_host(fallback_host) }
+        end
+
+        fallback_endpoint_index = connection.manager.retry_count_for_state(:disconnected) + connection.manager.retry_count_for_state(:suspended)
+
+        @fallback_endpoints[fallback_endpoint_index % @fallback_endpoints.count]
+      end
+
+      private
+      def endpoint_for_host(host)
+        URI::Generic.build(
+          scheme: use_tls? ? 'wss' : 'ws',
+          host:   host
+        )
+      end
     end
   end
 end

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

@@ -41,7 +41,7 @@ module Ably::Realtime
           logger.debug "#{protocol_message.action} received: #{protocol_message}"
         end
 
-        update_connection_id protocol_message
+        update_connection_recovery_info protocol_message
 
         case protocol_message.action
           when ACTION.Heartbeat
@@ -57,35 +57,44 @@ module Ably::Realtime
             connection.transition_state_machine :connected
 
           when ACTION.Disconnect, ACTION.Disconnected
+            connection.transition_state_machine :disconnected, protocol_message.error
 
           when ACTION.Close
           when ACTION.Closed
             connection.transition_state_machine :closed
 
           when ACTION.Error
-            logger.error "Error received: #{protocol_message.error}"
             if protocol_message.channel && !protocol_message.has_message_serial?
               dispatch_channel_error protocol_message
             else
-              connection.transition_state_machine :failed, protocol_message.error
+              process_connection_error protocol_message
             end
 
           when ACTION.Attach
           when ACTION.Attached
-            get_channel(protocol_message.channel).change_state Ably::Realtime::Channel::STATE.Attached
+            get_channel(protocol_message.channel).transition_state_machine :attached, protocol_message
 
           when ACTION.Detach
           when ACTION.Detached
-            get_channel(protocol_message.channel).change_state Ably::Realtime::Channel::STATE.Detached
+            get_channel(protocol_message.channel).transition_state_machine :detached
+
+          when ACTION.Sync
+            presence = get_channel(protocol_message.channel).presence
+            protocol_message.presence.each do |presence_message|
+              presence.__incoming_msgbus__.publish :sync, presence_message
+            end
+            presence.update_sync_serial protocol_message.channel_serial
 
           when ACTION.Presence
-            protocol_message.presence.each do |presence|
-              get_channel(protocol_message.channel).presence.__incoming_msgbus__.publish :presence, presence
+            presence = get_channel(protocol_message.channel).presence
+            protocol_message.presence.each do |presence_message|
+              presence.__incoming_msgbus__.publish :presence, presence_message
             end
 
           when ACTION.Message
+            channel = get_channel(protocol_message.channel)
             protocol_message.messages.each do |message|
-              get_channel(protocol_message.channel).__incoming_msgbus__.publish :message, message
+              channel.__incoming_msgbus__.publish :message, message
             end
 
           else
@@ -94,17 +103,26 @@ module Ably::Realtime
       end
 
       def dispatch_channel_error(protocol_message)
+        logger.warn "Channel Error message received: #{protocol_message.error}"
         if !protocol_message.has_message_serial?
-          get_channel(protocol_message.channel).change_state Ably::Realtime::Channel::STATE.Failed, protocol_message.error
+          get_channel(protocol_message.channel).transition_state_machine :failed, protocol_message.error
         else
           logger.fatal "Cannot process ProtocolMessage as not yet implemented: #{protocol_message}"
         end
       end
 
-      def update_connection_id(protocol_message)
-        if protocol_message.connection_id && (protocol_message.connection_id != connection.id)
-          logger.debug "New connection ID set to #{protocol_message.connection_id}"
-          connection.update_connection_id protocol_message.connection_id
+      def process_connection_error(protocol_message)
+        connection.manager.error_received_from_server protocol_message.error
+      end
+
+      def update_connection_recovery_info(protocol_message)
+        if protocol_message.connection_key && (protocol_message.connection_key != connection.key)
+          logger.debug "New connection ID set to #{protocol_message.connection_id} with connection key #{protocol_message.connection_key}"
+          connection.update_connection_id_and_key protocol_message.connection_id, protocol_message.connection_key
+        end
+
+        if protocol_message.has_connection_serial?
+          connection.update_connection_serial protocol_message.connection_serial
         end
       end
 

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

@@ -20,7 +20,7 @@ module Ably::Realtime
       attr_reader :client, :connection
 
       def can_send_messages?
-        connection.connected?
+        connection.connected? || connection.closing?
       end
 
       def messages_in_outgoing_queue?

data/lib/ably/realtime/connection.rb

@@ -23,6 +23,8 @@ 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
@@ -30,11 +32,8 @@ module Ably
     #    end
     #
     # @!attribute [r] state
-    #   @return {Ably::Realtime::Connection::STATE} connection state
-    # @!attribute [r] id
-    #   @return {String} the assigned connection ID
-    # @!attribute [r] error_reason
-    #   @return {Ably::Models::ErrorInfo} error information associated with a connection failure
+    #   @return [Ably::Realtime::Connection::STATE] connection state
+    #
     class Connection
       include Ably::Modules::EventEmitter
       include Ably::Modules::Conversions
@@ -47,37 +46,59 @@ module Ably
         :connected,
         :disconnected,
         :suspended,
+        :closing,
         :closed,
         :failed
       )
       include Ably::Modules::StateEmitter
+      include Ably::Modules::UsesStateMachine
 
-      attr_reader :id, :error_reason, :client
+      # Expected format for a connection recover key
+      RECOVER_REGEX = /^(?<recover>[\w-]+):(?<connection_serial>\-?\w+)$/
+
+      # A unique public identifier for this connection, used to identify this member in presence events and messages
+      # @return [String]
+      attr_reader :id
+
+      # A unique private connection key used to recover this connection, assigned by Ably
+      # @return [String]
+      attr_reader :key
+
+      # The serial number of the last message to be received on this connection, used to recover or resume a connection
+      # @return [Integer]
+      attr_reader :serial
+
+      # When a connection failure occurs this attribute contains the Ably Exception
+      # @return [Ably::Models::ErrorInfo,Ably::Exceptions::BaseAblyException]
+      attr_reader :error_reason
+
+      # {Ably::Realtime::Client} associated with this connection
+      # @return [Ably::Realtime::Client]
+      attr_reader :client
 
-      # @api private
       # Underlying socket transport used for this connection, for internal use by the client library
-      # @return {Ably::Realtime::Connection::WebsocketTransport}
+      # @return [Ably::Realtime::Connection::WebsocketTransport]
+      # @api private
       attr_reader :transport
 
+      # The Connection manager responsible for creating, maintaining and closing the connection and underlying transport
+      # @return [Ably::Realtime::Connection::ConnectionManager]
       # @api private
-      # The connection manager responsible for creating, maintaining and closing the connection and underlying transport
-      # @return {Ably::Realtime::Connection::ConnectionManager}
       attr_reader :manager
 
-      # @api private
       # An internal queue used to manage unsent outgoing messages.  You should never interface with this array directly
       # @return [Array]
+      # @api private
       attr_reader :__outgoing_message_queue__
 
-      # @api private
       # An internal queue used to manage sent messages.  You should never interface with this array directly
       # @return [Array]
+      # @api private
       attr_reader :__pending_message_queue__
 
       # @api public
       def initialize(client)
         @client                     = client
-
         @serial                     = -1
         @__outgoing_message_queue__ = []
         @__pending_message_queue__  = []
@@ -85,13 +106,9 @@ module Ably
         Client::IncomingMessageDispatcher.new client, self
         Client::OutgoingMessageDispatcher.new client, self
 
-        EventMachine.next_tick do
-          trigger STATE.Initialized
-        end
-
-        @state_machine              = ConnectionStateMachine.new(self)
-        @manager                    = ConnectionManager.new(self)
-        @state                      = STATE(state_machine.current_state)
+        @state_machine = ConnectionStateMachine.new(self)
+        @state         = STATE(state_machine.current_state)
+        @manager       = ConnectionManager.new(self)
       end
 
       # Causes the connection to close, entering the closed state, from any state except
@@ -100,31 +117,29 @@ module Ably
       #
       # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Closed state
       #
-      # @return [void]
-      def close(&block)
-        if closed?
-          block.call self
-        else
-          EventMachine.next_tick do
-            transition_state_machine(:closed)
-          end
-          once(STATE.Closed) { block.call self } if block_given?
+      # @return [EventMachine::Deferrable]
+      #
+      def close(&success_block)
+        unless closing? || closed?
+          raise exception_for_state_change_to(:closing) unless can_transition_to?(:closing)
+          transition_state_machine :closing
         end
+        deferrable_for_state_change_to(STATE.Closed, &success_block)
       end
 
-      # Causes the library to re-attempt connection, if it was previously explicitly
-      # closed by the user, or was closed as a result of an unrecoverable error.
+      # Causes the library to attempt connection.  If it was previously explicitly
+      # closed by the user, or was closed as a result of an unrecoverable error, a new connection will be opened.
       #
       # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Connected state
       #
-      # @return [void]
-      def connect(&block)
-        if connected?
-          block.call self
-        else
-          transition_state_machine(:connecting) unless connecting?
-          once(STATE.Connected) { block.call self } if block_given?
+      # @return [EventMachine::Deferrable]
+      #
+      def connect(&success_block)
+        unless connecting? || connected?
+          raise exception_for_state_change_to(:connecting) unless can_transition_to?(:connecting)
+          transition_state_machine :connecting
         end
+        deferrable_for_state_change_to(STATE.Connected, &success_block)
       end
 
       # Sends a ping to Ably and yields the provided block when a heartbeat ping request is echoed from the server.
@@ -139,7 +154,10 @@ module Ably
       #      puts "Ping took #{ms_elapsed}ms"
       #    end
       #
+      # @return [void]
+      #
       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?
 
         started = nil
@@ -152,42 +170,40 @@ module Ably
           end
         end
 
-        once(STATE.Connected) do
+        once_or_if(STATE.Connected) do
           started = Time.now
           send_protocol_message action: Ably::Models::ProtocolMessage::ACTION.Heartbeat.to_i
           __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
         end
       end
 
-      # Reconfigure the current connection ID
-      # @return [void]
-      # @api private
-      def update_connection_id(connection_id)
-        @id = connection_id
+      # @!attribute [r] recovery_key
+      #   @return [String] recovery key that can be used by another client to recover this connection with the :recover option
+      def recovery_key
+        "#{key}:#{serial}" if connection_resumable?
       end
 
-      # Call #transition_to on {Ably::Realtime::Connection::ConnectionStateMachine}
-      #
-      # @return [Boolean] true if new_state can be transitioned to by state machine
+      # Configure the current connection ID and connection key
+      # @return [void]
       # @api private
-      def transition_state_machine(new_state, emit_object = nil)
-        state_machine.transition_to(new_state, emit_object)
+      def update_connection_id_and_key(connection_id, connection_key)
+        @id  = connection_id
+        @key = connection_key
       end
 
-      # Call #transition_to! on {Ably::Realtime::Connection::ConnectionStateMachine}.
-      # An exception wil be raised if new_state cannot be transitioned to by state machine
-      #
+      # Store last received connection serial so that the connection can be resumed from the last known point-in-time
       # @return [void]
       # @api private
-      def transition_state_machine!(new_state, emit_object = nil)
-        state_machine.transition_to!(new_state, emit_object)
+      def update_connection_serial(connection_serial)
+        @serial = connection_serial
       end
 
-      # Provides an internal method for the {Ably::Realtime::Connection} state to match the {Ably::Realtime::Connection::ConnectionStateMachine}'s state
+      # Disable automatic resume of a connection
+      # @return [void]
       # @api private
-      def synchronize_state_with_statemachine(*args)
-        log_state_machine_state_change
-        change_state state_machine.current_state, state_machine.last_transition.metadata
+      def reset_resume_info
+        @key    = nil
+        @serial = nil
       end
 
       # @!attribute [r] __outgoing_protocol_msgbus__
@@ -205,9 +221,13 @@ module Ably
       end
 
       # @!attribute [r] host
-      # @return [String] The default host name used for this connection
+      # @return [String] The host name used for this connection, for network connection failures a {Ably::FALLBACK_HOSTS fallback host} is used to route around networking or intermittent problems
       def host
-        client.endpoint.host
+        if can_use_fallback_hosts?
+          client.fallback_endpoint.host
+        else
+          client.endpoint.host
+        end
       end
 
       # @!attribute [r] port
@@ -249,37 +269,28 @@ module Ably
         __outgoing_protocol_msgbus__.publish :protocol_message, protocol_message
       end
 
-      # @!attribute [r] previous_state
-      # @return [Ably::Realtime::Connection::STATE,nil] The previous state for this connection
-      # @api private
-      def previous_state
-        if state_machine.previous_state
-          STATE(state_machine.previous_state)
-        end
-      end
-
-      # @!attribute [r] state_history
-      # @return [Array<Hash>] All previous states including the current state in date ascending order with Hash properties :state, :metadata, :transitioned_at
-      # @api private
-      def state_history
-        state_machine.history.map do |transition|
-          {
-            state:           STATE(transition.to_state),
-            metadata:        transition.metadata,
-            transitioned_at: transition.created_at
-          }
-        end
-      end
-
       # @api private
       def create_websocket_transport(&block)
         operation = proc do
           URI(client.endpoint).tap do |endpoint|
-            endpoint.query = URI.encode_www_form(client.auth.auth_params.merge(
+            url_params = client.auth.auth_params.merge(
               timestamp: as_since_epoch(Time.now),
               format:    client.protocol,
               echo:      client.echo_messages
-            ))
+            )
+
+            if connection_resumable?
+              url_params.merge! resume: key, connection_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
+                client.disable_automatic_connection_recovery
+              end
+            end
+
+            endpoint.query = URI.encode_www_form(url_params)
           end.to_s
         end
 
@@ -289,7 +300,7 @@ module Ably
               yield websocket_transport if block_given?
             end
           rescue EventMachine::ConnectionError => error
-            manager.connection_failed error
+            manager.connection_opening_failed error
           end
         end
 
@@ -302,13 +313,16 @@ module Ably
         @transport = nil
       end
 
+      # @api private
+      def set_failed_connection_error_reason(error)
+        @error_reason = error
+      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
-      attr_reader :serial, :state_machine
-
       def create_pub_sub_message_bus
         Ably::Util::PubSub.new(
           coerce_into: Proc.new do |event|
@@ -335,13 +349,42 @@ module Ably
         raise e
       end
 
-      def log_state_machine_state_change
-        if state_machine.previous_state
-          logger.debug "ConnectionStateMachine: Transitioned from #{state_machine.previous_state} => #{state_machine.current_state}"
-        else
-          logger.debug "ConnectionStateMachine: Transitioned to #{state_machine.current_state}"
+      # Simply wait until the next EventMachine tick to ensure Connection initialization is complete
+      def when_initialized(&block)
+        EventMachine.next_tick { yield }
+      end
+
+      def connection_resumable?
+        !key.nil? && !serial.nil?
+      end
+
+      def connection_recoverable?
+        connection_recover_parts
+      end
+
+      def connection_recover_parts
+        client.recover.to_s.match(RECOVER_REGEX)
+      end
+
+      def can_use_fallback_hosts?
+        if client.environment.nil? && client.custom_realtime_host.nil?
+          if connecting? && previous_state
+            use_fallback_if_disconnected? || use_fallback_if_suspended?
+          end
         end
       end
+
+      def use_fallback_if_disconnected?
+        second_reconnect_attempt_for(:disconnected, 1)
+      end
+
+      def use_fallback_if_suspended?
+        second_reconnect_attempt_for(:suspended, 2) # on first suspended state use default Ably host again
+      end
+
+      def second_reconnect_attempt_for(state, first_attempt_count)
+        previous_state == state && manager.retry_count_for_state(state) >= first_attempt_count
+      end
     end
   end
 end