ably 1.2.5 → 1.2.6

data/lib/ably/realtime/connection.rb

@@ -9,6 +9,8 @@ module Ably
       include Ably::Modules::Conversions
       include Ably::Modules::SafeYield
       extend Ably::Modules::Enum
+      using Ably::Util::AblyExtensions
+
 
       # The current {Ably::Realtime::Connection::STATE} of the connection.
       # Describes the realtime [Connection]{@link Connection} object states.
@@ -23,26 +25,26 @@ module Ably
       #                 or no host is available. The disconnected state is entered if an established connection is dropped,
       #                 or if a connection attempt was unsuccessful. In the disconnected state the library will periodically
       #                 attempt to open a new connection (approximately every 15 seconds), anticipating that the connection
-      #                 will be re-established soon and thus connection and channel continuity will be possible. 
+      #                 will be re-established soon and thus connection and channel continuity will be possible.
       #                 In this state, developers can continue to publish messages as they are automatically placed
-      #                 in a local queue, to be sent as soon as a connection is reestablished. Messages published by 
+      #                 in a local queue, to be sent as soon as a connection is reestablished. Messages published by
       #                 other clients while this client is disconnected will be delivered to it upon reconnection,
-      #                 so long as the connection was resumed within 2 minutes. After 2 minutes have elapsed, recovery 
+      #                 so long as the connection was resumed within 2 minutes. After 2 minutes have elapsed, recovery
       #                 is no longer possible and the connection will move to the SUSPENDED state.
-      # SUSPENDED		  A long term failure condition. No current connection exists because there is no network connectivity 
-      #               or no host is available. The suspended state is entered after a failed connection attempt if 
-      #               there has then been no connection for a period of two minutes. In the suspended state, the library 
-      #               will periodically attempt to open a new connection every 30 seconds. Developers are unable to 
+      # SUSPENDED		  A long term failure condition. No current connection exists because there is no network connectivity
+      #               or no host is available. The suspended state is entered after a failed connection attempt if
+      #               there has then been no connection for a period of two minutes. In the suspended state, the library
+      #               will periodically attempt to open a new connection every 30 seconds. Developers are unable to
       #               publish messages in this state. A new connection attempt can also be triggered by an explicit
-      #               call to {Ably::Realtime::Connection#connect}. Once the connection has been re-established, 
-      #               channels will be automatically re-attached. The client has been disconnected for too long for them 
-      #               to resume from where they left off, so if it wants to catch up on messages published by other clients 
+      #               call to {Ably::Realtime::Connection#connect}. Once the connection has been re-established,
+      #               channels will be automatically re-attached. The client has been disconnected for too long for them
+      #               to resume from where they left off, so if it wants to catch up on messages published by other clients
       #               while it was disconnected, it needs to use the History API.
-      # CLOSING		  An explicit request by the developer to close the connection has been sent to the Ably service. 
-      #             If a reply is not received from Ably within a short period of time, the connection is forcibly 
+      # CLOSING		  An explicit request by the developer to close the connection has been sent to the Ably service.
+      #             If a reply is not received from Ably within a short period of time, the connection is forcibly
       #             terminated and the connection state becomes CLOSED.
-      # CLOSED		  The connection has been explicitly closed by the client. In the closed state, no reconnection attempts 
-      #             are made automatically by the library, and clients may not publish messages. No connection state is 
+      # CLOSED		  The connection has been explicitly closed by the client. In the closed state, no reconnection attempts
+      #             are made automatically by the library, and clients may not publish messages. No connection state is
       #             preserved by the service or by the library. A new connection attempt can be triggered by an explicit
       #             call to {Ably::Realtime::Connection#connect}, which results in a new connection.
       # FAILED		  This state is entered if the client library encounters a failure condition that it cannot recover from.
@@ -77,9 +79,6 @@ module Ably
       include Ably::Modules::UsesStateMachine
       ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
 
-      # Expected format for a connection recover key
-      RECOVER_REGEX = /^(?<recover>[^:]+):(?<connection_serial>[^:]+):(?<msg_serial>\-?\d+)$/
-
       # Defaults for automatic connection recovery and timeouts
       DEFAULTS = {
         channel_retry_timeout:      15, # when a channel becomes SUSPENDED, after this delay in seconds, the channel will automatically attempt to reattach if the connection is CONNECTED
@@ -113,16 +112,6 @@ module Ably
       #
       attr_reader :key
 
-      # The serial number of the last message to be received on this connection, used automatically by the library when
-      # recovering or resuming a connection. When recovering a connection explicitly, the recoveryKey is used in
-      # the recover client options as it contains both the key and the last message serial.
-      #
-      # @spec RTN10
-      #
-      # @return [Integer]
-      #
-      attr_reader :serial
-
       # An {Ably::Models::ErrorInfo} object describing the last error received if a connection failure occurs.
       #
       # @spec RTN14a
@@ -177,17 +166,6 @@ module Ably
         end if options.kind_of?(Hash)
         @defaults.freeze
 
-        # If a recover client options is provided, then we need to ensure that the msgSerial matches the
-        # recover serial immediately at client library instantiation. This is done immediately so that any queued
-        # publishes use the correct serial number for these queued messages as well.
-        # There is no harm if the msgSerial is higher than expected if the recover fails.
-        recovery_msg_serial = connection_recover_parts && connection_recover_parts[:msg_serial].to_i
-        if recovery_msg_serial
-          @client_msg_serial = recovery_msg_serial
-        else
-          reset_client_msg_serial
-        end
-
         Client::IncomingMessageDispatcher.new client, self
         Client::OutgoingMessageDispatcher.new client, self
 
@@ -196,6 +174,8 @@ module Ably
         @manager       = ConnectionManager.new(self)
 
         @current_host = client.endpoint.host
+
+        reset_client_msg_serial
       end
 
       # Causes the connection to close, entering the {Ably::Realtime::Connection::STATE} CLOSING state.
@@ -347,33 +327,40 @@ module Ably
         end
       end
 
-      # The recovery key string can be used by another client to recover this connection's state in the recover client options property. See connection state recover options for more information.
+      # The recovery key string can be used by another client to recover this connection's state in the
+      # recover client options property. See connection state recover options for more information.
       #
       # @spec RTN16b, RTN16c
       #
-      # @return [String]
+      # @deprecated Use {#create_recovery_key} instead
       #
       def recovery_key
-        "#{key}:#{serial}:#{client_msg_serial}" if connection_resumable?
+        logger.warn "[DEPRECATION] recovery_key is deprecated, use create_recovery_key method instead"
+        create_recovery_key
+      end
+
+      # The recovery key string can be used by another client to recover this connection's state in the recover client
+      # options property. See connection state recover options for more information.
+      #
+      # @spec RTN16g, RTN16c
+      #
+      # @return [String] a json string which incorporates the @connectionKey@, the current @msgSerial@ and collection
+      # of pairs of channel @name@ and current @channelSerial@ for every currently attached channel
+      def create_recovery_key
+        if key.nil_or_empty? || state == :closing || state == :closed || state == :failed || state == :suspended
+          return nil #RTN16g2
+        end
+        RecoveryKeyContext.new(key, client_msg_serial, client.channels.get_channel_serials).to_json
       end
 
       # Following a new connection being made, the connection ID, connection key
-      # and connection serial need to match the details provided by the server.
+      # need to match the details provided by the server.
       #
       # @return [void]
       # @api private
-      def configure_new(connection_id, connection_key, connection_serial)
+      def configure_new(connection_id, connection_key)
         @id            = connection_id
         @key           = connection_key
-
-        update_connection_serial connection_serial
-      end
-
-      # Store last received connection serial so that the connection can be resumed from the last known point-in-time
-      # @return [void]
-      # @api private
-      def update_connection_serial(connection_serial)
-        @serial = connection_serial
       end
 
       # Disable automatic resume of a connection
@@ -381,7 +368,7 @@ module Ably
       # @api private
       def reset_resume_info
         @key    = nil
-        @serial = nil
+        @id     = nil
       end
 
       # @!attribute [r] __outgoing_protocol_msgbus__
@@ -444,17 +431,28 @@ 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, logger: logger).tap do |message|
-            add_message_to_outgoing_queue message
-            notify_message_dispatcher_of_new_message message
-            logger.debug { "Connection: Prot msg queued =>: #{message.action} #{message}" }
-          end
+          message = Ably::Models::ProtocolMessage.new(protocol_message, logger: logger)
+          add_message_to_outgoing_queue(message)
+          notify_message_dispatcher_of_new_message message
         end
       end
 
+      def send_protocol_message_immediately(protocol_message)
+        message = Ably::Models::ProtocolMessage.new(protocol_message, logger: logger)
+        add_message_to_outgoing_queue(message, true)
+        notify_message_dispatcher_of_new_message message
+      end
+
       # @api private
-      def add_message_to_outgoing_queue(protocol_message)
-        __outgoing_message_queue__ << protocol_message
+      def add_message_to_outgoing_queue(protocol_message, send_immediately = false)
+        if send_immediately
+          # Adding msg at the top of the queue to get processed immediately while connection is CONNECTED
+          __outgoing_message_queue__.prepend(protocol_message)
+          logger.debug { "Connection: protocol msg pushed at the top =>: #{protocol_message.action} #{protocol_message}" }
+        else
+          __outgoing_message_queue__ << protocol_message
+          logger.debug { "Connection: protocol msg queued =>: #{protocol_message.action} #{protocol_message}" }
+        end
       end
 
       # @api private
@@ -472,7 +470,7 @@ module Ably
               url_params = auth_params.merge(
                 'format' =>     client.protocol,
                 'echo' =>       client.echo_messages,
-                'v' =>          Ably::PROTOCOL_VERSION,
+                'v' =>          Ably::PROTOCOL_VERSION, # RSC7a
                 'agent' =>      client.rest_client.agent
               )
 
@@ -482,18 +480,19 @@ module Ably
               else
                 'false'
               end
-
-              url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?
+              # RSA7e1
+              url_params['clientId'] = client.auth.client_id_for_request_sync if client.auth.client_id_for_request_sync
               url_params.merge!(client.transport_params)
 
-              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], connectionSerial: connection_recover_parts[:connection_serial]
-                logger.debug { "Recovering connection with key #{client.recover}" }
-                unsafe_once(:connected, :closed, :failed) do
-                  client.disable_automatic_connection_recovery
+              if !key.nil_or_empty? and connection_state_available?
+                url_params.merge! resume: key
+                logger.debug { "Resuming connection with key #{key}" }
+              elsif !client.recover.nil_or_empty?
+                recovery_context = RecoveryKeyContext.from_json(client.recover, logger)
+                unless recovery_context.nil?
+                  key = recovery_context.connection_key
+                  logger.debug { "Recovering connection with key #{key}" }
+                  url_params.merge! recover: key
                 end
               end
 
@@ -544,24 +543,6 @@ module Ably
         @details = connection_details
       end
 
-      # Executes registered callbacks for a successful connection resume event
-      # @api private
-      def trigger_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
-
       # Returns false if messages cannot be published as a result of message queueing being disabled
       # @api private
       def can_publish_messages?
@@ -600,6 +581,12 @@ module Ably
         @client_msg_serial = -1
       end
 
+      # Sets the client message serial from recover clientOption.
+      # @api private
+      def set_msg_serial_from_recover=(value)
+        @client_msg_serial = value
+      end
+
       # When a hearbeat or any other message from Ably is received
       # we know it's alive, see #RTN23
       # @api private
@@ -620,20 +607,12 @@ module Ably
       private
 
       # The client message serial (msgSerial) is incremented for every message that is published that requires an ACK.
-      # Note that this is different to the connection serial that contains the last known serial number
-      # received from the server.
-      #
       # A message serial number does not guarantee a message has been received, only sent.
-      # A connection serial guarantees the server has received the message and is thus used for connection recovery and resumes.
       # @return [Integer] starting at -1 indicating no messages sent, 0 when the first message is sent
       def client_msg_serial
         @client_msg_serial
       end
 
-      def resume_callbacks
-        @resume_callbacks ||= []
-      end
-
       def create_pub_sub_message_bus
         Ably::Util::PubSub.new(
           coerce_into: lambda do |event|
@@ -665,10 +644,6 @@ module Ably
         EventMachine.next_tick { yield }
       end
 
-      def connection_resumable?
-        !key.nil? && !serial.nil? && connection_state_available?
-      end
-
       def connection_state_available?
         return true if connected?
 
@@ -682,14 +657,6 @@ module Ably
         end
       end
 
-      def connection_recoverable?
-        connection_recover_parts
-      end
-
-      def connection_recover_parts
-        client.recover.to_s.match(RECOVER_REGEX)
-      end
-
       def production?
         client.environment.nil? || client.environment == :production
       end
@@ -740,3 +707,4 @@ end
 require 'ably/realtime/connection/connection_manager'
 require 'ably/realtime/connection/connection_state_machine'
 require 'ably/realtime/connection/websocket_transport'
+require 'ably/realtime/recovery_key_context'

data/lib/ably/realtime/presence/members_map.rb

@@ -23,7 +23,7 @@ module Ably::Realtime
         :sync_starting, # Indicates the client is waiting for SYNC ProtocolMessages from Ably
         :sync_none, # Indicates the ATTACHED ProtocolMessage had no presence flag and thus no members on the channel
         :finalizing_sync,
-        :in_sync,
+        :sync_complete, # Indicates completion of server initiated sync
         :failed
       )
       include Ably::Modules::StateEmitter
@@ -49,16 +49,6 @@ module Ably::Realtime
         setup_event_handlers
       end
 
-      # When attaching to a channel that has members present, the server
-      # initiates a sync automatically so that the client has a complete list of members.
-      #
-      # Until this sync is complete, this method returns false
-      #
-      # @return [Boolean]
-      def sync_complete?
-        in_sync?
-      end
-
       # Update the SYNC serial from the ProtocolMessage so that SYNC can be resumed.
       # If the serial is nil, or the part after the first : is empty, then the SYNC is complete
       #
@@ -110,27 +100,27 @@ module Ably::Realtime
           # Must be defined before subsequent procs reference this callback
           reset_callbacks = nil
 
-          in_sync_callback = lambda do
+          sync_complete_callback = lambda do
             reset_callbacks.call if reset_callbacks
             result_block.call
           end
 
-          failed_callback = lambda do |error|
+          sync_failed_callback = lambda do |error|
             reset_callbacks.call if reset_callbacks
             deferrable.fail error
           end
 
           reset_callbacks = lambda do
-            off(&in_sync_callback)
-            off(&failed_callback)
-            channel.off(&failed_callback)
+            off(&sync_complete_callback)
+            off(&sync_failed_callback)
+            channel.off(&sync_failed_callback)
           end
 
-          unsafe_once(:in_sync, &in_sync_callback)
-          unsafe_once(:failed, &failed_callback)
+          unsafe_once(:sync_complete, &sync_complete_callback)
+          unsafe_once(:failed, &sync_failed_callback)
 
           channel.unsafe_once(:detaching, :detached, :failed) do |error_reason|
-            failed_callback.call error_reason
+            sync_failed_callback.call error_reason
           end
         end
 
@@ -156,12 +146,33 @@ module Ably::Realtime
       # and thus the responsibility of this library to re-enter on the channel automatically if the
       # channel loses continuity
       #
-      # @return [Array<PresenceMessage>]
+      # @return [Hash<String, PresenceMessage>]
       # @api private
       def local_members
         @local_members
       end
 
+      def enter_local_members
+        local_members.values.each do |member|
+          logger.debug { "#{self.class.name}: Manually re-entering local presence member, client ID: #{member.client_id} with data: #{member.data}" }
+          presence.enter_client_with_id(member.id, member.client_id, member.data).tap do |deferrable|
+            deferrable.errback do |error|
+              re_enter_error = Ably::Models::ErrorInfo.new(
+                message: "unable to automatically re-enter presence channel for client_id '#{member.client_id}'. Source error code #{error.code} and message '#{error.message}'",
+                code: Ably::Exceptions::Codes::UNABLE_TO_AUTOMATICALLY_REENTER_PRESENCE_CHANNEL
+              )
+              channel.emit :update, Ably::Models::ChannelStateChange.new(
+                current: channel.state,
+                previous: channel.state,
+                event: Ably::Realtime::Channel::EVENT(:update),
+                reason: re_enter_error,
+                resumed: true
+              )
+            end
+          end
+        end
+      end
+
       private
       attr_reader :sync_session_id
 
@@ -213,23 +224,14 @@ module Ably::Realtime
           update_members_and_emit_events presence_message
         end
 
+        # RTP5a
         channel.unsafe_on(:failed, :detached) do
           reset_members
           reset_local_members
         end
 
-        resume_sync_proc = method(:resume_sync).to_proc
-
         unsafe_on(:sync_starting) do
           @sync_session_id += 1
-
-          channel.unsafe_once(:attached) do
-            connection.on_resume(&resume_sync_proc)
-          end
-
-          unsafe_once(:in_sync, :failed) do
-            connection.off_resume(&resume_sync_proc)
-          end
         end
 
         unsafe_on(:sync_none) do
@@ -240,61 +242,9 @@ module Ably::Realtime
 
         unsafe_on(:finalizing_sync) do
           clean_up_absent_members
-          clean_up_members_not_present_in_sync
-          change_state :in_sync
+          clean_up_members_not_present_after_sync
+          change_state :sync_complete
         end
-
-        unsafe_on(:in_sync) do
-          update_local_member_state
-        end
-      end
-
-      # Listen for events that change the PresenceMap state and thus
-      # need to be replicated to the local member set
-      def update_local_member_state
-        new_local_members = members.select do |member_key, member|
-          member.fetch(:message).connection_id == connection.id
-        end.each_with_object({}) do |(member_key, member), hash_object|
-          hash_object[member_key] = member.fetch(:message)
-        end
-
-        @local_members.reject do |member_key, message|
-          new_local_members.keys.include?(member_key)
-        end.each do |member_key, message|
-          re_enter_local_member_missing_from_presence_map message
-        end
-
-        @local_members = new_local_members
-      end
-
-      def re_enter_local_member_missing_from_presence_map(presence_message)
-        local_client_id = presence_message.client_id || client.auth.client_id
-        logger.debug { "#{self.class.name}: Manually re-entering local presence member, client ID: #{local_client_id} with data: #{presence_message.data}" }
-        presence.enter_client(local_client_id, presence_message.data).tap do |deferrable|
-          deferrable.errback do |error|
-            presence_message_client_id = presence_message.client_id || client.auth.client_id
-            re_enter_error = Ably::Models::ErrorInfo.new(
-              message: "unable to automatically re-enter presence channel for client_id '#{presence_message_client_id}'. Source error code #{error.code} and message '#{error.message}'",
-              code: Ably::Exceptions::Codes::UNABLE_TO_AUTOMATICALLY_REENTER_PRESENCE_CHANNEL
-            )
-            channel.emit :update, Ably::Models::ChannelStateChange.new(
-              current: channel.state,
-              previous: channel.state,
-              event: Ably::Realtime::Channel::EVENT(:update),
-              reason: re_enter_error,
-              resumed: true
-            )
-          end
-        end
-      end
-
-      # Trigger a manual SYNC operation to resume member synchronisation from last known cursor position
-      def resume_sync
-        connection.send_protocol_message(
-          action:         Ably::Models::ProtocolMessage::ACTION.Sync.to_i,
-          channel:        channel.name,
-          channel_serial: sync_serial
-        ) if channel.attached?
       end
 
       def update_members_and_emit_events(presence_message)
@@ -375,7 +325,7 @@ module Ably::Realtime
       def remove_presence_member(presence_message)
         logger.debug { "#{self.class.name}: Member '#{presence_message.member_key}' removed.\n#{presence_message.to_json}" }
 
-        if in_sync?
+        if sync_complete?
           member_set_delete presence_message
         else
           member_set_upsert presence_message, false
@@ -394,17 +344,16 @@ module Ably::Realtime
       def member_set_upsert(presence_message, present)
         members[presence_message.member_key] = { present: present, message: presence_message, sync_session_id: sync_session_id }
         if presence_message.connection_id == connection.id
-          local_members[presence_message.member_key] = presence_message
-          logger.debug { "#{self.class.name}: Local member '#{presence_message.member_key}' added" }
+          local_members[presence_message.client_id] = presence_message
+          logger.debug { "#{self.class.name}: Local member '#{presence_message.client_id}' added" }
         end
       end
 
       def member_set_delete(presence_message)
         members.delete presence_message.member_key
-        if in_sync?
-          # If not in SYNC, then local members missing may need to be re-entered
-          # Let #update_local_member_state handle missing members
-          local_members.delete presence_message.member_key
+        if sync_complete? and presence_message.connection_id == connection.id
+          local_members.delete presence_message.client_id
+          logger.debug { "#{self.class.name}: Local member '#{presence_message.client_id}' deleted" }
         end
       end
 
@@ -431,7 +380,7 @@ module Ably::Realtime
         end
       end
 
-      def clean_up_members_not_present_in_sync
+      def clean_up_members_not_present_after_sync
         members.select do |member_key, member|
           member.fetch(:sync_session_id) != sync_session_id
         end.each do |member_key, member|

data/lib/ably/realtime/presence/presence_manager.rb

@@ -19,13 +19,19 @@ module Ably::Realtime
         setup_channel_event_handlers
       end
 
-      # Expect SYNC ProtocolMessages from the server with a list of current members on this channel
-      #
-      # @return [void]
-      #
       # @api private
-      def sync_expected
-        presence.members.change_state :sync_starting
+      def on_attach(has_presence_flag)
+        # RTP1
+        if has_presence_flag
+          # Expect SYNC ProtocolMessages from the server with a list of current members on this channel
+          presence.members.change_state :sync_starting
+        else
+          # There server has indicated that there are no SYNC ProtocolMessages to come because
+          # there are no members on this channel
+          logger.debug { "#{self.class.name}: Emitting leave events for all members as a SYNC is not expected and thus there are no members on the channel" }
+          presence.members.change_state :sync_none
+        end
+        presence.members.enter_local_members # RTP17f
       end
 
       # Process presence messages from SYNC messages. Sync can be server-initiated or triggered following ATTACH
@@ -47,17 +53,6 @@ module Ably::Realtime
         presence.members.change_state :finalizing_sync if presence.members.sync_serial_cursor_at_end?
       end
 
-      # There server has indicated that there are no SYNC ProtocolMessages to come because
-      # there are no members on this channel
-      #
-      # @return [void]
-      #
-      # @api private
-      def sync_not_expected
-        logger.debug { "#{self.class.name}: Emitting leave events for all members as a SYNC is not expected and thus there are no members on the channel" }
-        presence.members.change_state :sync_none
-      end
-
       private
       def_delegators :presence, :members, :channel
 

data/lib/ably/realtime/presence.rb

@@ -110,6 +110,14 @@ module Ably::Realtime
       send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Enter, client_id, data, &success_block)
     end
 
+    # @api private
+    def enter_client_with_id(id, client_id, data = nil, &success_block)
+      ensure_supported_client_id client_id
+      ensure_supported_payload data
+
+      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Enter, client_id, data, id, &success_block)
+    end
+
     # Leave this client from this channel. This client will be removed from the presence
     # set and presence subscribers will see a leave message for this client.
     #
@@ -338,8 +346,8 @@ module Ably::Realtime
 
     private
     # @return [Ably::Models::PresenceMessage] presence message is returned allowing callbacks to be added
-    def send_presence_protocol_message(presence_action, client_id, data)
-      presence_message = create_presence_message(presence_action, client_id, data)
+    def send_presence_protocol_message(presence_action, client_id, data, id = nil)
+      presence_message = create_presence_message(presence_action, client_id, data, id)
       unless presence_message.client_id
         raise Ably::Exceptions::Standard.new('Unable to enter create presence message without a client_id', 400, Ably::Exceptions::Codes::UNABLE_TO_ENTER_PRESENCE_CHANNEL_NO_CLIENTID)
       end
@@ -355,12 +363,13 @@ module Ably::Realtime
       presence_message
     end
 
-    def create_presence_message(action, client_id, data)
+    def create_presence_message(action, client_id, data, id = nil)
       model = {
         action:   Ably::Models::PresenceMessage.ACTION(action).to_i,
         clientId: client_id,
-        data:     data
+        data:     data,
       }
+      model[:id] = id unless id.nil?
 
       Ably::Models::PresenceMessage.new(model, logger: logger).tap do |presence_message|
         presence_message.encode(client.encoders, channel.options) do |encode_error, error_message|
@@ -433,13 +442,13 @@ module Ably::Realtime
       deferrable
     end
 
-    def send_presence_action_for_client(action, client_id, data, &success_block)
+    def send_presence_action_for_client(action, client_id, data, id = nil, &success_block)
       requirements_failed_deferrable = ensure_presence_publishable_on_connection_deferrable
       return requirements_failed_deferrable if requirements_failed_deferrable
 
       deferrable = create_deferrable
       ensure_channel_attached(deferrable) do
-        send_presence_protocol_message(action, client_id, data).tap do |protocol_message|
+        send_presence_protocol_message(action, client_id, data, id).tap do |protocol_message|
           protocol_message.callback { |message| deferrable_succeed deferrable, &success_block }
           protocol_message.errback  { |error| deferrable_fail deferrable, error }
         end