ably 0.8.5 → 0.8.6

data/ably.gemspec

@@ -8,10 +8,10 @@ Gem::Specification.new do |spec|
   spec.version       = Ably::VERSION
   spec.authors       = ['Lewis Marshall', "Matthew O'Riordan"]
   spec.email         = ['lewis@lmars.net', 'matt@ably.io']
-  spec.description   = %q{A Ruby client library for ably.io, the realtime messaging service}
-  spec.summary       = %q{A Ruby client library for ably.io, the realtime messaging service}
+  spec.description   = %q{A Ruby client library for ably.io realtime messaging}
+  spec.summary       = %q{A Ruby client library for ably.io realtime messaging implemented using EventMachine}
   spec.homepage      = 'http://github.com/ably/ably-ruby'
-  spec.license       = 'MIT'
+  spec.license       = 'Apache 2'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -25,14 +25,20 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'json'
   spec.add_runtime_dependency 'websocket-driver', '~> 0.3'
   spec.add_runtime_dependency 'msgpack', '>= 0.6.2'
+  spec.add_runtime_dependency 'addressable', '>= 2.0.0'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'redcarpet'
-  spec.add_development_dependency 'rspec', '~> 3.1.0' # version lock, see config.around(:example, :event_machine) in event_machine_helper.rb
+  spec.add_development_dependency 'rspec', '~> 3.2.0' # version lock, see config.around(:example, :event_machine) in event_machine_helper.rb
   spec.add_development_dependency 'rspec-retry'
   spec.add_development_dependency 'yard'
   spec.add_development_dependency 'webmock'
 
   spec.add_development_dependency 'coveralls'
+
+  if RUBY_VERSION.match(/^2/)
+    spec.add_development_dependency 'pry'
+    spec.add_development_dependency 'pry-byebug'
+  end
 end

data/lib/ably/auth.rb

@@ -13,8 +13,6 @@ module Ably
   #   @return [String] The provided client ID, used for identifying this client for presence purposes
   # @!attribute [r] current_token_details
   #   @return [Ably::Models::TokenDetails] Current {Ably::Models::TokenDetails} issued by this library or one of the provided callbacks used to authenticate requests
-  # @!attribute [r] token
-  #   @return [String] Token string provided to the {Ably::Client} constructor that is used to authenticate all requests
   # @!attribute [r] key
   #   @return [String] Complete API key containing both the key name and key secret, if present
   # @!attribute [r] key_name
@@ -61,6 +59,7 @@ module Ably
       @client              = client
       @options             = auth_options.dup
       @token_params        = token_params.dup
+      @token_option        = options[:token] || options[:token_details]
 
       @options.delete :force # Forcing token auth for every request is not a valid default
 
@@ -74,11 +73,25 @@ module Ably
         raise ArgumentError, 'key is missing. Either an API key, token, or token auth method must be provided'
       end
 
-      if has_client_id? && !token_creatable_externally?
-        raise ArgumentError, 'client_id cannot be provided without a complete API key. Key name & Secret is needed to authenticate with Ably and obtain a token' unless api_key_present?
+      if options[:client_id] == '*'
+        raise ArgumentError, 'A client cannot be configured with a wildcard client_id'
+      end
+
+      if has_client_id? && !token_creatable_externally? && !token_option
+        raise ArgumentError, 'client_id cannot be provided without a complete API key or means to authenticate. An API key is needed to automatically authenticate with Ably and obtain a token' unless api_key_present?
         ensure_utf_8 :client_id, client_id
       end
 
+      # If a token details object or token string is provided in the initializer
+      # then the client can be authorised immediately using this token
+      if token_option
+        token_details = convert_to_token_details(token_option)
+        if token_details
+          token_details = authorise_with_token(token_details)
+          logger.debug "Auth: new token passed in to the initializer: #{token_details}"
+        end
+      end
+
       @options.freeze
       @token_params.freeze
     end
@@ -120,7 +133,9 @@ module Ably
       token_params = (auth_options.delete(:token_params) || {}).merge(token_params)
       @token_params = @token_params.merge(token_params) # update defaults
 
-      @current_token_details = request_token(token_params, auth_options)
+      authorise_with_token(request_token(token_params, auth_options)).tap do |new_token_details|
+        logger.debug "Auth: new token following authorisation: #{new_token_details}"
+      end
     end
 
     # Request a {Ably::Models::TokenDetails} which can be used to make authenticated token based requests
@@ -154,34 +169,29 @@ module Ably
     def request_token(token_params = {}, auth_options = {})
       ensure_valid_auth_attributes auth_options
 
-      token_params = (auth_options[:token_params] || {}).merge(token_params)
-      token_params = self.token_params.merge(token_params)
+      # Token param precedence (lowest to highest):
+      #   Auth default => client_id => auth_options[:token_params] arg => token_params arg
+      token_params = self.token_params.merge(
+        (client_id ? { client_id: client_id } : {}).
+          merge(auth_options[:token_params] || {}).
+          merge(token_params)
+      )
+
       auth_options = self.options.merge(auth_options)
 
       token_request = if auth_callback = auth_options.delete(:auth_callback)
         auth_callback.call(token_params)
       elsif auth_url = auth_options.delete(:auth_url)
-        token_request_from_auth_url(auth_url, auth_options)
+        token_request_from_auth_url(auth_url, auth_options, token_params)
       else
         create_token_request(token_params, auth_options)
       end
 
-      case token_request
-        when Ably::Models::TokenDetails
-          return token_request
-        when Hash
-          return Ably::Models::TokenDetails.new(token_request) if IdiomaticRubyWrapper(token_request).has_key?(:issued)
-        when String
-          return Ably::Models::TokenDetails.new(token: token_request)
+      convert_to_token_details(token_request).tap do |token_details|
+        return token_details if token_details
       end
 
-      token_request = Ably::Models::TokenRequest(token_request)
-
-      response = client.post("/keys/#{token_request.key_name}/requestToken",
-                             token_request.hash, send_auth_header: false,
-                             disable_automatic_reauthorise: true)
-
-      Ably::Models::TokenDetails.new(response.body)
+      send_token_request(token_request)
     end
 
     # Creates and signs a token request that can then subsequently be used by any client to request a token
@@ -277,21 +287,23 @@ module Ably
     # True when Token Auth is being used to authenticate with Ably
     def using_token_auth?
       return options[:use_token_auth] if options.has_key?(:use_token_auth)
-      !!(token || current_token_details || has_client_id? || token_creatable_externally?)
+      !!(token_option || current_token_details || has_client_id? || token_creatable_externally?)
     end
 
     def client_id
-      options[:client_id]
+      @client_id || options[:client_id]
     end
 
-    def token
-      token_object = options[:token] || options[:token_details]
-
-      if token_object.kind_of?(Ably::Models::TokenDetails)
-        token_object.token
-      else
-        token_object
-      end
+    # When a client has authenticated with Ably and the client is either anonymous (cannot assume a +client_id+)
+    # or has an assigned +client_id+ (implicit in all operations), then this client has a validated +client_id+, even
+    # if that client_id is +nil+ (anonymous)
+    #
+    # Once validated by Ably, the client library will enforce the use of the +client_id+ identity provided by Ably, rejecting
+    # messages with an invalid +client_id+ immediately
+    #
+    # @return [Boolean]
+    def client_id_validated?
+      !!@client_id_validated
     end
 
     # Auth header string used in HTTP requests to Ably
@@ -327,7 +339,7 @@ module Ably
     #
     # @return [Boolean]
     def token_renewable?
-      token_creatable_externally? || (api_key_present? && !token)
+      token_creatable_externally? || (api_key_present? && !token_option)
     end
 
     # Returns false when attempting to send an API Key over a non-secure connection
@@ -338,8 +350,59 @@ module Ably
       client.use_tls? || using_token_auth?
     end
 
+    # True if token provided client_id is compatible with the client's configured +client_id+, when applicable
+    #
+    # @return [Boolean]
+    # @api private
+    def token_client_id_allowed?(token_client_id)
+      return true if client_id.nil? # no explicit client_id specified for this client
+      return true if client_id == '*' || token_client_id == '*' # wildcard supported always
+      token_client_id == client_id
+    end
+
+    # True if assumed_client_id is compatible with the client's configured or Ably assigned +client_id+
+    #
+    # @return [Boolean]
+    # @api private
+    def can_assume_client_id?(assumed_client_id)
+      if client_id_validated?
+        client_id == '*' || (client_id == assumed_client_id)
+      elsif !options[:client_id] || options[:client_id] == '*'
+        true # client ID is unknown
+      else
+        options[:client_id] == assumed_client_id
+      end
+    end
+
+    # Configures the client ID for this client
+    # Typically this occurs following an Auth or receiving a {Ably::Models::ProtocolMessage} with a +client_id+ in the {Ably::Models::ConnectionDetails}
+    #
+    # @api private
+    def configure_client_id(new_client_id)
+      # If new client ID from Ably is a wildcard, but preconfigured clientId is set, then keep the existing clientId
+      if has_client_id? && new_client_id == '*'
+        @client_id_validated = true
+        return
+      end
+
+      # If client_id is defined and not a wildcard, prevent it changing, this is not supported
+      if client_id && client_id != '*' &&  new_client_id != client_id
+        raise Ably::Exceptions::IncompatibleClientId.new("Client ID is immutable once configured for a client. Client ID cannot be changed to '#{new_client_id}'", 400, 40012)
+      end
+      @client_id_validated = true
+      @client_id = new_client_id
+    end
+
+    # True when a client_id other than a wildcard is configured for Auth
+    #
+    # @api private
+    def has_client_id?
+      client_id && (client_id != '*')
+    end
+
     private
     attr_reader :client
+    attr_reader :token_option
 
     def ensure_valid_auth_attributes(attributes)
       if attributes[:timestamp]
@@ -401,17 +464,21 @@ module Ably
 
     # Returns the current token if it exists or authorises and retrieves a token
     def token_auth_string
-      # If a TokenDetails object has been issued by this library
-      # then that Token will take precedence
-      if @current_token_details
-        authorise.token
-      elsif token # token string was configured in the options
-        token
+      if !current_token_details && token_option
+        # A TokenRequest was configured in the ClientOptions +:token field+ and no current token exists
+        # Note: If a Token or TokenDetails is provided in the initializer, the token is stored in +current_token_details+
+        authorise_with_token send_token_request(token_option)
+        current_token_details.token
       else
+        # Authorise will use the current token if one exists and is not expired, otherwise a new token will be issued
         authorise.token
       end
     end
 
+    def configure_current_token_details(token_details)
+      @current_token_details = token_details
+    end
+
     # Token Auth HTTP Authorization header value
     def token_auth_header
       "Bearer #{encode64(token_auth_string)}"
@@ -455,15 +522,20 @@ module Ably
     # Retrieve a token request from a specified URL, expects a JSON response
     #
     # @return [Hash]
-    def token_request_from_auth_url(auth_url, auth_options)
+    def token_request_from_auth_url(auth_url, auth_options, token_params)
       uri = URI.parse(auth_url)
       connection = Faraday.new("#{uri.scheme}://#{uri.host}", connection_options)
-      method = auth_options[:auth_method] || :get
+      method = auth_options[:auth_method] || options[:auth_method] || :get
+      params = (auth_options[:auth_params] || options[:auth_method] || {}).merge(token_params)
 
       response = connection.send(method) do |request|
         request.url uri.path
-        request.params = CGI.parse(uri.query || '').merge(auth_options[:auth_params] || {})
         request.headers = auth_options[:auth_headers] || {}
+        if method.to_s.downcase == 'post'
+          request.body = params
+        else
+          request.params = (Addressable::URI.parse(uri.to_s).query_values || {}).merge(params)
+        end
       end
 
       if !response.body.kind_of?(Hash) && !response.headers['Content-Type'].to_s.match(%r{text/plain}i)
@@ -474,6 +546,42 @@ module Ably
       response.body
     end
 
+    # Use the provided token to authenticate immediately and store the token details in +current_token_details+
+    def authorise_with_token(new_token_details)
+      if new_token_details && !new_token_details.from_token_string?
+        if !token_client_id_allowed?(new_token_details.client_id)
+          raise Ably::Exceptions::IncompatibleClientId.new("Client ID '#{new_token_details.client_id}' in the token is incompatible with the current client ID '#{client_id}'", 400, 40012)
+        end
+        configure_client_id new_token_details.client_id
+      end
+      configure_current_token_details new_token_details
+    end
+
+    # Returns a TokenDetails object if the provided token_details_obj argument is a TokenDetails object, Token String
+    # or TokenDetails JSON object.
+    # If the token_details_obj is not a Token or TokenDetails +nil+ is returned
+    def convert_to_token_details(token_details_obj)
+      case token_details_obj
+        when Ably::Models::TokenDetails
+          return token_details_obj
+        when Hash
+          return Ably::Models::TokenDetails.new(token_details_obj) if IdiomaticRubyWrapper(token_details_obj).has_key?(:issued)
+        when String
+          return Ably::Models::TokenDetails.new(token: token_details_obj)
+      end
+    end
+
+    # @return [Ably::Models::TokenDetails]
+    def send_token_request(token_request)
+      token_request = Ably::Models::TokenRequest(token_request)
+
+      response = client.post("/keys/#{token_request.key_name}/requestToken",
+                             token_request.hash, send_auth_header: false,
+                             disable_automatic_reauthorise: true)
+
+      Ably::Models::TokenDetails.new(response.body)
+    end
+
     # Return a Hash of connection options to initiate the Faraday::Connection with
     #
     # @return [Hash]
@@ -501,7 +609,7 @@ module Ably
         # Raise exceptions if response code is invalid
         builder.use Ably::Rest::Middleware::ExternalExceptions
 
-        setup_incoming_middleware builder, client.logger
+        setup_incoming_middleware builder, logger
 
         # Set Faraday's HTTP adapter
         builder.adapter Faraday.default_adapter
@@ -520,12 +628,12 @@ module Ably
       auth_callback_present? || token_url_present?
     end
 
-    def has_client_id?
-      !!client_id
-    end
-
     def api_key_present?
       key_name && key_secret
     end
+
+    def logger
+      client.logger
+    end
   end
 end

data/lib/ably/exceptions.rb

@@ -106,5 +106,7 @@ module Ably
 
     # When a channel is detached / failed, certain operations are not permitted such as publishing messages
     class ChannelInactive < BaseAblyException; end
+
+    class IncompatibleClientId < BaseAblyException; end
   end
 end

data/lib/ably/models/channel_state_change.rb

@@ -3,9 +3,9 @@ module Ably::Models
   # when a state change occurs
   #
   # @!attribute [r] current
-  #   @return [Connection::STATE] Current connection state
+  #   @return [Connection::STATE] Current channel state
   # @!attribute [r] previous
-  #   @return [Connection::STATE] Previous connection state
+  #   @return [Connection::STATE] Previous channel state
   # @!attribute [r] reason
   #   @return [Ably::Models::ErrorInfo] Object describing the reason for a state change when not initiated by the consumer of the client library
   #
@@ -20,7 +20,6 @@ module Ably::Models
       @hash_object = {
         current: hash_object.fetch(:current),
         previous: hash_object.fetch(:previous),
-        retry_in: hash_object[:retry_in],
         reason: hash_object[:reason],
         protocol_message: hash_object[:protocol_message]
       }

data/lib/ably/models/connection_details.rb

@@ -0,0 +1,54 @@
+module Ably::Models
+  # Convert connection details attributes to a {ConnectionDetails} object
+  #
+  # @param attributes (see #initialize)
+  #
+  # @return [ConnectionDetails]
+  def self.ConnectionDetails(attributes)
+    case attributes
+    when ConnectionDetails
+      return attributes
+    else
+      ConnectionDetails.new(attributes || {})
+    end
+  end
+
+  # ConnectionDetails are optionally passed to the client library in the +CONNECTED+ {Ably::Models::ProtocolMessage#connectionDetails} attribute
+  # to inform the client about any constraints it should adhere to and provide additional metadata about the connection.
+  # For example, if a request is made to publish a message that exceeds the +maxMessageSize+, the client library can reject
+  # the message immediately, without communicating with the Ably service
+  #
+  class ConnectionDetails
+    include Ably::Modules::ModelCommon
+
+    # @param attributes [Hash]
+    # @option attributes [String]    :client_id             contains the client ID assigned to the connection
+    # @option attributes [String]    :connection_key        the connection secret key string that is used to resume a connection and its state
+    # @option attributes [Integer]   :max_message_size      maximum individual message size in bytes
+    # @option attributes [Integer]   :max_frame_size        maximum size for a single frame of data sent to Ably. This restriction applies to a {Ably::Models::ProtocolMessage} sent over a realtime connection, or the total body size for a REST request
+    # @option attributes [Integer]   :max_inbound_rate      maximum allowable number of requests per second from a client
+    # @option attributes [Integer]   :connection_state_ttl  duration in seconds that Ably will persist the connection state when a Realtime client is abruptly disconnected
+    #
+    def initialize(attributes = {})
+      @hash_object = IdiomaticRubyWrapper(attributes.clone)
+      hash[:connection_state_ttl] = (hash[:connection_state_ttl].to_f / 1000).round if hash[:connection_state_ttl]
+      hash.freeze
+    end
+
+    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl).each do |attribute|
+      define_method attribute do
+        hash[attribute.to_sym]
+      end
+    end
+
+    def has_client_id?
+      hash.has_key?(:client_id)
+    end
+
+    # @!attribute [r] hash
+    # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
+    def hash
+      @hash_object
+    end
+  end
+end

data/lib/ably/models/protocol_message.rb

@@ -10,12 +10,12 @@ module Ably::Models
   #   @return [ACTION] Protocol Message action {Ably::Modules::Enum} from list of {ACTION}. Returns nil if action is unsupported by protocol
   # @!attribute [r] count
   #   @return [Integer] The count field is used for ACK and NACK actions. See {http://docs.ably.io/client-lib-development-guide/protocol/#message-acknowledgement message acknowledgement protocol}
-  # @!attribute [r] error_info
+  # @!attribute [r] error
   #   @return [ErrorInfo] Contains error information
   # @!attribute [r] channel
   #   @return [String] Channel name for messages
   # @!attribute [r] channel_serial
-  #   @return [String] Contains a serial number for a message on the current channel
+  #   @return [String] Contains a serial number for a message on the current channelƒ
   # @!attribute [r] connection_id
   #   @return [String] Contains a string public identifier for the connection
   # @!attribute [r] connection_key
@@ -88,12 +88,18 @@ module Ably::Models
       @hash_object.freeze
     end
 
-    %w(id channel channel_serial connection_id connection_key).each do |attribute|
+    %w(id channel channel_serial connection_id).each do |attribute|
       define_method attribute do
         hash[attribute.to_sym]
       end
     end
 
+    def connection_key
+      # connection_key in connection details takes precedence over connection_key on the ProtocolMessage
+      # connection_key in the ProtocolMessage will be deprecated in future protocol versions > 0.8
+      connection_details.connection_key || hash[:connection_key]
+    end
+
     def id!
       raise RuntimeError, 'ProtocolMessage #id is nil' unless id
       id
@@ -106,7 +112,7 @@ module Ably::Models
     end
 
     def error
-      @error_info ||= ErrorInfo.new(hash[:error]) if hash[:error]
+      @error ||= ErrorInfo.new(hash[:error]) if hash[:error]
     end
 
     def timestamp
@@ -181,6 +187,10 @@ module Ably::Models
       flags & 1 == 1
     end
 
+    def connection_details
+      @connection_details ||= Ably::Models::ConnectionDetails(hash[:connection_details])
+    end
+
     # Indicates this protocol message will generate an ACK response when sent
     # Examples of protocol messages required ACK include :message and :presence
     def ack_required?

data/lib/ably/models/token_details.rb

@@ -1,8 +1,7 @@
 module Ably::Models
   # Convert token details argument to a {TokenDetails} object
   #
-  # @param attributes [TokenDetails,Hash] A {TokenDetails} object or Hash of token and meta data attributes
-  # @option attributes (see TokenDetails#initialize)
+  # @param attributes (see #initialize)
   #
   # @return [TokenDetails]
   def self.TokenDetails(attributes)
@@ -27,10 +26,6 @@ module Ably::Models
     # For example, if buffer is 10s, the token can no longer be used for new requests 9s before it expires
     TOKEN_EXPIRY_BUFFER = 15
 
-    def initialize(attributes)
-      @hash_object = IdiomaticRubyWrapper(attributes.clone.freeze)
-    end
-
     # @param attributes
     # @option attributes [String]       :token      token used to authenticate requests
     # @option attributes [String]       :key_name   API key name used to create this token
@@ -76,7 +71,7 @@ module Ably::Models
     # @!attribute [r] capability
     # @return [Hash] Capabilities assigned to this token
     def capability
-      JSON.parse(hash.fetch(:capability)) if hash.fetch(:capability)
+      JSON.parse(hash.fetch(:capability)) if hash.has_key?(:capability)
     end
 
     # @!attribute [r] client_id
@@ -94,10 +89,21 @@ module Ably::Models
       expires < Time.now + TOKEN_EXPIRY_BUFFER
     end
 
+    # True if the TokenDetails was created from an opaque string i.e. no metadata exists for this token
+    # @return [Boolean]
+    # @api private
+    def from_token_string?
+      hash.keys == [:token]
+    end
+
     # @!attribute [r] hash
     # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
     def hash
       @hash_object
     end
+
+    def to_s
+      "<TokenDetails token=#{token} client_id=#{client_id} key_name=#{key_name} issued=#{issued} expires=#{expires} capability=#{capability} expired?=#{expired?}>"
+    end
   end
 end

data/lib/ably/models/token_request.rb

@@ -1,8 +1,7 @@
 module Ably::Models
   # Convert token request argument to a {TokenRequest} object
   #
-  # @param attributes [TokenRequest,Hash] A {TokenRequest} object or Hash of attributes to create a new token request
-  # @option attributes (see TokenRequest#initialize)
+  # @param attributes (see #initialize)
   #
   # @return [TokenRequest]
   def self.TokenRequest(attributes)

data/lib/ably/modules/ably.rb

@@ -7,9 +7,10 @@ module Ably
   # Fallback hosts to use when a connection to rest/realtime.ably.io is not possible due to
   # network failures either at the client, between the client and Ably, within an Ably data center, or at the IO domain registrar
   #
-  FALLBACK_HOSTS = %w(A.ably-realtime.com B.ably-realtime.com C.ably-realtime.com D.ably-realtime.com E.ably-realtime.com)
+  FALLBACK_HOSTS = %w(A.ably-realtime.com B.ably-realtime.com C.ably-realtime.com D.ably-realtime.com E.ably-realtime.com).freeze
+
   INTERNET_CHECK = {
     url:     '//internet-up.ably-realtime.com/is-the-internet-up.txt',
     ok_text: 'yes'
-  }
+  }.freeze
 end

data/lib/ably/modules/message_emitter.rb

@@ -50,10 +50,8 @@ module Ably::Modules
     #
     # @api private
     def emit_message(name, payload)
-      raise 'Event name is required' unless name
-
       message_emitter_subscriptions[:all].each { |cb| cb.call(payload) }
-      message_emitter_subscriptions[name].each { |cb| cb.call(payload) }
+      message_emitter_subscriptions[name].each { |cb| cb.call(payload) } if name
     end
 
     private

data/lib/ably/modules/state_emitter.rb

@@ -71,11 +71,11 @@ module Ably::Modules
     # @yield block is called if the state is matched immediately or once when the state is reached
     #
     # @return [void]
-    def once_or_if(target_states, options = {})
+    def once_or_if(target_states, options = {}, &block)
       raise ArgumentError, 'Block required' unless block_given?
 
       if Array(target_states).any? { |target_state| state == target_state }
-        yield
+        safe_yield block
       else
         failure_block   = options.fetch(:else, nil)
         failure_wrapper = nil

data/lib/ably/realtime/auth.rb

@@ -37,6 +37,8 @@ module Ably
       include Ably::Modules::AsyncWrapper
 
       def_delegators :auth_sync, :client_id
+      def_delegators :auth_sync, :token_client_id_allowed?, :configure_client_id, :client_id_validated?
+      def_delegators :auth_sync, :can_assume_client_id?, :has_client_id?
       def_delegators :auth_sync, :current_token_details, :token
       def_delegators :auth_sync, :key, :key_name, :key_secret, :options, :auth_options, :token_params
       def_delegators :auth_sync, :using_basic_auth?, :using_token_auth?
@@ -68,6 +70,10 @@ module Ably
       def authorise(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
           auth_sync.authorise(token_params, auth_options)
+        end.tap do |deferrable|
+          deferrable.errback do |error|
+            client.connection.transition_state_machine :failed, reason: error if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
+          end
         end
       end
 

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

@@ -123,6 +123,8 @@ module Ably::Realtime
       # 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|

data/lib/ably/realtime/channel.rb

@@ -309,9 +309,20 @@ module Ably
 
       # Queue messages and process queue if channel is attached.
       # If channel is not yet attached, attempt to attach it before the message queue is processed.
-      # @returns [Ably::Util::SafeDeferrable]
+      # @return [Ably::Util::SafeDeferrable]
       def queue_messages(raw_messages)
-        messages = Array(raw_messages).map { |msg| create_message(msg) }
+        messages = Array(raw_messages).map do |raw_msg|
+          create_message(raw_msg).tap do |message|
+            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
+        end
+
         queue.push *messages
 
         if attached?
@@ -340,12 +351,12 @@ module Ably
         Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
           messages.each do |message|
             message.callback do
-              return if failed
+              next if failed
               actual_deliveries += 1
               deferrable.succeed messages if actual_deliveries == expected_deliveries
             end
             message.errback do |error|
-              return if failed
+              next if failed
               failed = true
               deferrable.fail error, message
             end