ably 0.7.2 → 0.7.4

data/lib/ably/realtime/client.rb

@@ -101,7 +101,7 @@ module Ably
       # Retrieve the Ably service time
       #
       # @yield [Time] The time as reported by the Ably service
-      # @return [EventMachine::Deferrable]
+      # @return [Ably::Util::SafeDeferrable]
       #
       def time(&success_callback)
         async_wrap(success_callback) do
@@ -116,7 +116,7 @@ module Ably
       #
       # @yield [Ably::Models::PaginatedResource<Ably::Models::Stat>] An Array of Stats
       #
-      # @return [EventMachine::Deferrable]
+      # @return [Ably::Util::SafeDeferrable]
       #
       def stats(options = {}, &success_callback)
         async_wrap(success_callback) do
@@ -129,6 +129,11 @@ module Ably
         connection.close(&block)
       end
 
+      # (see Ably::Realtime::Connection#connect)
+      def connect(&block)
+        connection.connect(&block)
+      end
+
       # @!attribute [r] endpoint
       # @return [URI::Generic] Default Ably Realtime endpoint used for all requests
       def endpoint

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

@@ -41,6 +41,20 @@ module Ably::Realtime
           logger.debug "#{protocol_message.action} received: #{protocol_message}"
         end
 
+        if [:sync, :presence, :message].any? { |prevent_duplicate| protocol_message.action == prevent_duplicate }
+          if connection.serial && protocol_message.has_connection_serial? && protocol_message.connection_serial <= connection.serial
+            error_target = if protocol_message.channel
+              get_channel(protocol_message.channel)
+            else
+              connection
+            end
+            error_message = "Protocol error, duplicate message received for serial #{protocol_message.connection_serial}"
+            error_target.trigger :error, Ably::Exceptions::ProtocolError.new(error_message, 400, 80013)
+            logger.error error_message
+            return
+          end
+        end
+
         update_connection_recovery_info protocol_message
 
         case protocol_message.action
@@ -54,14 +68,14 @@ module Ably::Realtime
 
           when ACTION.Connect
           when ACTION.Connected
-            connection.transition_state_machine :connected, protocol_message.error
+            connection.transition_state_machine :connected, protocol_message unless connection.connected?
 
           when ACTION.Disconnect, ACTION.Disconnected
-            connection.transition_state_machine :disconnected, protocol_message.error
+            connection.transition_state_machine :disconnected, protocol_message.error unless connection.disconnected?
 
           when ACTION.Close
           when ACTION.Closed
-            connection.transition_state_machine :closed
+            connection.transition_state_machine :closed unless connection.closed?
 
           when ACTION.Error
             if protocol_message.channel && !protocol_message.has_message_serial?
@@ -72,18 +86,22 @@ module Ably::Realtime
 
           when ACTION.Attach
           when ACTION.Attached
-            get_channel(protocol_message.channel).transition_state_machine :attached, protocol_message
+            get_channel(protocol_message.channel).tap do |channel|
+              channel.transition_state_machine :attached, protocol_message unless channel.attached?
+            end
 
           when ACTION.Detach
           when ACTION.Detached
-            get_channel(protocol_message.channel).transition_state_machine :detached
+            get_channel(protocol_message.channel).tap do |channel|
+              channel.transition_state_machine :detached unless channel.detached?
+            end
 
           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
+            presence.members.update_sync_serial protocol_message.channel_serial
 
           when ACTION.Presence
             presence = get_channel(protocol_message.channel).presence
@@ -98,7 +116,9 @@ module Ably::Realtime
             end
 
           else
-            raise ArgumentError, "Protocol Message Action #{protocol_message.action} is unsupported by this MessageDispatcher"
+            error = Ably::Exceptions::ProtocolError.new("Protocol Message Action #{protocol_message.action} is unsupported by this MessageDispatcher", 400, 80013)
+            client.connection.trigger :error, error
+            logger.fatal error.message
         end
       end
 
@@ -116,24 +136,7 @@ module Ably::Realtime
       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}"
-          detach_attached_channels protocol_message.error if protocol_message.error
-          connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
-        end
-
-        if protocol_message.has_connection_serial?
-          connection.update_connection_serial protocol_message.connection_serial
-        end
-      end
-
-      def detach_attached_channels(error)
-        channels.select do |channel|
-          channel.attached? || channel.attaching?
-        end.each do |channel|
-          logger.warn "Detaching channel '#{channel.name}': #{error}"
-          channel.manager.suspend error
-        end
+        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)
@@ -166,7 +169,7 @@ module Ably::Realtime
 
       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_queue__.drop_while do |protocol_message|
+        connection.__pending_message_ack_queue__.drop_while do |protocol_message|
           if protocol_message.message_serial <= message_serial_up_to
             yield protocol_message
             true

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

@@ -31,8 +31,8 @@ module Ably::Realtime
         connection.__outgoing_message_queue__
       end
 
-      def pending_queue
-        connection.__pending_message_queue__
+      def pending_ack_queue
+        connection.__pending_message_ack_queue__
       end
 
       def current_transport_outgoing_message_bus
@@ -47,7 +47,7 @@ module Ably::Realtime
           current_transport_outgoing_message_bus.publish :protocol_message, protocol_message
 
           if protocol_message.ack_required?
-            pending_queue << protocol_message
+            pending_ack_queue << protocol_message
           else
             protocol_message.succeed protocol_message
           end
@@ -61,7 +61,7 @@ module Ably::Realtime
       end
 
       def setup_event_handlers
-        connection.on(:connected) do
+        connection.unsafe_on(:connected) do
           deliver_queued_protocol_messages
         end
       end

data/lib/ably/realtime/connection.rb

@@ -37,6 +37,7 @@ module Ably
     class Connection
       include Ably::Modules::EventEmitter
       include Ably::Modules::Conversions
+      include Ably::Modules::SafeYield
       extend Ably::Modules::Enum
 
       # Valid Connection states
@@ -94,14 +95,14 @@ module Ably
       # 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__
+      attr_reader :__pending_message_ack_queue__
 
       # @api public
       def initialize(client)
-        @client                     = client
-        @client_serial              = -1
-        @__outgoing_message_queue__ = []
-        @__pending_message_queue__  = []
+        @client                        = client
+        @client_serial                 = -1
+        @__outgoing_message_queue__    = []
+        @__pending_message_ack_queue__ = []
 
         Client::IncomingMessageDispatcher.new client, self
         Client::OutgoingMessageDispatcher.new client, self
@@ -156,7 +157,7 @@ module Ably
       #
       # @return [void]
       #
-      def ping
+      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?
 
@@ -166,7 +167,7 @@ module Ably
           if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
             __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
             time_passed = (Time.now.to_f * 1000 - started.to_f * 1000).to_i
-            yield time_passed if block_given?
+            safe_yield block, time_passed if block_given?
           end
         end
 
@@ -202,7 +203,7 @@ module Ably
         "#{key}:#{serial}" if connection_resumable?
       end
 
-      # Following a new connection being made, resumed or recovered, the connection ID, connection key
+      # Following a new connection being made, the connection ID, connection key
       # and message serial need to match the details provided by the server.
       #
       # @return [void]
@@ -290,7 +291,7 @@ module Ably
       # @api private
       def send_protocol_message(protocol_message)
         add_message_serial_if_ack_required_to(protocol_message) do
-          Ably::Models::ProtocolMessage.new(protocol_message).tap do |protocol_message|
+          Ably::Models::ProtocolMessage.new(protocol_message, logger: logger).tap do |protocol_message|
             add_message_to_outgoing_queue protocol_message
             notify_message_dispatcher_of_new_message protocol_message
             logger.debug("Connection: Prot msg queued =>: #{protocol_message.action} #{protocol_message}")
@@ -362,6 +363,29 @@ module Ably
         @error_reason = error
       end
 
+      # @api private
+      def clear_error_reason
+        @error_reason = nil
+      end
+
+      # Triggers registered callbacks for a successful connection resume event
+      # @api private
+      def resumed
+        resume_callbacks.each(&:call)
+      end
+
+      # Provides a simple hook to inject a callback when a connection is successfully resumed
+      # @api private
+      def on_resume(&callback)
+        resume_callbacks << callback
+      end
+
+      # Remove a registered connection resume callback
+      # @api private
+      def off_resume(&callback)
+        resume_callbacks.delete(callback)
+      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
@@ -378,6 +402,10 @@ module Ably
       # @return [Integer] starting at -1 indicating no messages sent, 0 when the first message is sent
       attr_reader :client_serial
 
+      def resume_callbacks
+        @resume_callbacks ||= []
+      end
+
       def create_pub_sub_message_bus
         Ably::Util::PubSub.new(
           coerce_into: Proc.new do |event|
@@ -443,3 +471,7 @@ module Ably
     end
   end
 end
+
+require 'ably/realtime/connection/connection_manager'
+require 'ably/realtime/connection/connection_state_machine'
+require 'ably/realtime/connection/websocket_transport'

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

@@ -29,11 +29,11 @@ module Ably::Realtime
         @connection = connection
         @timers     = Hash.new { |hash, key| hash[key] = [] }
 
-        connection.on(:closed) do
+        connection.unsafe_on(:closed) do
           connection.reset_resume_info
         end
 
-        connection.once(:connecting) do
+        connection.unsafe_once(:connecting) do
           close_connection_when_reactor_is_stopped
         end
 
@@ -75,15 +75,26 @@ module Ably::Realtime
       # @api private
       def connection_opening_failed(error)
         logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
-        connection.transition_state_machine next_retry_state, Ably::Exceptions::ConnectionError.new("Connection failed; #{error.message}", nil, 80000)
+        connection.transition_state_machine next_retry_state, Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
       end
 
-      # Called whenever a new connection message is received with an error
+      # Called whenever a new connection is made
       #
       # @api private
-      def connected_with_error(error)
-        logger.warn "ConnectionManager: Connected with error; #{error.message}"
-        connection.trigger :error, error
+      def connected(protocol_message)
+        if connection.key
+          if protocol_message.connection_key == connection.key
+            logger.debug "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}"
+            EventMachine.next_tick { connection.resumed }
+          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
+            connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
+          end
+        else
+          logger.debug "ConnectionManager: New connection created with ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}"
+          connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
+        end
       end
 
       # Ensures the underlying transport has been disconnected and all event emitter callbacks removed
@@ -133,7 +144,7 @@ module Ably::Realtime
       def fail(error)
         connection.logger.fatal "ConnectionManager: Connection failed - #{error}"
         connection.manager.destroy_transport
-        connection.once(:failed) { connection.trigger :error, error }
+        connection.unsafe_once(:failed) { connection.trigger :error, error }
       end
 
       # When a connection is disconnected whilst connecting, attempt reconnect and/or set state to :suspended or :failed
@@ -143,6 +154,12 @@ module Ably::Realtime
         return unless connection.disconnected? || connection.suspended? # do nothing if state has changed through an explicit request
         return unless retry_connection? # do not always reattempt connection or change state as client may be re-authorising
 
+        error = current_transition.metadata
+        if error.kind_of?(Ably::Models::ErrorInfo)
+          renew_token_and_reconnect error if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
+          return
+        end
+
         unless connection_retry_from_suspended_state?
           return if connection_retry_for(:disconnected, ignore_states: [:connecting])
         end
@@ -159,9 +176,10 @@ module Ably::Realtime
       def respond_to_transport_disconnected_whilst_connected(current_transition)
         logger.warn "ConnectionManager: Connection to #{connection.transport.url} was disconnected unexpectedly"
 
-        if current_transition.metadata.kind_of?(Ably::Models::ErrorInfo)
-          connection.trigger :error, current_transition.metadata
-          logger.error "ConnectionManager: Error received when disconnected within ProtocolMessage - #{current_transition.metadata}"
+        error = current_transition.metadata
+        if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
+          connection.trigger :error, error
+          logger.error "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}"
         end
 
         destroy_transport
@@ -176,7 +194,7 @@ module Ably::Realtime
         case error.code
         when RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           connection.transition_state_machine :disconnected
-          connection.once_or_if(:disconnected) do
+          connection.unsafe_once_or_if(:disconnected) do
             renew_token_and_reconnect error
           end
         else
@@ -207,6 +225,10 @@ module Ably::Realtime
         connection.client
       end
 
+      def channels
+        client.channels
+      end
+
       # Create a timer that will execute in timeout_in seconds.
       # If the connection state changes however, cancel the timer
       def create_timeout_timer_whilst_in_state(timer_id, timeout_in)
@@ -215,7 +237,7 @@ module Ably::Realtime
         timers[timer_id] << EventMachine::Timer.new(timeout_in) do
           yield
         end
-        connection.once_state_changed { clear_timers timer_id }
+        connection.unsafe_once_state_changed { clear_timers timer_id }
       end
 
       def clear_timers(key)
@@ -245,10 +267,15 @@ module Ably::Realtime
       def connection_retry_for(from_state, options = {})
         retry_params = CONNECT_RETRY_CONFIG.fetch(from_state)
 
-        if time_spent_attempting_state(from_state, options) <= retry_params.fetch(:max_time_in_state)
-          logger.debug "ConnectionManager: Pausing for #{retry_params.fetch(:retry_every)}s before attempting to reconnect"
-          create_timeout_timer_whilst_in_state(:reconnect, retry_params.fetch(:retry_every)) do
-            connection.connect if connection.state == from_state
+        if time_spent_attempting_state(from_state, options) < retry_params.fetch(:max_time_in_state)
+          if retries_for_state(from_state, ignore_states: [:connecting]).empty?
+            logger.debug "ConnectionManager: Will attempt reconnect immediately as no previous reconnect attempts made in this state"
+            EventMachine.next_tick { connection.connect }
+          else
+            logger.debug "ConnectionManager: Pausing for #{retry_params.fetch(:retry_every)}s before attempting to reconnect"
+            create_timeout_timer_whilst_in_state(:reconnect, retry_params.fetch(:retry_every)) do
+              connection.connect if connection.state == from_state
+            end
           end
           true
         end
@@ -282,7 +309,16 @@ module Ably::Realtime
         ignore_states = options.fetch(:ignore_states, [])
         allowed_states = Array(state) + Array(ignore_states)
 
-        connection.state_history.reverse.take_while do |transition|
+        state_history_ordered = connection.state_history.reverse
+        last_state = state_history_ordered.first
+
+        # If this method is called after the transition has been persisted to memory,
+        # then we need to ignore the current transition when reviewing the number of retries
+        if last_state[:state].to_sym == state && last_state.fetch(:transitioned_at).to_f > Time.now.to_f - 0.1
+          state_history_ordered.shift
+        end
+
+        state_history_ordered.take_while do |transition|
           allowed_states.include?(transition[:state].to_sym)
         end.select do |transition|
           transition[:state] == state
@@ -290,15 +326,18 @@ module Ably::Realtime
       end
 
       def subscribe_to_transport_events(transport)
-        transport.__incoming_protocol_msgbus__.on(:protocol_message) do |protocol_message|
+        transport.__incoming_protocol_msgbus__.unsafe_on(:protocol_message) do |protocol_message|
           connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
         end
 
-        transport.on(:disconnected) do
+        transport.unsafe_on(:disconnected) do |reason|
           if connection.closing?
             connection.transition_state_machine :closed
           elsif !connection.closed? && !connection.disconnected?
-            connection.transition_state_machine :disconnected
+            exception = if reason
+              Ably::Exceptions::ConnectionClosedError.new(reason)
+            end
+            connection.transition_state_machine :disconnected, exception
           end
         end
       end
@@ -328,10 +367,10 @@ module Ably::Realtime
               connection.off &state_changed_callback
             end
 
-            connection.once :connected, :closed, :failed, &state_changed_callback
+            connection.unsafe_once :connected, :closed, :failed, &state_changed_callback
 
             if token && !token.expired?
-              reconnect_transport
+              connection.connect
             else
               connection.transition_state_machine :failed, error unless connection.failed?
             end
@@ -339,7 +378,7 @@ module Ably::Realtime
 
           EventMachine.defer operation, callback
         else
-          logger.warn "ConnectionManager: Token has expired and is not renewable"
+          logger.error "ConnectionManager: Token has expired and is not renewable"
           connection.transition_state_machine :failed, error
         end
       end
@@ -360,6 +399,15 @@ module Ably::Realtime
         !@renewing_token
       end
 
+      def detach_attached_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
+        end
+      end
+
       def logger
         connection.logger
       end