ably 1.0.5 → 1.0.6

data/lib/ably/realtime/presence.rb

@@ -71,7 +71,7 @@ module Ably::Realtime
 
       ensure_channel_attached(deferrable) do
         if entering?
-          once_or_if(STATE.Entered, else: proc { |args| deferrable_fail deferrable, *args }) do
+          once_or_if(STATE.Entered, else: lambda { |args| deferrable_fail deferrable, *args }) do
             deferrable_succeed deferrable, &success_block
           end
         else
@@ -132,7 +132,7 @@ module Ably::Realtime
 
       ensure_channel_attached(deferrable) do
         if leaving?
-          once_or_if(STATE.Left, else: proc { |error|deferrable_fail deferrable, *args }) do
+          once_or_if(STATE.Left, else: lambda { |error|deferrable_fail deferrable, *args }) do
             deferrable_succeed deferrable, &success_block
           end
         else
@@ -310,7 +310,7 @@ module Ably::Realtime
     # @api private
     def __incoming_msgbus__
       @__incoming_msgbus__ ||= Ably::Util::PubSub.new(
-        coerce_into: Proc.new { |event| Ably::Models::ProtocolMessage::ACTION(event) }
+        coerce_into: lambda { |event| Ably::Models::ProtocolMessage::ACTION(event) }
       )
     end
 

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

@@ -94,7 +94,7 @@ module Ably::Realtime
         wait_for_sync = options.fetch(:wait_for_sync, true)
         deferrable    = Ably::Util::SafeDeferrable.new(logger)
 
-        result_block = proc do
+        result_block = lambda do
           present_members.tap do |members|
             members.keep_if { |member| member.connection_id == options[:connection_id] } if options[:connection_id]
             members.keep_if { |member| member.client_id == options[:client_id] } if options[:client_id]
@@ -110,17 +110,17 @@ module Ably::Realtime
           # Must be defined before subsequent procs reference this callback
           reset_callbacks = nil
 
-          in_sync_callback = proc do
-            reset_callbacks
+          in_sync_callback = lambda do
+            reset_callbacks.call if reset_callbacks
             result_block.call
           end
 
-          failed_callback = proc do |error|
-            reset_callbacks
+          failed_callback = lambda do |error|
+            reset_callbacks.call if reset_callbacks
             deferrable.fail error
           end
 
-          reset_callbacks = proc do
+          reset_callbacks = lambda do
             off(&in_sync_callback)
             off(&failed_callback)
             channel.off(&failed_callback)

data/lib/ably/rest/channel.rb

@@ -22,7 +22,7 @@ module Ably
       # @option channel_options [Hash,Ably::Models::CipherParams]   :cipher   A hash of options or a {Ably::Models::CipherParams} to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of +:cipher+ options
       #
       def initialize(client, name, channel_options = {})
-        ensure_utf_8 :name, name
+        name = (ensure_utf_8 :name, name)
 
         update_options channel_options
         @client  = client
@@ -58,7 +58,7 @@ module Ably
         messages = if name.kind_of?(Enumerable)
           name
         else
-          ensure_utf_8 :name, name, allow_nil: true
+          name = ensure_utf_8(:name, name, allow_nil: true)
           ensure_supported_payload data
           [{ name: name, data: data }.merge(attributes)]
         end

data/lib/ably/rest/client.rb

@@ -439,22 +439,15 @@ module Ably
         max_retry_duration = http_defaults.fetch(:max_retry_duration)
         requested_at       = Time.now
         retry_count        = 0
-        request_id         = nil
-        if add_request_ids
-          params = if params.nil?
-            {}
-          else
-            params.dup
-          end
-          request_id = SecureRandom.urlsafe_base64(10)
-          params[:request_id] = request_id
-        end
+        retry_sequence_id  = nil
+        request_id         = SecureRandom.urlsafe_base64(10) if add_request_ids
 
         begin
           use_fallback = can_fallback_to_alternate_ably_host? && retry_count > 0
 
           connection(use_fallback: use_fallback).send(method, path, params) do |request|
             if add_request_ids
+              request.params[:request_id] = request_id
               request.options.context = {} if request.options.context.nil?
               request.options.context[:request_id] = request_id
             end
@@ -466,15 +459,30 @@ module Ably
                 end
               end
             end
+          end.tap do
+            if retry_count > 0
+              logger.warn do
+                "Ably::Rest::Client - Request SUCCEEDED after #{retry_count} #{retry_count > 1 ? 'retries' : 'retry' } for" \
+                " #{method} #{path} #{params} (seq ##{retry_sequence_id}, time elapsed #{(Time.now.to_f - requested_at.to_f).round(2)}s)"
+              end
+            end
           end
 
         rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
+          retry_sequence_id ||= SecureRandom.urlsafe_base64(4)
           time_passed = Time.now - requested_at
+
           if can_fallback_to_alternate_ably_host? && retry_count < max_retry_count && time_passed <= max_retry_duration
             retry_count += 1
-            logger.warn { "Ably::Rest::Client - Retry #{retry_count} for #{method} #{path} #{params} as initial attempt failed: #{error}" }
+            logger.warn { "Ably::Rest::Client - Retry #{retry_count} for #{method} #{path} #{params} as initial attempt failed (seq ##{retry_sequence_id}): #{error}" }
             retry
           end
+
+          logger.error do
+            "Ably::Rest::Client - Request FAILED after #{retry_count} #{retry_count > 1 ? 'retries' : 'retry' } for" \
+            " #{method} #{path} #{params} (seq ##{retry_sequence_id}, time elapsed #{(Time.now.to_f - requested_at.to_f).round(2)}s)"
+          end
+
           case error
             when Faraday::TimeoutError
               raise Ably::Exceptions::ConnectionTimeout.new(error.message, nil, 80014, error, { request_id: request_id })
@@ -549,7 +557,7 @@ module Ably
           setup_incoming_middleware builder, logger, fail_if_unsupported_mime_type: true
 
           # Set Faraday's HTTP adapter
-          builder.adapter Faraday.default_adapter
+          builder.adapter :excon
         end
       end
 

data/lib/ably/version.rb

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

data/spec/acceptance/realtime/auth_spec.rb

@@ -206,7 +206,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           context 'with a slow auth callback response' do
             let(:auth_callback) do
-              Proc.new do
+              lambda do |token_params|
                 sleep pause
                 rest_auth_client.auth.request_token
               end
@@ -214,7 +214,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
             it 'asynchronously authenticates' do
               timers_called = 0
-              block = Proc.new do
+              block = lambda do
                 timers_called += 1
                 EventMachine.add_timer(0.5, &block)
               end
@@ -230,7 +230,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
         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) }
+          let(:client_options)   { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }, client_id: client_id, log_level: :none) }
           let(:rest_auth_client) { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')) }
 
           context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
@@ -268,7 +268,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
         context 'when explicitly called, with an explicit ClientOptions client_id' do
           let(:auth_proc) do
-            Proc.new do
+            lambda do |token_params|
               if !@requested
                 @requested = true
                 valid_auth_token
@@ -304,18 +304,18 @@ describe Ably::Realtime::Auth, :event_machine do
           let(:rest_client)      { Ably::Rest::Client.new(default_options) }
           let(:client_publisher) { auto_close Ably::Realtime::Client.new(default_options) }
           let(:basic_capability) { JSON.dump("foo" => ["subscribe"]) }
-          let(:basic_token_cb)   { Proc.new do
+          let(:basic_token_cb)   { lambda do |token_params|
             rest_client.auth.create_token_request({ capability: basic_capability })
           end }
           let(:upgraded_capability) { JSON.dump({ "foo" => ["subscribe", "publish"] }) }
-          let(:upgraded_token_cb)   { Proc.new do
+          let(:upgraded_token_cb)   { lambda do |token_params|
             rest_client.auth.create_token_request({ capability: upgraded_capability })
           end }
-          let(:identified_token_cb) { Proc.new do
+          let(:identified_token_cb) { lambda do |token_params|
             rest_client.auth.create_token_request({ client_id: 'bob' })
           end }
           let(:downgraded_capability) { JSON.dump({ "bar" => ["subscribe"] }) }
-          let(:downgraded_token_cb)   { Proc.new do
+          let(:downgraded_token_cb)   { lambda do |token_params|
             rest_client.auth.create_token_request({ capability: downgraded_capability })
           end }
 
@@ -589,7 +589,7 @@ describe Ably::Realtime::Auth, :event_machine do
           context 'when client is identified' do
             let(:client_options) { default_options.merge(auth_callback: basic_token_cb, log_level: :none) }
 
-            let(:basic_token_cb)   { Proc.new do
+            let(:basic_token_cb)   { lambda do |token_params|
               rest_client.auth.create_token_request({ client_id: 'mike', capability: basic_capability })
             end }
 
@@ -612,7 +612,7 @@ describe Ably::Realtime::Auth, :event_machine do
               connection_failed = false
 
               client.connection.once(:connected) do
-                client.auth.authorize(nil, auth_callback: Proc.new { 'invalid.token:will.cause.failure' }).tap do |deferrable|
+                client.auth.authorize(nil, auth_callback: lambda { |token_params| 'invalid.token:will.cause.failure' }).tap do |deferrable|
                   deferrable.errback do |error|
                     EventMachine.add_timer(0.2) do
                       expect(connection_failed).to eql(true)
@@ -638,7 +638,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
             it 'calls the error callback of authorize and leaves the connection intact (#RSA4c3)' do
               client.connection.once(:connected) do
-                client.auth.authorize(nil, auth_callback: Proc.new { raise 'Exception raised' }).errback do |error|
+                client.auth.authorize(nil, auth_callback: lambda { |token_params| raise 'Exception raised' }).errback do |error|
                   EventMachine.add_timer(0.2) do
                     expect(connection).to be_connected
                     expect(error.message).to match(/Exception raised/i)
@@ -1014,33 +1014,9 @@ describe Ably::Realtime::Auth, :event_machine do
       end
     end
 
-    context 'deprecated #authorise' do
+    context 'deprecated #authorise', :prevent_log_stubbing do
       let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object, use_token_auth: true) }
-      let(:custom_logger) do
-        Class.new do
-          def initialize
-            @messages = []
-          end
-
-          [:fatal, :error, :warn, :info, :debug].each do |severity|
-            define_method severity do |message|
-              @messages << [severity, message]
-            end
-          end
-
-          def logs
-            @messages
-          end
-
-          def level
-            1
-          end
-
-          def level=(new_level)
-          end
-        end
-      end
-      let(:custom_logger_object) { custom_logger.new }
+      let(:custom_logger_object) { TestLogger.new }
 
       it 'logs a deprecation warning (#RSA10l)' do
         client.auth.authorise

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -77,7 +77,13 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
             limit.times do |index|
               expect(next_page.items[index].data).to eql("history#{index + limit}")
             end
-            expect(next_page).to be_last
+            if next_page.has_next?
+              next_page.next do |last|
+                expect(last.items.length).to eql(0)
+              end
+            else
+              expect(next_page).to be_last
+            end
 
             stop_reactor
           end

data/spec/acceptance/realtime/channel_spec.rb

@@ -1342,7 +1342,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'many times with different event names' do
         it 'filters events accordingly to each callback' do
-          click_callback = proc { |message| messages << message }
+          click_callback = lambda { |message| messages << message }
 
           channel.subscribe('click', &click_callback)
           channel.subscribe('move', &click_callback)
@@ -1958,7 +1958,7 @@ describe Ably::Realtime::Channel, :event_machine do
             specify 'all queued messages fail with NACK (#RTL11)' do
               channel.attach do
                 # Move to disconnected
-                disconnect_transport_proc = Proc.new do
+                disconnect_transport_proc = lambda do
                   if connection.transport
                     connection.transport.close_connection_after_writing
                   else
@@ -2090,7 +2090,7 @@ describe Ably::Realtime::Channel, :event_machine do
         it 'will move to the SUSPENDED state and then attempt to ATTACH with the ATTACHING state (#RTL13b)' do
           connection.once(:connected) do
             # Prevent any incoming or outgoing ATTACH/ATTACHED message from Ably
-            prevent_protocol_messages_proc = Proc.new do
+            prevent_protocol_messages_proc = lambda do
               if client.connection.transport
                 client.connection.transport.__incoming_protocol_msgbus__.unsubscribe
                 client.connection.transport.__outgoing_protocol_msgbus__.unsubscribe

data/spec/acceptance/realtime/client_spec.rb

@@ -134,7 +134,7 @@ describe Ably::Realtime::Client, :event_machine do
 
           context 'with a wildcard client_id token' do
             subject                 { auto_close Ably::Realtime::Client.new(client_options) }
-            let(:client_options)    { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+            let(:client_options)    { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }, client_id: client_id) }
             let(:rest_auth_client)  { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
             let(:auth_token_object) { rest_auth_client.auth.request_token(client_id: '*') }
 
@@ -155,7 +155,7 @@ describe Ably::Realtime::Client, :event_machine do
             end
 
             context 'and client_id omitted in ClientOptions' do
-              let(:client_options) { default_options.merge(auth_callback: Proc.new { auth_token_object }) }
+              let(:client_options) { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }) }
 
               it 'uses the token provided clientId in the connection' do
                 connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -143,7 +143,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       context 'with auth_callback' do
         context 'opening a new connection' do
           context 'when callback fails due to an exception' do
-            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_callback: Proc.new { raise "Cannot issue token" }, log_level: :fatal) }
+            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_callback: lambda { |token_params| raise "Cannot issue token" }, log_level: :fatal) }
 
             it 'the connection moves to the disconnected state and tries again, returning again to the disconnected state (#RSA4c, #RSA4c1, #RSA4c2)' do
               states = Hash.new { |hash, key| hash[key] = [] }
@@ -174,7 +174,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 use_token_auth: true,
                 log_level: :fatal)
               }
-              let(:auth_options) { { auth_callback: Proc.new { sleep 10 }, } }
+              let(:auth_options) { { auth_callback: lambda { |token_params| sleep 10 }, } }
 
               it 'the authorization request fails as configured in the realtime_request_timeout (#RSA4c, #RSA4c1, #RSA4c3)' do
                 connection.once(:connected) do
@@ -514,6 +514,216 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
+        context 'connection state freshness is monitored' do
+          it 'resumes connections when disconnected within the connection_state_ttl period (#RTN15g)' do
+            connection.once(:connected) do
+              connection_id = connection.id
+              reconnected_with_resume = false
+
+              # Make sure the next connect has the resume param
+              allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                url = args[4]
+                uri = URI.parse(url)
+                expect(CGI::parse(uri.query)['resume'][0]).to_not be_empty
+                reconnected_with_resume = true
+                original.call(*args, &block)
+              end
+
+              connection.once(:disconnected) do
+                disconnected_at = Time.now
+
+                connection.once(:connecting) do
+                  expect(Time.now.to_f - disconnected_at.to_f).to be < connection.connection_state_ttl
+                  connection.once(:connected) do |state_change|
+                    expect(connection.id).to eql(connection_id)
+                    expect(reconnected_with_resume).to be_truthy
+                    stop_reactor
+                  end
+                end
+              end
+
+              connection.transport.unbind
+            end
+          end
+
+          context 'when connection_state_ttl period has passed since being disconnected' do
+            let(:client_options) do
+              default_options.merge(
+                disconnected_retry_timeout: 4,
+                suspended_retry_timeout:    8,
+                max_connection_state_ttl:   2,
+              )
+            end
+
+            it 'clears the local connection state and uses a new connection when the connection_state_ttl period has passed (#RTN15g)' do
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  connection.once(:connecting) do
+                    connection.once(:disconnected) do
+                      # Make sure the next connect does not have the resume param
+                      allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                        url = args[4]
+                        uri = URI.parse(url)
+                        expect(CGI::parse(uri.query)['resume']).to be_empty
+                        resumed_with_clean_connection = true
+                        original.call(*args, &block)
+                      end
+
+                      allow(connection.details).to receive(:max_idle_interval).and_return(0)
+                      connection.__incoming_protocol_msgbus__.plugin_listeners
+
+                      connection.once(:connecting) do
+                        expect(Time.now.to_f - disconnected_at.to_f).to be > connection.connection_state_ttl
+                        connection.once(:connected) do |state_change|
+                          expect(connection.id).to_not eql(connection_id)
+                          expect(resumed_with_clean_connection).to be_truthy
+                          stop_reactor
+                        end
+                      end
+                    end
+
+                    # Disconnect the transport and trigger a new disconnected state
+                    wait_until(lambda { connection.transport }) do
+                      connection.transport.unbind
+                    end
+                  end
+
+                  connection.__incoming_protocol_msgbus__.unplug_listeners
+                end
+
+                connection.transport.unbind
+              end
+            end
+          end
+
+          context 'when connection_state_ttl period has passed since last activity on the connection' do
+            let(:client_options) do
+              default_options.merge(
+                max_connection_state_ttl: 2,
+              )
+            end
+
+            it 'does not clear the local connection state when the connection_state_ttl period has passed since last activity, but the idle timeout has not passed (#RTN15g1, #RTN15g2)' do
+              expect(connection.connection_state_ttl).to eql(client_options.fetch(:max_connection_state_ttl))
+
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(connection.connection_state_ttl + 1)
+
+                  # Make sure the next connect does not have the resume param
+                  allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                    url = args[4]
+                    uri = URI.parse(url)
+                    expect(CGI::parse(uri.query)['resume']).to_not be_empty
+                    resumed_connection = true
+                    original.call(*args, &block)
+                  end
+
+                  connection.once(:connecting) do
+                    connection.once(:connected) do |state_change|
+                      expect(connection.id).to eql(connection_id)
+                      expect(resumed_connection).to be_truthy
+                      stop_reactor
+                    end
+                  end
+                end
+
+                connection.transport.unbind
+              end
+            end
+
+            it 'clears the local connection state and uses a new connection when the connection_state_ttl + max_idle_interval period has passed since last activity (#RTN15g1, #RTN15g2)' do
+              expect(connection.connection_state_ttl).to eql(client_options.fetch(:max_connection_state_ttl))
+
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  pseudo_time_passed = connection.connection_state_ttl + connection.details.max_idle_interval + 1
+                  allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(pseudo_time_passed)
+
+                  # Make sure the next connect does not have the resume param
+                  allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                    url = args[4]
+                    uri = URI.parse(url)
+                    expect(CGI::parse(uri.query)['resume']).to be_empty
+                    resumed_with_clean_connection = true
+                    original.call(*args, &block)
+                  end
+
+                  connection.once(:connecting) do
+                    connection.once(:connected) do |state_change|
+                      expect(connection.id).to_not eql(connection_id)
+                      expect(resumed_with_clean_connection).to be_truthy
+                      stop_reactor
+                    end
+                  end
+                end
+
+                connection.transport.unbind
+              end
+            end
+
+            it 'still reattaches the channels automatically following a new connection being established (#RTN15g2)' do
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+                channel_emitted_an_attached = false
+
+                channel.attach do
+                  channel.once(:attached) do |channel_state_change|
+                    expect(channel_state_change.resumed).to be_falsey
+                    channel_emitted_an_attached = true
+                  end
+
+                  connection.once(:disconnected) do
+                    disconnected_at = Time.now
+
+                    pseudo_time_passed = connection.connection_state_ttl + connection.details.max_idle_interval + 1
+                    allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(pseudo_time_passed)
+
+                    # Make sure the next connect does not have the resume param
+                    allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                      url = args[4]
+                      uri = URI.parse(url)
+                      expect(CGI::parse(uri.query)['resume']).to be_empty
+                      resumed_with_clean_connection = true
+                      original.call(*args, &block)
+                    end
+
+                    connection.once(:connecting) do
+                      connection.once(:connected) do |state_change|
+                        expect(connection.id).to_not eql(connection_id)
+                        expect(resumed_with_clean_connection).to be_truthy
+
+                        wait_until(lambda { channel.attached? }) do
+                          expect(channel_emitted_an_attached).to be_truthy
+                          stop_reactor
+                        end
+                      end
+                    end
+                  end
+
+                  connection.transport.unbind
+                end
+              end
+            end
+          end
+        end
+
         context 'and subsequently fails to reconnect' do
           let(:retry_every) { 1.5 }
 
@@ -935,16 +1145,20 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               previous_connection_id  = connection.id
               previous_connection_key = connection.key
 
-              five_minutes_time = Time.now + 5 * 60
-              allow(Time).to receive(:now) { five_minutes_time }
-
               connection.once(:connected) do
                 expect(connection.key).to_not eql(previous_connection_key)
                 expect(connection.id).to_not eql(previous_connection_id)
                 stop_reactor
               end
 
-              kill_connection_transport_and_prevent_valid_resume
+              # Wait until next tick before stubbing otherwise liveness test may
+              # record the stubbed last contact time as the future time
+              EventMachine.next_tick do
+                five_minutes_time = Time.now + 5 * 60
+                allow(Time).to receive(:now) { five_minutes_time }
+
+                kill_connection_transport_and_prevent_valid_resume
+              end
             end
           end
         end
@@ -1017,7 +1231,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           }
 
           let(:client_options) do
-            default_options.merge(auth_callback: Proc.new do
+            default_options.merge(auth_callback: lambda do |token_params|
               @auth_requests ||= 0
               @auth_requests += 1