ably-rest 0.9.3 → 1.0.0

data/lib/submodules/ably-ruby/ably.gemspec

@@ -38,11 +38,12 @@ Gem::Specification.new do |spec|
   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', '~> 0.4'
   spec.add_development_dependency 'yard', '~> 0.9'
-  spec.add_development_dependency 'webmock', '~> 2.0'
 
   if RUBY_VERSION.match(/^1/)
     spec.add_development_dependency 'public_suffix', '~> 1.4.6' # Later versions do not support Ruby 1.9
+    spec.add_development_dependency 'webmock', '2.2'
   else
+    spec.add_development_dependency 'webmock', '~> 2.2'
     spec.add_development_dependency 'coveralls'
     spec.add_development_dependency 'pry'
     spec.add_development_dependency 'pry-byebug'

data/lib/submodules/ably-ruby/lib/ably/auth.rb

@@ -30,11 +30,11 @@ module Ably
 
     # Default capability Hash object and TTL in seconds for issued tokens
     TOKEN_DEFAULTS = {
-      capability:         { '*' => ['*'] },
-      ttl:                60 * 60, # 1 hour in seconds
       renew_token_buffer: 10 # buffer to allow a token to be reissued before the token is considered expired (Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER)
     }.freeze
 
+    API_KEY_REGEX = /^[\w-]{2,}\.[\w-]{2,}:[\w-]{2,}$/
+
     attr_reader :options, :token_params, :current_token_details
     alias_method :auth_options, :options
 
@@ -77,7 +77,7 @@ module Ably
       end
 
       if options[:client_id] == '*'
-        raise ArgumentError, 'A client cannot be configured with a wildcard client_id'
+        raise ArgumentError, 'A client cannot be configured with a wildcard client_id, only a token can have a wildcard client_id privilege'
       end
 
       if has_client_id? && !token_creatable_externally? && !token_option
@@ -90,8 +90,12 @@ module Ably
       if token_option
         token_details = convert_to_token_details(token_option)
         if token_details
-          token_details = authorize_with_token(token_details)
-          logger.debug "Auth: new token passed in to the initializer: #{token_details}"
+          begin
+            token_details = authorize_with_token(token_details)
+            logger.debug { "Auth: new token passed in to the initializer: #{token_details}" }
+          rescue StandardError => e
+            logger.error { "Auth: Implicit authorization using the provided token failed: #{e}" }
+          end
         end
       end
 
@@ -123,10 +127,18 @@ module Ably
     def authorize(token_params = nil, auth_options = nil)
       if auth_options.nil?
         auth_options = options # Use default options
+
+        if options.has_key?(:query_time)
+          @options = options.dup
+          # Query the server time only happens once
+          # the options remain in auth_options though so they are passed to request_token
+          @options.delete(:query_time)
+          @options.freeze
+        end
       else
         ensure_valid_auth_attributes auth_options
 
-        auth_options = auth_options.clone
+        auth_options = auth_options.dup
 
         if auth_options[:token_params]
           token_params = auth_options.delete(:token_params).merge(token_params || {})
@@ -139,7 +151,7 @@ module Ably
           store_and_delete_basic_auth_key_from_options! auth_options
         end
 
-        @options = auth_options.clone
+        @options = auth_options.dup
 
         # Query the server time only happens once
         # the options remain in auth_options though so they are passed to request_token
@@ -150,12 +162,14 @@ module Ably
 
       # Unless provided, defaults are used
       unless token_params.nil?
-        @token_params = token_params
+        @token_params = token_params.dup
+        # Timestamp is only valid for this request
+        @token_params.delete(:timestamp)
         @token_params.freeze
       end
 
-      authorize_with_token(request_token(@token_params, auth_options)).tap do |new_token_details|
-        logger.debug "Auth: new token following authorisation: #{new_token_details}"
+      authorize_with_token(request_token(token_params || @token_params, auth_options)).tap do |new_token_details|
+        logger.debug { "Auth: new token following authorisation: #{new_token_details}" }
 
         # If authorize the realtime library required auth, then yield the token in a block
         if block_given?
@@ -166,7 +180,7 @@ module Ably
 
     # @deprecated Use {#authorize} instead
     def authorise(*args, &block)
-      logger.warn "Auth#authorise is deprecated and will be removed in 1.0. Please use Auth#authorize instead"
+      logger.warn { "Auth#authorise is deprecated and will be removed in 1.0. Please use Auth#authorize instead" }
       authorize(*args, &block)
     end
 
@@ -212,9 +226,21 @@ module Ably
       auth_options = self.options.merge(auth_options)
 
       token_request = if auth_callback = auth_options.delete(:auth_callback)
-        auth_callback.call(token_params)
+        begin
+          Timeout::timeout(client.auth_request_timeout) do
+            auth_callback.call(token_params)
+          end
+        rescue StandardError => err
+          raise Ably::Exceptions::AuthenticationFailed.new("auth_callback failed: #{err.message}", nil, nil, err, fallback_status: 500, fallback_code: 80019)
+        end
       elsif auth_url = auth_options.delete(:auth_url)
-        token_request_from_auth_url(auth_url, auth_options, token_params)
+        begin
+          Timeout::timeout(client.auth_request_timeout) do
+            token_request_from_auth_url(auth_url, auth_options, token_params)
+          end
+        rescue StandardError => err
+          raise Ably::Exceptions::AuthenticationFailed.new("auth_url failed: #{err.message}", nil, nil, err, fallback_status: 500, fallback_code: 80019)
+        end
       else
         create_token_request(token_params, auth_options)
       end
@@ -259,7 +285,7 @@ module Ably
     def create_token_request(token_params = {}, auth_options = {})
       ensure_valid_auth_attributes auth_options
 
-      auth_options = auth_options.clone
+      auth_options = auth_options.dup
       token_params = (auth_options[:token_params] || {}).merge(token_params)
 
       split_api_key_into_key_and_secret! auth_options if auth_options[:key]
@@ -272,20 +298,26 @@ module Ably
       timestamp = token_params.delete(:timestamp) || current_time
       timestamp = Time.at(timestamp) if timestamp.kind_of?(Integer)
 
-      ttl = [
-        (token_params[:ttl] || TOKEN_DEFAULTS.fetch(:ttl)),
-        Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER + TOKEN_DEFAULTS.fetch(:renew_token_buffer) # never issue a token that will be immediately considered expired due to the buffer
-      ].max
+
 
       token_request = {
         keyName:    request_key_name,
-        clientId:   token_params[:client_id] || auth_options[:client_id] || client_id,
-        ttl:        (ttl * 1000).to_i,
         timestamp:  (timestamp.to_f * 1000).round,
-        capability: token_params[:capability] || TOKEN_DEFAULTS.fetch(:capability),
         nonce:      token_params[:nonce] || SecureRandom.hex.force_encoding('UTF-8')
       }
 
+      token_client_id = token_params[:client_id] || auth_options[:client_id] || client_id
+      token_request[:clientId] = token_client_id if token_client_id
+
+      if token_params[:ttl]
+        token_ttl = [
+          token_params[:ttl],
+          Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER + TOKEN_DEFAULTS.fetch(:renew_token_buffer) # never issue a token that will be immediately considered expired due to the buffer
+        ].max
+        token_request[:ttl] = (token_ttl * 1000).to_i
+      end
+
+      token_request[:capability] = token_params[:capability] if token_params[:capability]
       if token_request[:capability].is_a?(Hash)
         lexicographic_ordered_capabilities = Hash[
           token_request[:capability].sort_by { |key, value| key }.map do |key, value|
@@ -423,7 +455,7 @@ module Ably
 
       # 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)
+        raise Ably::Exceptions::IncompatibleClientId.new("Client ID is immutable once configured for a client. Client ID cannot be changed to '#{new_client_id}'")
       end
       @client_id_validated = true
       @client_id = new_client_id
@@ -537,7 +569,7 @@ module Ably
     # Returns the current token if it exists or authorizes and retrieves a token
     def token_auth_string
       if !current_token_details && token_option
-        logger.debug "Auth: Token auth string missing, authorizing implicitly now"
+        logger.debug { "Auth: Token auth string missing, authorizing implicitly now" }
         # 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+
         authorize_with_token send_token_request(token_option)
@@ -592,7 +624,7 @@ module Ably
       )
     end
 
-    # Retrieve a token request from a specified URL, expects a JSON response
+    # Retrieve a token request from a specified URL, expects a JSON or text response
     #
     # @return [Hash]
     def token_request_from_auth_url(auth_url, auth_options, token_params)
@@ -623,7 +655,7 @@ module Ably
     def authorize_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)
+          raise Ably::Exceptions::IncompatibleClientId.new("Client ID '#{new_token_details.client_id}' in the token is incompatible with the current client ID '#{client_id}'")
         end
         configure_client_id new_token_details.client_id
       end

data/lib/submodules/ably-ruby/lib/ably/exceptions.rb

@@ -1,5 +1,8 @@
 module Ably
   module Exceptions
+    TOKEN_EXPIRED_CODE = 40140..40149
+    INVALID_CLIENT_ID = 40012
+
     # Base Ably exception class that contains status and code values used by Ably
     # Refer to https://github.com/ably/ably-common/blob/master/protocol/errors.json
     #
@@ -11,10 +14,17 @@ module Ably
     #   @return [String] Ably specific error code
     class BaseAblyException < StandardError
       attr_reader :status, :code
-      def initialize(message, status = nil, code = nil)
+
+      def initialize(message, status = nil, code = nil, base_exception = nil, options = {})
         super message
+
+        @base_exception = base_exception
         @status = status
+        @status ||= base_exception.status if base_exception && base_exception.respond_to?(:status)
+        @status ||= options[:fallback_status]
         @code = code
+        @code ||= base_exception.code if base_exception && base_exception.respond_to?(:code)
+        @code ||= options[:fallback_code]
       end
 
       def to_s
@@ -23,10 +33,19 @@ module Ably
           additional_info = []
           additional_info << "code: #{code}" if code
           additional_info << "http status: #{status}" if status
+          additional_info << "base exception: #{@base_exception.class}" if @base_exception
           message << "(#{additional_info.join(', ')})"
         end
         message.join(' ')
       end
+
+      def as_json
+        {
+          message: "#{self.class}: #{message}",
+          status: @status,
+          code: @code
+        }.delete_if { |key, val| val.nil? }
+      end
     end
 
     # An invalid request was received by Ably
@@ -52,16 +71,15 @@ module Ably
 
     # Connection error from Realtime or REST service
     class ConnectionError < BaseAblyException
-      def initialize(message, status = nil, code = nil, base_error = nil)
-        super message, status, code
-        @base_error = base_error
+      def initialize(message, status = nil, code = nil, base_exception = nil, options = {})
+        super message, status, code, base_exception, options
       end
 
       def to_s
         message = [super]
-        if @base_error
-          message << "#{@base_error}"
-          if @base_error.respond_to?(:message) && @base_error.message.match(/certificate verify failed/i)
+        if @base_exception
+          message << "#{@base_exception}"
+          if @base_exception.respond_to?(:message) && @base_exception.message.match(/certificate verify failed/i)
             message << "See https://goo.gl/eKvfcR to resolve this issue."
           end
         end
@@ -84,9 +102,13 @@ module Ably
     # Connection failed
     class ConnectionFailed < ConnectionError; end
 
+    class AuthenticationFailed < ConnectionError; end
+
     # Invalid State Change error on a {https://github.com/gocardless/statesman Statesman State Machine}
     class InvalidStateChange < BaseAblyException; end
 
+    class InvalidState < BaseAblyException; end
+
     # A generic Ably exception taht supports a status & code.
     # See https://github.com/ably/ably-common/blob/master/protocol/errors.json for a list of Ably errors
     class Standard < BaseAblyException; end
@@ -121,7 +143,11 @@ 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
+    class IncompatibleClientId < BaseAblyException
+      def initialize(messages, status = 400, code = INVALID_CLIENT_ID, *args)
+        super(message, status, code, *args)
+      end
+    end
 
     # Token request has missing or invalid attributes
     class InvalidTokenRequest < BaseAblyException; end

data/lib/submodules/ably-ruby/lib/ably/logger.rb

@@ -34,7 +34,16 @@ module Ably
     # @return {Integer}
     attr_reader :log_level
 
-    def_delegators :logger, :fatal, :error, :warn, :info, :debug
+    # Catch exceptiosn in blocks passed to the logger, log the error and continue
+    %w(fatal error warn info debug).each do |method_name|
+      define_method(method_name) do |*args, &block|
+        begin
+          logger.public_send(method_name, *args, &block)
+        rescue StandardError => e
+          logger.error "Logger: Failed to log #{method_name} block - #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+    end
 
     private
     def client

data/lib/submodules/ably-ruby/lib/ably/models/auth_details.rb

@@ -0,0 +1,42 @@
+module Ably::Models
+  # Convert auth details attributes to a {AuthDetails} object
+  #
+  # @param attributes (see #initialize)
+  #
+  # @return [AuthDetails]
+  def self.AuthDetails(attributes)
+    case attributes
+    when AuthDetails
+      return attributes
+    else
+      AuthDetails.new(attributes || {})
+    end
+  end
+
+  # AuthDetails are included in an +AUTH+ {Ably::Models::ProtocolMessage#auth} attribute
+  # to provide the realtime service with new token authentication details following a re-auth workflow
+  #
+  class AuthDetails
+    include Ably::Modules::ModelCommon
+
+    # @param attributes [Hash]
+    # @option attributes [String]    :access_token     token string
+    #
+    def initialize(attributes = {})
+      @hash_object = IdiomaticRubyWrapper(attributes.clone)
+      self.attributes.freeze
+    end
+
+    %w(access_token).each do |attribute|
+      define_method attribute do
+        attributes[attribute.to_sym]
+      end
+    end
+
+    # @!attribute [r] attributes
+    # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
+    def attributes
+      @hash_object
+    end
+  end
+end

data/lib/submodules/ably-ruby/lib/ably/models/channel_state_change.rb

@@ -8,31 +8,45 @@ module Ably::Models
   #   @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
+  # @!attribute [r] resumed
+  #   @return [Boolean] True when a channel is resumed, false when continuity on the channel is no longer provided indicating that the developer is now responsible for recovering lost messages on this channel through other means, such as using the hisory API
   #
   class ChannelStateChange
     include Ably::Modules::ModelCommon
 
     def initialize(hash_object)
-      unless (hash_object.keys - [:current, :previous, :reason, :protocol_message]).empty?
-        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :reason'
+      unless (hash_object.keys - [:current, :previous, :event, :reason, :resumed, :protocol_message]).empty?
+        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :event, :reason, :resumed'
       end
 
       @hash_object = {
         current: hash_object.fetch(:current),
         previous: hash_object.fetch(:previous),
+        event: hash_object[:event],
         reason: hash_object[:reason],
-        protocol_message: hash_object[:protocol_message]
+        protocol_message: hash_object[:protocol_message],
+        resumed: hash_object[:resumed]
       }
     rescue KeyError => e
       raise ArgumentError, e
     end
 
-    %w(current previous reason protocol_message).each do |attribute|
+    %w(current previous event reason).each do |attribute|
       define_method attribute do
         @hash_object[attribute.to_sym]
       end
     end
 
+    def resumed
+      !!@hash_object[:resumed]
+    end
+    alias_method :resumed?, :resumed
+
+    # @api private
+    def protocol_message
+      @hash_object[:protocol_message]
+    end
+
     def to_s
       "ChannelStateChange: current state #{current}, previous state #{previous}"
     end

data/lib/submodules/ably-ruby/lib/ably/models/connection_details.rb

@@ -27,18 +27,21 @@ module Ably::Models
     # @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]   :max_idle_interval     is the maximum length of time in seconds that the server will allow no activity to occur in the server->client direction. After such a period of inactivity, the server will send a @HEARTBEAT@ or transport-level ping to the client. If the value is 0, the server will allow arbitrarily-long levels of inactivity.
     # @option attributes [Integer]   :connection_state_ttl  duration in seconds that Ably will persist the connection state when a Realtime client is abruptly disconnected
     # @option attributes [String]    :server_id             unique identifier of the Ably server where the connection is established
     #
     def initialize(attributes = {})
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
-      if self.attributes[:connection_state_ttl]
-        self.attributes[:connection_state_ttl] = (self.attributes[:connection_state_ttl].to_f / 1000).round
+      [:connection_state_ttl, :max_idle_interval].each do |duration_field|
+        if self.attributes[duration_field]
+          self.attributes[duration_field] = (self.attributes[duration_field].to_f / 1000).round
+        end
       end
       self.attributes.freeze
     end
 
-    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl server_id).each do |attribute|
+    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl max_idle_interval server_id).each do |attribute|
       define_method attribute do
         attributes[attribute.to_sym]
       end

data/lib/submodules/ably-ruby/lib/ably/models/connection_state_change.rb

@@ -15,13 +15,14 @@ module Ably::Models
     include Ably::Modules::ModelCommon
 
     def initialize(hash_object)
-      unless (hash_object.keys - [:current, :previous, :retry_in, :reason, :protocol_message]).empty?
-        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :retry_in, :reason'
+      unless (hash_object.keys - [:current, :previous, :event, :retry_in, :reason, :protocol_message]).empty?
+        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :event, :retry_in, :reason'
       end
 
       @hash_object = {
         current: hash_object.fetch(:current),
         previous: hash_object.fetch(:previous),
+        event: hash_object[:event],
         retry_in: hash_object[:retry_in],
         reason: hash_object[:reason],
         protocol_message: hash_object[:protocol_message]
@@ -30,7 +31,7 @@ module Ably::Models
       raise ArgumentError, e
     end
 
-    %w(current previous retry_in reason protocol_message).each do |attribute|
+    %w(current previous event retry_in reason protocol_message).each do |attribute|
       define_method attribute do
         @hash_object[attribute.to_sym]
       end