ably 0.8.14 → 0.8.15

data/lib/ably/models/paginated_result.rb

@@ -32,6 +32,11 @@ module Ably::Models
       @make_async    = options.fetch(:async_blocking_operations, false)
 
       @items = http_response.body
+      if @items.nil? || @items.to_s.strip.empty?
+        @items = []
+      end
+      @items = [@items] if @items.kind_of?(Hash)
+
       @items = coerce_items_into(items, @coerce_into) if @coerce_into
       @items = items.map { |item| yield item } if block_given?
     end

data/lib/ably/modules/event_emitter.rb

@@ -50,18 +50,14 @@ module Ably
       #
       # @return [void]
       def on(*event_names, &block)
-        event_names.each do |event_name|
-          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block)
-        end
+        add_callback event_names, proc_for_block(block)
       end
 
       # Equivalent of {#on} but any exception raised in a block will bubble up and cause this client library to fail.
       # This method should only be used internally by the client library.
       # @api private
       def unsafe_on(*event_names, &block)
-        event_names.each do |event_name|
-          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, unsafe: true)
-        end
+        add_callback event_names, proc_for_block(block, unsafe: true)
       end
 
       # On receiving an event maching the event_name, call the provided block only once and remove the registered callback
@@ -70,24 +66,20 @@ module Ably
       #
       # @return [void]
       def once(*event_names, &block)
-        event_names.each do |event_name|
-          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, delete_once_run: true)
-        end
+        add_callback event_names, proc_for_block(block, delete_once_run: true)
       end
 
       # Equivalent of {#once} but any exception raised in a block will bubble up and cause this client library to fail.
       # This method should only be used internally by the client library.
       # @api private
       def unsafe_once(*event_names, &block)
-        event_names.each do |event_name|
-          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, delete_once_run: true, unsafe: true)
-        end
+        add_callback event_names, proc_for_block(block, delete_once_run: true, unsafe: true)
       end
 
       # Emit an event with event_name that will in turn call all matching callbacks setup with `on`
       def emit(event_name, *args)
-        callbacks[callbacks_event_coerced(event_name)].
-          clone.
+        [callbacks_any, callbacks[callbacks_event_coerced(event_name)]].each do |callback_arr|
+          callback_arr.clone.
           select do |proc_hash|
             if proc_hash[:unsafe]
               proc_hash[:emit_proc].call(*args)
@@ -95,8 +87,9 @@ module Ably
               safe_yield proc_hash[:emit_proc], *args
             end
           end.each do |callback|
-            callbacks[callbacks_event_coerced(event_name)].delete callback
+            callback_arr.delete callback
           end
+        end
       end
 
       # Remove all callbacks for event_name.
@@ -121,6 +114,14 @@ module Ably
             callbacks[callbacks_event_coerced(event_name)].clear
           end
         end
+
+        if event_names.empty?
+          if block_given?
+            callbacks_any.delete_if { |proc_hash| proc_hash[:block] == block }
+          else
+            callbacks_any.clear
+          end
+        end
       end
 
       private
@@ -128,6 +129,16 @@ module Ably
         klass.extend ClassMethods
       end
 
+      def add_callback(event_names, proc_block)
+        if event_names.empty?
+          callbacks_any << proc_block
+        else
+          event_names.each do |event_name|
+            callbacks[callbacks_event_coerced(event_name)] << proc_block
+          end
+        end
+      end
+
       # Create a Hash with a proc that calls the provided block and returns true if option :delete_once_run is set to true.
       # #emit automatically deletes any blocks that return true thus allowing a block to be run once
       def proc_for_block(block, options = {})
@@ -145,6 +156,10 @@ module Ably
         @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
       end
 
+      def callbacks_any
+        @callbacks_any ||= []
+      end
+
       def callbacks_event_coerced(event_name)
         if self.class.event_emitter_coerce_proc
           self.class.event_emitter_coerce_proc.call(event_name)

data/lib/ably/modules/model_common.rb

@@ -32,6 +32,14 @@ module Ably::Modules
       as_json.to_json(*args)
     end
 
+    # Like to_json but encodes all binary fields to hex
+    def to_safe_json(*args)
+      as_json.
+        each_with_object({}) do |(key, val), obj|
+          obj[key] = to_safe_jsonable_val(val)
+        end.to_json(*args)
+    end
+
     # @!attribute [r] hash
     # @return [Integer] Compute a hash-code for this hash. Two hashes with the same content will have the same hash code
     def hash
@@ -39,6 +47,23 @@ module Ably::Modules
     end
 
     private
+    def to_safe_jsonable_val(val)
+      case val
+      when Array
+        val.map { |array_val| to_safe_jsonable_val(array_val) }
+      when Hash
+        val.each_with_object({}) { |(key, hash_val), obj| obj[key] = to_safe_jsonable_val(hash_val) }
+      when String
+        if val.encoding == Encoding::ASCII_8BIT
+          val.unpack("H*").first
+        else
+          val
+        end
+      else
+        val
+      end
+    end
+
     def ensure_utf8_string_for(attribute, value)
       if value
         raise ArgumentError, "#{attribute} must be a String" unless value.kind_of?(String)

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

@@ -58,7 +58,7 @@ module Ably::Realtime
       # all messages awaiting an ACK response should fail immediately
       def fail_messages_awaiting_ack(error)
         # Allow a short time for other queued operations to complete before failing all messages
-        EventMachine.add_timer(0.1) do
+        EventMachine.next_tick do
           error = Ably::Exceptions::MessageDeliveryFailed.new("Channel cannot publish messages whilst state is '#{channel.state}'") unless error
           fail_messages_in_queue connection.__pending_message_ack_queue__, error
           fail_messages_in_queue connection.__outgoing_message_queue__, error
@@ -76,10 +76,10 @@ module Ably::Realtime
 
       def nack_messages(protocol_message, error)
         (protocol_message.messages + protocol_message.presence).each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
+          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_safe_json}, protocol message: #{protocol_message}"
           message.fail error
         end
-        logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}"
+        logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_safe_json}"
         protocol_message.fail error
       end
 

data/lib/ably/realtime/client.rb

@@ -68,6 +68,9 @@ module Ably
       #
       # @param (see Ably::Rest::Client#initialize)
       # @option options (see Ably::Rest::Client#initialize)
+      # @option options [Proc]                    :auth_callback       when provided, the Proc will be called with the token params hash as the first argument, whenever a new token is required.
+      #                                                                Whilst the proc is called synchronously, it does not block the EventMachine reactor as it is run in a separate thread.
+      #                                                                The Proc should return a token string, {Ably::Models::TokenDetails} or JSON equivalent, {Ably::Models::TokenRequest} or JSON equivalent
       # @option options [Boolean] :queue_messages If false, this disables the default behaviour whereby the library queues messages on a connection in the disconnected or connecting states
       # @option options [Boolean] :echo_messages  If false, prevents messages originating from this connection being echoed back on the same connection
       # @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
@@ -144,6 +147,16 @@ module Ably
         connection.connect(&block)
       end
 
+      # (see Ably::Rest::Client#request)
+      # @yield [Ably::Models::HttpPaginatedResponse<>] An Array of Stats
+      #
+      # @return [Ably::Util::SafeDeferrable]
+      def request(method, path, params = {}, body = nil, headers = {}, &callback)
+        async_wrap(callback) do
+          rest_client.request(method, path, params, body, headers, async_blocking_operations: true)
+        end
+      end
+
       # @!attribute [r] endpoint
       # @return [URI::Generic] Default Ably Realtime endpoint used for all requests
       def endpoint

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

@@ -178,14 +178,14 @@ module Ably::Realtime
 
       def ack_messages(messages)
         messages.each do |message|
-          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}"
+          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_safe_json}"
           message.succeed message
         end
       end
 
       def nack_messages(messages, protocol_message)
         messages.each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
+          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_safe_json}, protocol message: #{protocol_message}"
           message.fail protocol_message.error
         end
       end

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

@@ -200,7 +200,7 @@ module Ably::Realtime
         return unless ensure_presence_message_is_valid(presence_message)
 
         unless should_update_member?(presence_message)
-          logger.debug "#{self.class.name}: Skipped presence member #{presence_message.action} on channel #{presence.channel.name}.\n#{presence_message.to_json}"
+          logger.debug "#{self.class.name}: Skipped presence member #{presence_message.action} on channel #{presence.channel.name}.\n#{presence_message.to_safe_json}"
           return
         end
 
@@ -239,13 +239,13 @@ module Ably::Realtime
       end
 
       def add_presence_member(presence_message)
-        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' for event '#{presence_message.action}' #{members.has_key?(presence_message.member_key) ? 'updated' : 'added'}.\n#{presence_message.to_json}"
+        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' for event '#{presence_message.action}' #{members.has_key?(presence_message.member_key) ? 'updated' : 'added'}.\n#{presence_message.to_safe_json}"
         members[presence_message.member_key] = { present: true, message: presence_message }
         presence.emit_message presence_message.action, presence_message
       end
 
       def remove_presence_member(presence_message)
-        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' removed.\n#{presence_message.to_json}"
+        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' removed.\n#{presence_message.to_safe_json}"
 
         if in_sync?
           members.delete presence_message.member_key

data/lib/ably/rest/client.rb

@@ -251,15 +251,67 @@ module Ably
       # Perform an HTTP GET request to the API using configured authentication
       #
       # @return [Faraday::Response]
+      #
+      # @api private
       def get(path, params = {}, options = {})
-        request(:get, path, params, options)
+        raw_request(:get, path, params, options)
       end
 
       # Perform an HTTP POST request to the API using configured authentication
       #
       # @return [Faraday::Response]
+      #
+      # @api private
       def post(path, params, options = {})
-        request(:post, path, params, options)
+        raw_request(:post, path, params, options)
+      end
+
+      # Perform an HTTP request to the Ably API
+      # This is a convenience for customers who wish to use bleeding edge REST API functionality
+      # that is either not documented or is not included in the API for our client libraries.
+      # The REST client library provides a function to issue HTTP requests to the Ably endpoints
+      # with all the built in functionality of the library such as authentication, paging,
+      # fallback hosts, MsgPack and JSON support etc.
+      #
+      # @param method  [Symbol]    The HTTP method symbol such as +:get+, +:post+, +:put+
+      # @param path    [String]    The path of the URL such +/channel/foo/publish+
+      # @param params  [Hash, nil] Optional querystring params
+      # @param body    [Hash, nil] Optional body for the POST or PUT request, must be nil or a JSON-like object
+      # @param headers [Hash, nil] Optional additional headers
+      #
+      # @return [Ably::Models::HttpPaginatedResponse<>]
+      def request(method, path, params = {}, body = nil, headers = {}, options = {})
+        raise "Method #{method.to_s.upcase} not supported" unless [:get, :put, :post].include?(method.to_sym)
+
+        response = case method.to_sym
+        when :get
+          reauthorise_on_authorisation_failure do
+            send_request(method, path, params, headers: headers)
+          end
+        when :post
+          path_with_params = Addressable::URI.new
+          path_with_params.query_values = params || {}
+          query = path_with_params.query
+          reauthorise_on_authorisation_failure do
+            send_request(method, "#{path}#{"?#{query}" unless query.nil? || query.empty?}", body, headers: headers)
+          end
+        end
+
+        paginated_options = {
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        Ably::Models::HttpPaginatedResponse.new(response, path, self, paginated_options)
+
+      rescue Exceptions::ResourceMissing, Exceptions::ForbiddenRequest, Exceptions::ResourceMissing => e
+        response = Models::HttpPaginatedResponse::ErrorResponse.new(e.status, e.code, e.message)
+        Models::HttpPaginatedResponse.new(response, path, self)
+      rescue Exceptions::TokenExpired, Exceptions::UnauthorizedRequest => e
+        response = Models::HttpPaginatedResponse::ErrorResponse.new(e.status, e.code, e.message)
+        Models::HttpPaginatedResponse.new(response, path, self)
+      rescue Exceptions::InvalidRequest, Exceptions::ServerError => e
+        response = Models::HttpPaginatedResponse::ErrorResponse.new(e.status, e.code, e.message)
+        Models::HttpPaginatedResponse.new(response, path, self)
       end
 
       # @!attribute [r] endpoint
@@ -360,7 +412,7 @@ module Ably
       end
 
       private
-      def request(method, path, params = {}, options = {})
+      def raw_request(method, path, params = {}, options = {})
         options = options.clone
         if options.delete(:disable_automatic_reauthorise) == true
           send_request(method, path, params, options)
@@ -385,6 +437,11 @@ module Ably
           connection(use_fallback: use_fallback).send(method, path, params) do |request|
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
+              if options[:headers]
+                options[:headers].map do |key, val|
+                  request.headers[key] = val
+                end
+              end
             end
           end
 

data/lib/ably/version.rb

@@ -1,5 +1,5 @@
 module Ably
-  VERSION = '0.8.14'
+  VERSION = '0.8.15'
   PROTOCOL_VERSION = '0.8'
 
   # Allow a variant to be configured for all instances of this client library

data/spec/acceptance/realtime/auth_spec.rb

@@ -186,6 +186,35 @@ describe Ably::Realtime::Auth, :event_machine do
           end
         end
 
+        context 'with auth_callback blocking' do
+          let(:rest_auth_client) { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
+          let(:client_options)   { default_options.merge(auth_callback: auth_callback) }
+          let(:pause)            { 5 }
+
+          context 'with a slow auth callback response' do
+            let(:auth_callback) do
+              Proc.new do
+                sleep pause
+                rest_auth_client.auth.request_token
+              end
+            end
+
+            it 'asynchronously authenticates' do
+              timers_called = 0
+              block = Proc.new do
+                timers_called += 1
+                EventMachine.add_timer(0.5, &block)
+              end
+              block.call
+              client.connect
+              client.connection.on(:connected) do
+                expect(timers_called).to be >= (pause-1) / 0.5
+                stop_reactor
+              end
+            end
+          end
+        end
+
         context 'when implicitly called, with an explicit ClientOptions client_id' do
           let(:client_id)        { random_str }
           let(:client_options)   { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id, log_level: :none) }

data/spec/acceptance/realtime/channel_spec.rb

@@ -92,12 +92,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'reattaches' do
           channel.attach do
-            channel.transition_state_machine :failed, reason: RuntimeError.new
-            expect(channel).to be_failed
-            channel.attach do
-              expect(channel).to be_attached
-              stop_reactor
+            channel.once(:failed) do
+              expect(channel).to be_failed
+              channel.attach do
+                expect(channel).to be_attached
+                stop_reactor
+              end
             end
+            channel.transition_state_machine :failed, reason: RuntimeError.new
           end
         end
       end
@@ -371,7 +373,7 @@ describe Ably::Realtime::Channel, :event_machine do
             expect(message_id.uniq.count).to eql(1)
 
             # Check that messages use index 0,1,2 in the ID
-            message_indexes = messages.map { |msg| msg.id.split(':')[1] }
+            message_indexes = messages.map { |msg| msg.id.split(':').last }
             expect(message_indexes).to include("0", "1", "2")
             stop_reactor
           end

data/spec/acceptance/realtime/client_spec.rb

@@ -229,5 +229,57 @@ describe Ably::Realtime::Client, :event_machine do
         stop_reactor
       end
     end
+
+    context '#request (#RSC19*)' do
+      let(:client_options) { default_options.merge(key: api_key) }
+
+      context 'get' do
+        it 'returns an HttpPaginatedResponse object' do
+          subject.request(:get, 'time').callback do |response|
+            expect(response).to be_a(Ably::Models::HttpPaginatedResponse)
+            expect(response.status_code).to eql(200)
+            stop_reactor
+          end
+        end
+
+        context '404 request to invalid URL' do
+          it 'returns an object with 404 status code and error message' do
+            subject.request(:get, 'does-not-exist').callback do |response|
+              expect(response).to be_a(Ably::Models::HttpPaginatedResponse)
+              expect(response.error_message).to match(/Could not find/)
+              expect(response.error_code).to eql(40400)
+              expect(response.status_code).to eql(404)
+              stop_reactor
+            end
+          end
+        end
+
+        context 'paged results' do
+          let(:channel_name) { random_str }
+
+          it 'provides paging' do
+            10.times do
+              subject.rest_client.request(:post, "/channels/#{channel_name}/publish", {}, { 'name': 'test' })
+            end
+
+            subject.request(:get, "/channels/#{channel_name}/messages", { limit: 2 }).callback do |response|
+              expect(response.items.length).to eql(2)
+              expect(response).to be_has_next
+              response.next do |next_page|
+                expect(next_page.items.length).to eql(2)
+                expect(next_page).to be_has_next
+                first_page_ids = response.items.map { |message| message['id'] }.uniq.sort
+                next_page_ids = next_page.items.map { |message| message['id'] }.uniq.sort
+                expect(first_page_ids).to_not eql(next_page_ids)
+                next_page.next do |third_page|
+                  expect(third_page.items.length).to eql(2)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end