ably 0.8.5 → 0.8.6

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

@@ -73,7 +73,7 @@ module Ably::Realtime
             elsif connection.connected?
               logger.error "CONNECTED ProtocolMessage should not have been received when the connection is in the CONNECTED state"
             else
-              connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
+              process_connected_message protocol_message
             end
 
           when ACTION.Disconnect, ACTION.Disconnected
@@ -141,6 +141,16 @@ module Ably::Realtime
         connection.manager.error_received_from_server protocol_message.error
       end
 
+      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
+          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)
+          connection.transition_state_machine :failed, reason: reason, protocol_message: protocol_message
+        end
+      end
+
       def update_connection_recovery_info(protocol_message)
         connection.update_connection_serial protocol_message.connection_serial if protocol_message.has_connection_serial?
       end

data/lib/ably/realtime/client.rb

@@ -30,6 +30,10 @@ module Ably
       # (see Ably::Rest::Client#auth)
       attr_reader :auth
 
+      # The underlying connection for this client
+      # @return [Aby::Realtime::Connection]
+      attr_reader :connection
+
       # 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
@@ -69,6 +73,9 @@ 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
+      #
       # @return [Ably::Realtime::Client]
       #
       # @example
@@ -82,6 +89,7 @@ module Ably
         @rest_client           = Ably::Rest::Client.new(options)
         @auth                  = Ably::Realtime::Auth.new(self)
         @channels              = Ably::Realtime::Channels.new(self)
+        @connection            = Ably::Realtime::Connection.new(self, options)
         @echo_messages         = @rest_client.options.fetch(:echo_messages, true) == false ? false : true
         @queue_messages        = @rest_client.options.fetch(:queue_messages, true) == false ? false : true
         @custom_realtime_host  = @rest_client.options[:realtime_host] || @rest_client.options[:ws_host]
@@ -142,10 +150,9 @@ module Ably
         endpoint_for_host(custom_realtime_host || [environment, DOMAIN].compact.join('-'))
       end
 
-      # @!attribute [r] connection
-      # @return [Aby::Realtime::Connection] The underlying connection for this client
+
       def connection
-        @connection ||= Connection.new(self)
+        @connection
       end
 
       # (see Ably::Rest::Client#register_encoder)

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

@@ -8,18 +8,6 @@ module Ably::Realtime
     #
     # @api private
     class ConnectionManager
-      # Configuration for automatic recovery of failed connection attempts
-      CONNECT_RETRY_CONFIG = {
-        disconnected: { retry_every: 15,  max_time_in_state: 120 },
-        suspended:    { retry_every: 120, max_time_in_state: Float::INFINITY }
-      }.freeze
-
-      # Time to wait following a connection state request before it's considered a failure
-      TIMEOUTS = {
-        open:  15,
-        close: 10
-      }
-
       # Error codes from the server that can potentially be resolved
       RESOLVABLE_ERROR_CODES = {
         token_expired: 40140
@@ -69,9 +57,9 @@ module Ably::Realtime
           end
         end
 
-        logger.debug "ConnectionManager: Setting up automatic connection timeout timer for #{TIMEOUTS.fetch(:open)}s"
-        create_timeout_timer_whilst_in_state(:connect, TIMEOUTS.fetch(:open)) do
-          connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{TIMEOUTS.fetch(:open)}s", nil, 80014)
+        logger.debug "ConnectionManager: Setting up automatic connection timeout timer for #{realtime_request_timeout}s"
+        create_timeout_timer_whilst_in_state(:connect, realtime_request_timeout) do
+          connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{realtime_request_timeout}s", nil, 80014)
         end
       end
 
@@ -79,6 +67,11 @@ module Ably::Realtime
       #
       # @api private
       def connection_opening_failed(error)
+        if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
+          client.connection.transition_state_machine :failed, reason: error
+          return
+        end
+
         logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
         next_state = get_next_retry_state_info
         connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
@@ -89,18 +82,17 @@ module Ably::Realtime
       # @api private
       def connected(protocol_message)
         if connection.key
-          if connection_key_shared(protocol_message.connection_key) == connection_key_shared(connection.key)
+          if protocol_message.connection_id == connection.id
             logger.debug "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}"
             EventMachine.next_tick { connection.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
+        connection.configure_new protocol_message.connection_id, protocol_message.connection_key, protocol_message.connection_serial
       end
 
       # Ensures the underlying transport has been disconnected and all event emitter callbacks removed
@@ -131,7 +123,7 @@ module Ably::Realtime
       def close_connection
         connection.send_protocol_message(action: Ably::Models::ProtocolMessage::ACTION.Close)
 
-        create_timeout_timer_whilst_in_state(:close, TIMEOUTS.fetch(:close)) do
+        create_timeout_timer_whilst_in_state(:close, realtime_request_timeout) do
           force_close_connection if connection.closing?
         end
       end
@@ -158,19 +150,23 @@ module Ably::Realtime
       # @api private
       def respond_to_transport_disconnected_when_connecting(error)
         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
+        return unless can_retry_connection? # do not always reattempt connection or change state as client may be re-authorising
 
         if error.kind_of?(Ably::Models::ErrorInfo)
-          renew_token_and_reconnect error if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
-          return
+          if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
+            next_state = get_next_retry_state_info
+            logger.debug "ConnectionManager: Transport disconnected because of token expiry, pausing #{next_state.fetch(:pause)}s before reattempting to connect"
+            EventMachine.add_timer(next_state.fetch(:pause)) { renew_token_and_reconnect error }
+            return
+          end
         end
 
-        unless connection_retry_from_suspended_state?
+        if connection.state == :suspended
+          return if connection_retry_for(:suspended)
+        elsif connection.state == :disconnected
           return if connection_retry_for(:disconnected)
         end
 
-        return if connection_retry_for(:suspended)
-
         # Fallback if no other criteria met
         connection.transition_state_machine :failed, reason: error
       end
@@ -179,7 +175,11 @@ module Ably::Realtime
       #
       # @api private
       def respond_to_transport_disconnected_whilst_connected(error)
-        logger.warn "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly"
+        unless connection.disconnected? || connection.suspended?
+          logger.warn "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly"
+        else
+          logger.debug "ConnectionManager: Transport disconnected whilst connection in #{connection.state} state"
+        end
 
         if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           connection.emit :error, error
@@ -197,10 +197,8 @@ module Ably::Realtime
       def error_received_from_server(error)
         case error.code
         when RESOLVABLE_ERROR_CODES.fetch(:token_expired)
-          connection.transition_state_machine :disconnected, retry_in: 0
-          connection.unsafe_once_or_if(:disconnected) do
-            renew_token_and_reconnect error
-          end
+          next_state = get_next_retry_state_info
+          connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: error
         else
           logger.error "ConnectionManager: Error #{error.class.name} code #{error.code} received from server '#{error.message}', transitioning to failed state"
           connection.transition_state_machine :failed, reason: error
@@ -233,10 +231,16 @@ module Ably::Realtime
         client.channels
       end
 
-      # Connection key left part is consistent between connection resumes
-      # i.e. wVIsgTHAB1UvXh7z-1991d8586 becomes wVIsgTHAB1UvXh7z-1990d8586 after a resume
-      def connection_key_shared(connection_key)
-        (connection_key || '')[/^\w{5,}-/, 0]
+      def realtime_request_timeout
+        connection.defaults.fetch(:realtime_request_timeout)
+      end
+
+      def retry_timeout_for(state)
+        connection.defaults.fetch("#{state}_retry_timeout".to_sym) { raise ArgumentError.new("#{state} does not have a configured retry timeout") }
+      end
+
+      def state_has_retry_timeout?(state)
+        connection.defaults.has_key?("#{state}_retry_timeout".to_sym)
       end
 
       # Create a timer that will execute in timeout_in seconds.
@@ -267,12 +271,12 @@ module Ably::Realtime
       end
 
       def next_retry_pause(retry_state)
-        return nil unless CONNECT_RETRY_CONFIG.fetch(retry_state)
+        return nil unless state_has_retry_timeout?(retry_state)
 
         if retries_for_state(retry_state, ignore_states: [:connecting]).empty?
           0
         else
-          CONNECT_RETRY_CONFIG.fetch(retry_state).fetch(:retry_every)
+          retry_timeout_for(retry_state)
         end
       end
 
@@ -284,20 +288,18 @@ module Ably::Realtime
         time_spent_attempting_state(:disconnected, ignore_states: [:connecting])
       end
 
-      # Reattempt a connection with a delay based on the CONNECT_RETRY_CONFIG for `from_state`
+      # Reattempt a connection with a delay based on the configured retry timeout for +from_state+
       #
       # @return [Boolean] True if a connection attempt has been set up, false if no further connection attempts can be made for this state
       #
       def connection_retry_for(from_state)
-        retry_params = CONNECT_RETRY_CONFIG.fetch(from_state)
-
         if can_reattempt_connect_for_state?(from_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"
+          if connection.state == :disconnected && retries_for_state(from_state, ignore_states: [:connecting]).empty?
+            logger.debug "ConnectionManager: Will attempt reconnect immediately as no previous reconnect attempts made in state #{from_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
+            logger.debug "ConnectionManager: Pausing for #{retry_timeout_for(from_state)}s before attempting to reconnect"
+            create_timeout_timer_whilst_in_state(from_state, retry_timeout_for(from_state)) do
               connection.connect if connection.state == from_state
             end
           end
@@ -309,8 +311,14 @@ module Ably::Realtime
       # For example, if the state is disconnected, and has been in a cycle of disconnected > connect > disconnected
       #  so long as the time in this cycle of states is less than max_time_in_state, this will return true
       def can_reattempt_connect_for_state?(state)
-        retry_params = CONNECT_RETRY_CONFIG.fetch(state)
-        time_spent_attempting_state(state, ignore_states: [:connecting]) < retry_params.fetch(:max_time_in_state)
+        case state
+        when :disconnected
+          time_spent_attempting_state(:disconnected, ignore_states: [:connecting]) < connection.defaults.fetch(:connection_state_ttl)
+        when :suspended
+          true # suspended state remains indefinitely
+        else
+          raise ArgumentError, "Connections in state '#{state}' cannot be reattempted"
+        end
       end
 
       # Returns a float representing the amount of time passed since the first consecutive attempt of this state
@@ -380,23 +388,18 @@ module Ably::Realtime
       def renew_token_and_reconnect(error)
         if client.auth.token_renewable?
           if @renewing_token
-            connection.transition_state_machine :failed, reason: error
+            logger.error 'ConnectionManager: Attempting to renew token whilst another token renewal is underway. Aborting current renew token request'
             return
           end
 
           @renewing_token = true
           logger.info "ConnectionManager: Token has expired and is renewable, renewing token now"
 
-          client.auth.authorise.tap do |authorise_deferrable|
+          client.auth.authorise({}, force: true).tap do |authorise_deferrable|
             authorise_deferrable.callback do |token_details|
               logger.info 'ConnectionManager: Token renewed succesfully following expiration'
 
-              state_changed_callback = proc do
-                @renewing_token = false
-                connection.off &state_changed_callback
-              end
-
-              connection.unsafe_once :connected, :closed, :failed, &state_changed_callback
+              connection.once_state_changed { @renewing_token = false }
 
               if token_details && !token_details.expired?
                 connection.connect
@@ -406,6 +409,7 @@ module Ably::Realtime
             end
 
             authorise_deferrable.errback do |auth_error|
+              @renewing_token = false
               logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
               connection.transition_state_machine :failed, reason: auth_error
             end
@@ -428,7 +432,7 @@ module Ably::Realtime
         end
       end
 
-      def retry_connection?
+      def can_retry_connection?
         !@renewing_token
       end
 

data/lib/ably/realtime/connection.rb

@@ -60,6 +60,14 @@ module Ably
       # Expected format for a connection recover key
       RECOVER_REGEX = /^(?<recover>[\w-]+):(?<connection_serial>\-?\w+)$/
 
+      # Defaults for automatic connection recovery and timeouts
+      DEFAULTS = {
+        disconnected_retry_timeout: 15, # 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
+        suspended_retry_timeout:    30, # 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
+        connection_state_ttl:       60, # the duration that Ably will persist the connection state when a Realtime client is abruptly disconnected
+        realtime_request_timeout:   10  # default timeout when establishing a connection, or sending a HEARTBEAT, CONNECT, ATTACH, DETACH or CLOSE ProtocolMessage
+      }.freeze
+
       # A unique public identifier for this connection, used to identify this member in presence events and messages
       # @return [String]
       attr_reader :id
@@ -90,23 +98,35 @@ module Ably
       # @api private
       attr_reader :manager
 
-      # An internal queue used to manage unsent outgoing messages.  You should never interface with this array directly
+      # 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__
 
-      # An internal queue used to manage sent messages.  You should never interface with this array directly
+      # An internal queue used to manage sent messages. You should never interface with this array directly
       # @return [Array]
       # @api private
       attr_reader :__pending_message_ack_queue__
 
+      # Configured recovery and timeout defaults for this {Connection}.
+      # See the configurable options in {Ably::Realtime::Client#initialize}.
+      # The defaults are immutable
+      # @return [Hash]
+      attr_reader :defaults
+
       # @api public
-      def initialize(client)
+      def initialize(client, options)
         @client                        = client
         @client_serial                 = -1
         @__outgoing_message_queue__    = []
         @__pending_message_ack_queue__ = []
 
+        @defaults = DEFAULTS.dup
+        options.each do |key, val|
+          @defaults[key] = val if DEFAULTS.has_key?(key)
+        end if options.kind_of?(Hash)
+        @defaults.freeze
+
         Client::IncomingMessageDispatcher.new client, self
         Client::OutgoingMessageDispatcher.new client, self
 
@@ -133,6 +153,11 @@ module Ably
 
       # 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.
+      # Succeeds when connection is established i.e. state is @Connected@
+      # Fails when state becomes either @Closing@, @Closed@ or @Failed@
+      #
+      # Note that if the connection remains in the disconnected ans suspended states indefinitely,
+      # the Deferrable or block provided may never be called
       #
       # @yield block is called as soon as this connection is in the Connected state
       #
@@ -143,14 +168,32 @@ module Ably
           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)
+
+        Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
+          deferrable.callback do
+            yield if block_given?
+          end
+          succeed_callback = deferrable.method(:succeed)
+          fail_callback    = deferrable.method(:fail)
+
+          once(:connected) do
+            deferrable.succeed
+            off &fail_callback
+          end
+
+          once(:failed, :closed, :closing) do
+            deferrable.fail
+            off &succeed_callback
+          end
+        end
       end
 
       # Sends a ping to Ably and yields the provided block when a heartbeat ping request is echoed from the server.
       # This can be useful for measuring true roundtrip client to Ably server latency for a simple message, or checking that an underlying transport is responding currently.
       # The elapsed milliseconds is passed as an argument to the block and represents the time taken to echo a ping heartbeat once the connection is in the `:connected` state.
       #
-      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in milliseconds
+      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in milliseconds.
+      #                  If the ping is not received within an acceptable timeframe, the block will be called with +nil+ as he first argument
       #
       # @example
       #    client = Ably::Rest::Client.new(key: 'key.id:secret')
@@ -165,9 +208,12 @@ module Ably
         raise RuntimeError, 'Cannot send a ping when connection is in a closed or failed state' if closed? || failed?
 
         started = nil
+        finished = false
 
         wait_for_ping = Proc.new do |protocol_message|
+          next if finished
           if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
+            finished = true
             __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
             time_passed = (Time.now.to_f * 1000 - started.to_f * 1000).to_i
             safe_yield block, time_passed if block_given?
@@ -175,10 +221,19 @@ module Ably
         end
 
         once_or_if(STATE.Connected) do
+          next if finished
           started = Time.now
           send_protocol_message action: Ably::Models::ProtocolMessage::ACTION.Heartbeat.to_i
           __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
         end
+
+        EventMachine.add_timer(defaults.fetch(:realtime_request_timeout)) do
+          next if finished
+          finished = true
+          __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
+          logger.warn "Ping timed out after #{defaults.fetch(:realtime_request_timeout)}s"
+          safe_yield block, nil if block_given?
+        end
       end
 
       # @yield [Boolean] True if an internet connection check appears to be up following an HTTP request to a reliable CDN
@@ -327,11 +382,12 @@ module Ably
           client.auth.auth_params.tap do |auth_deferrable|
             auth_deferrable.callback do |auth_params|
               url_params = auth_params.merge(
-                timestamp: as_since_epoch(Time.now),
                 format:    client.protocol,
                 echo:      client.echo_messages
               )
 
+              url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?
+
               if connection_resumable?
                 url_params.merge! resume: key, connection_serial: serial
                 logger.debug "Resuming connection key #{key} with serial #{serial}"

data/lib/ably/realtime/presence.rb

@@ -74,8 +74,8 @@ module Ably::Realtime
       data       = options.fetch(:data, nil)
       deferrable = create_deferrable
 
+      ensure_supported_client_id client_id
       ensure_supported_payload data unless data.nil?
-      raise Ably::Exceptions::Standard.new('Unable to enter presence channel without a client_id', 400, 91000) unless client_id
 
       @data = data
       @client_id = client_id
@@ -120,8 +120,8 @@ module Ably::Realtime
     #
     def enter_client(client_id, options = {}, &success_block)
       raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+      ensure_supported_client_id client_id
       ensure_supported_payload options[:data] if options.has_key?(:data)
-      raise Ably::Exceptions::Standard.new('Unable to enter presence channel without a client_id', 400, 91000) unless client_id
 
       send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Enter, client_id, options, &success_block)
     end
@@ -139,6 +139,7 @@ module Ably::Realtime
       data       = options.fetch(:data, self.data) # nil value defaults leave data to existing value
       deferrable = create_deferrable
 
+      ensure_supported_client_id client_id
       ensure_supported_payload data unless data.nil?
       raise Ably::Exceptions::Standard.new('Unable to leave presence channel that is not entered', 400, 91002) unless able_to_leave?
 
@@ -178,8 +179,8 @@ module Ably::Realtime
     #
     def leave_client(client_id, options = {}, &success_block)
       raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+      ensure_supported_client_id client_id
       ensure_supported_payload options[:data] if options.has_key?(:data)
-      raise Ably::Exceptions::Standard.new('Unable to leave presence channel without a client_id', 400, 91000) unless client_id
 
       send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Leave, client_id, options, &success_block)
     end
@@ -198,8 +199,8 @@ module Ably::Realtime
       data       = options.fetch(:data, nil)
       deferrable = create_deferrable
 
+      ensure_supported_client_id client_id
       ensure_supported_payload data unless data.nil?
-      raise Ably::Exceptions::Standard.new('Unable to update presence channel without a client_id', 400, 91000) unless client_id
 
       @data = data
 
@@ -230,8 +231,8 @@ module Ably::Realtime
     #
     def update_client(client_id, options = {}, &success_block)
       raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+      ensure_supported_client_id client_id
       ensure_supported_payload options[:data] if options.has_key?(:data)
-      raise Ably::Exceptions::Standard.new('Unable to enter presence channel without a client_id', 400, 91000) unless client_id
 
       send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Update, client_id, options, &success_block)
     end
@@ -387,6 +388,18 @@ module Ably::Realtime
       deferrable
     end
 
+    def ensure_supported_client_id(check_client_id)
+      unless check_client_id
+        raise Ably::Exceptions::IncompatibleClientId.new('Unable to enter/update/leave presence channel without a client_id', 400, 40012)
+      end
+      if check_client_id == '*'
+        raise Ably::Exceptions::IncompatibleClientId.new('Unable to enter/update/leave presence channel with the reserved wildcard client_id', 400, 40012)
+      end
+      unless client.auth.can_assume_client_id?(check_client_id)
+        raise Ably::Exceptions::IncompatibleClientId.new("Cannot enter with provided client_id '#{check_client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
+      end
+    end
+
     def send_protocol_message_and_transition_state_to(action, options = {}, &success_block)
       deferrable   = options.fetch(:deferrable) { raise ArgumentError, 'option :deferrable is required' }
       client_id    = options.fetch(:client_id)  { raise ArgumentError, 'option :client_id is required' }

data/lib/ably/rest/channel.rb

@@ -67,6 +67,14 @@ module Ably
         payload = messages.map do |message|
           Ably::Models::Message(message.dup).tap do |message|
             message.encode self
+
+            next if message.client_id.nil?
+            if message.client_id == '*'
+              raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages', 400, 40012)
+            end
+            unless client.auth.can_assume_client_id?(message.client_id)
+              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
+            end
           end.as_json
         end
 
@@ -123,7 +131,7 @@ module Ably
 
       private
       def base_path
-        "/channels/#{CGI.escape(name)}"
+        "/channels/#{Addressable::URI.encode(name)}"
       end
 
       def decode_message(message)