ably 0.8.15 → 1.0.0

data/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.next_tick 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_safe_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_safe_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
 

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

@@ -20,11 +20,12 @@ module Ably::Realtime
         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, :detached, :failed]
-      transition :from => :detaching,    :to => [:detached, :attaching, :failed]
+      transition :from => :initialized,  :to => [:attaching, :failed]
+      transition :from => :attaching,    :to => [:attached, :detaching, :failed, :suspended]
+      transition :from => :attached,     :to => [:attaching, :detaching, :detached, :failed, :suspended]
+      transition :from => :detaching,    :to => [:detached, :attaching, :attached, :failed, :suspended]
       transition :from => :detached,     :to => [:attaching, :attached, :failed]
+      transition :from => :suspended,    :to => [:attaching, :detached, :failed]
       transition :from => :failed,       :to => [:attaching]
 
       after_transition do |channel, transition|
@@ -41,31 +42,29 @@ module Ably::Realtime
 
       after_transition(to: [:detaching]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.manager.detach err
+        channel.manager.detach err, current_transition.metadata.previous
       end
 
-      after_transition(to: [:detached]) do |channel, current_transition|
+      after_transition(to: [:detached, :failed, :suspended]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.manager.fail_messages_awaiting_ack err
-        channel.manager.emit_error err if err
+        channel.manager.fail_queued_messages err
+        channel.manager.log_channel_error err if err
       end
 
-      after_transition(to: [:failed]) do |channel, current_transition|
-        err = error_from_state_change(current_transition)
-        channel.manager.fail_messages_awaiting_ack err
-        channel.manager.emit_error err if err
+      after_transition(to: [:suspended]) do |channel, current_transition|
+        channel.manager.start_attach_from_suspended_timer
       end
 
       # Transitions responsible for updating channel#error_reason
-      before_transition(to: [:failed]) do |channel, current_transition|
+      before_transition(to: [:failed, :suspended]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.set_failed_channel_error_reason err if err
+        channel.set_channel_error_reason err if err
       end
 
       before_transition(to: [:attached, :detached]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
         if err
-          channel.set_failed_channel_error_reason err
+          channel.set_channel_error_reason err
         else
           # Attached & Detached are "healthy" final states so reset the error reason
           channel.clear_error_reason

data/lib/ably/realtime/client.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Ably
   module Realtime
     # Client for the Ably Realtime API
@@ -76,8 +78,10 @@ module Ably
       # @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] :auto_connect   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.
       #
-      # @option options [Integer] :disconnected_retry_timeout  (15 seconds). When the connection enters the DISCONNECTED state, after this delay in milliseconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
-      # @option options [Integer] :suspended_retry_timeout     (30 seconds). When the connection enters the SUSPENDED state, after this delay in milliseconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
+      # @option options [Integer] :channel_retry_timeout       (15 seconds). When a channel becomes SUSPENDED, after this delay in seconds, the channel will automatically attempt to reattach if the connection is CONNECTED
+      # @option options [Integer] :disconnected_retry_timeout  (15 seconds). When the connection enters the DISCONNECTED state, after this delay in seconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
+      # @option options [Integer] :suspended_retry_timeout     (30 seconds). When the connection enters the SUSPENDED state, after this delay in seconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
+      # @option options [Boolean] :disable_websocket_heartbeats   WebSocket heartbeats are more efficient than protocol level heartbeats, however they can be disabled for development purposes
       #
       # @return [Ably::Realtime::Client]
       #
@@ -89,7 +93,18 @@ module Ably
       #    client = Ably::Realtime::Client.new(key: 'key.id:secret', client_id: 'john')
       #
       def initialize(options)
-        @rest_client           = Ably::Rest::Client.new(options)
+        raise ArgumentError, 'Options Hash is expected' if options.nil?
+
+        options = options.clone
+        if options.kind_of?(String)
+          options = if options.match(Ably::Auth::API_KEY_REGEX)
+            { key: options }
+          else
+            { token: options }
+          end
+        end
+
+        @rest_client           = Ably::Rest::Client.new(options.merge(realtime_client: self))
         @auth                  = Ably::Realtime::Auth.new(self)
         @channels              = Ably::Realtime::Channels.new(self)
         @connection            = Ably::Realtime::Connection.new(self, options)

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

@@ -27,7 +27,7 @@ module Ably::Realtime
 
       def get_channel(channel_name)
         channels.fetch(channel_name) do
-          logger.warn "Received channel message for non-existent channel"
+          logger.warn { "Received channel message for non-existent channel" }
           Ably::Realtime::Models::NilChannel.new
         end
       end
@@ -43,19 +43,13 @@ module Ably::Realtime
           raise ArgumentError, "Expected a ProtocolMessage. Received #{protocol_message}"
         end
 
-        unless [:nack, :error].include?(protocol_message.action)
-          logger.debug "#{protocol_message.action} received: #{protocol_message}"
+        unless protocol_message.action.match_any?(:nack, :error)
+          logger.debug { "#{protocol_message.action} received: #{protocol_message}" }
         end
 
-        if [:sync, :presence, :message].any? { |prevent_duplicate| protocol_message.action == prevent_duplicate }
+        if protocol_message.action.match_any?(:sync, :presence, :message)
           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.emit :error, Ably::Exceptions::ProtocolError.new(error_message, 400, 80013)
             logger.error error_message
             return
           end
@@ -69,15 +63,18 @@ module Ably::Realtime
             ack_pending_queue_for_message_serial(protocol_message) if protocol_message.has_message_serial?
 
           when ACTION.Nack
-            logger.warn "NACK received: #{protocol_message}"
+            logger.warn { "NACK received: #{protocol_message}" }
             nack_pending_queue_for_message_serial(protocol_message) if protocol_message.has_message_serial?
 
           when ACTION.Connect
           when ACTION.Connected
-            if connection.disconnected? || connection.closing? || connection.closed? || connection.failed?
-              logger.debug "Incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}"
+            if connection.closing?
+              logger.debug { "Out-of-order incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}" }
+            elsif connection.disconnected? || connection.closing? || connection.closed? || connection.failed?
+              logger.warn { "Out-of-order incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}" }
             elsif connection.connected?
-              logger.error "CONNECTED ProtocolMessage should not have been received when the connection is in the CONNECTED state"
+              logger.debug { "Updated CONNECTED ProtocolMessage received (whilst connected)" }
+              process_connected_update_message protocol_message
             else
               process_connected_message protocol_message
             end
@@ -90,7 +87,7 @@ module Ably::Realtime
             connection.transition_state_machine :closed unless connection.closed?
 
           when ACTION.Error
-            if protocol_message.channel && !protocol_message.has_message_serial?
+            if protocol_message.channel
               dispatch_channel_error protocol_message
             else
               process_connection_error protocol_message
@@ -99,21 +96,22 @@ module Ably::Realtime
           when ACTION.Attach
           when ACTION.Attached
             get_channel(protocol_message.channel).tap do |channel|
-              channel.transition_state_machine :attached, reason: protocol_message.error, protocol_message: protocol_message unless channel.attached?
+              if channel.attached?
+                channel.manager.duplicate_attached_received protocol_message
+              else
+                channel.transition_state_machine :attached, reason: protocol_message.error, resumed: protocol_message.has_channel_resumed_flag?, protocol_message: protocol_message
+              end
             end
 
           when ACTION.Detach
           when ACTION.Detached
             get_channel(protocol_message.channel).tap do |channel|
-              channel.transition_state_machine :detached unless channel.detached?
+              channel.manager.detached_received protocol_message.error
             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.members.update_sync_serial protocol_message.channel_serial
+            presence.manager.sync_process_messages protocol_message.channel_serial, protocol_message.presence
 
           when ACTION.Presence
             presence = get_channel(protocol_message.channel).presence
@@ -127,19 +125,23 @@ module Ably::Realtime
               channel.__incoming_msgbus__.publish :message, message
             end
 
+          when ACTION.Auth
+            client.auth.authorize
+
           else
             error = Ably::Exceptions::ProtocolError.new("Protocol Message Action #{protocol_message.action} is unsupported by this MessageDispatcher", 400, 80013)
-            client.connection.emit :error, error
             logger.fatal error.message
         end
+
+        connection.set_connection_confirmed_alive
       end
 
       def dispatch_channel_error(protocol_message)
-        logger.warn "Channel Error message received: #{protocol_message.error}"
+        logger.warn { "Channel Error message received: #{protocol_message.error}" }
         if !protocol_message.has_message_serial?
           get_channel(protocol_message.channel).transition_state_machine :failed, reason: protocol_message.error
         else
-          logger.fatal "Cannot process ProtocolMessage as not yet implemented: #{protocol_message}"
+          logger.fatal { "Cannot process ProtocolMessage ERROR with message serial as not yet implemented: #{protocol_message}" }
         end
       end
 
@@ -149,11 +151,18 @@ module Ably::Realtime
 
       def process_connected_message(protocol_message)
         if client.auth.token_client_id_allowed?(protocol_message.connection_details.client_id)
-          client.auth.configure_client_id protocol_message.connection_details.client_id
-          client.connection.set_connection_details protocol_message.connection_details
           connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
         else
-          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' specified by the server is incompatible with the library's configured client ID '#{client.client_id}'", 400, 40012)
+          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' specified by the server is incompatible with the library's configured client ID '#{client.client_id}'")
+          connection.transition_state_machine :failed, reason: reason, protocol_message: protocol_message
+        end
+      end
+
+      def process_connected_update_message(protocol_message)
+        if client.auth.token_client_id_allowed?(protocol_message.connection_details.client_id)
+          connection.manager.connected_update protocol_message
+        else
+          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' in CONNECTED update specified by the server is incompatible with the library's configured client ID '#{client.client_id}'")
           connection.transition_state_machine :failed, reason: reason, protocol_message: protocol_message
         end
       end
@@ -178,14 +187,14 @@ module Ably::Realtime
 
       def ack_messages(messages)
         messages.each do |message|
-          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_safe_json}"
+          logger.debug { "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}" }
           message.succeed message
         end
       end
 
       def nack_messages(messages, protocol_message)
         messages.each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_safe_json}, protocol message: #{protocol_message}"
+          logger.debug { "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}" }
           message.fail protocol_message.error
         end
       end