ably 0.7.0 → 0.7.1

data/lib/ably/realtime/channels.rb

@@ -15,6 +15,7 @@ module Ably
       # @param name [String] The name of the channel
       # @param channel_options [Hash] Channel options, currently reserved for Encryption options
       # @return [Ably::Realtime::Channel}
+      #
       def get(*args)
         super
       end
@@ -27,6 +28,7 @@ module Ably
       # @yield [options] (optional) if a missing_block is passed to this method and no channel exists matching the name, this block is called
       # @yieldparam [String] name of the missing channel
       # @return [Ably::Realtime::Channel]
+      #
       def fetch(*args)
         super
       end
@@ -37,6 +39,7 @@ module Ably
       # the memory footprint of the {Ably::Realtime::Channel Realtime Channel object}. Release channels to free up resources if required
       #
       # @return [void]
+      #
       def release(channel)
         get(channel).detach do
           @channels.delete(channel)

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

@@ -54,7 +54,7 @@ module Ably::Realtime
 
           when ACTION.Connect
           when ACTION.Connected
-            connection.transition_state_machine :connected
+            connection.transition_state_machine :connected, protocol_message.error
 
           when ACTION.Disconnect, ACTION.Disconnected
             connection.transition_state_machine :disconnected, protocol_message.error
@@ -118,6 +118,7 @@ module Ably::Realtime
       def update_connection_recovery_info(protocol_message)
         if protocol_message.connection_key && (protocol_message.connection_key != connection.key)
           logger.debug "New connection ID set to #{protocol_message.connection_id} with connection key #{protocol_message.connection_key}"
+          detach_attached_channels protocol_message.error if protocol_message.error
           connection.update_connection_id_and_key protocol_message.connection_id, protocol_message.connection_key
         end
 
@@ -126,6 +127,15 @@ module Ably::Realtime
         end
       end
 
+      def detach_attached_channels(error)
+        channels.select do |channel|
+          channel.attached? || channel.attaching?
+        end.each do |channel|
+          logger.warn "Detaching channel '#{channel.name}': #{error}"
+          channel.manager.suspend error
+        end
+      end
+
       def ack_pending_queue_for_message_serial(ack_protocol_message)
         drop_pending_queue_from_ack(ack_protocol_message) do |protocol_message|
           ack_messages protocol_message.messages

data/lib/ably/realtime/connection.rb

@@ -156,7 +156,7 @@ module Ably
       #
       # @return [void]
       #
-      def ping(&block)
+      def ping
         raise RuntimeError, 'Cannot send a ping when connection is not open' if initialized?
         raise RuntimeError, 'Cannot send a ping when connection is in a closed or failed state' if closed? || failed?
 
@@ -166,7 +166,7 @@ module Ably
           if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
             __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
             time_passed = (Time.now.to_f * 1000 - started.to_f * 1000).to_i
-            block.call time_passed if block_given?
+            yield time_passed if block_given?
           end
         end
 
@@ -177,6 +177,25 @@ module Ably
         end
       end
 
+      # @yield [Boolean] True if an internet connection check appears to be up following an HTTP request to a reliable CDN
+      # @return [EventMachine::Deferrable]
+      # @api private
+      def internet_up?
+        EventMachine::DefaultDeferrable.new.tap do |deferrable|
+          EventMachine::HttpRequest.new(Ably::INTERNET_CHECK.fetch(:url)).get.tap do |http|
+            http.errback do
+              yield false if block_given?
+              deferrable.fail
+            end
+            http.callback do
+              result = http.response_header.status == 200 && http.response.strip == Ably::INTERNET_CHECK.fetch(:ok_text)
+              yield result if block_given?
+              deferrable.succeed
+            end
+          end
+        end
+      end
+
       # @!attribute [r] recovery_key
       #   @return [String] recovery key that can be used by another client to recover this connection with the :recover option
       def recovery_key
@@ -220,16 +239,31 @@ module Ably
         @__incoming_protocol_msgbus__ ||= create_pub_sub_message_bus
       end
 
-      # @!attribute [r] host
-      # @return [String] The host name used for this connection, for network connection failures a {Ably::FALLBACK_HOSTS fallback host} is used to route around networking or intermittent problems
-      def host
+      # Determines the correct host name to use for the next connection attempt and updates current_host
+      # @yield [String] The host name used for this connection, for network connection failures a {Ably::FALLBACK_HOSTS fallback host} is used to route around networking or intermittent problems if an Internet connection is available
+      # @api private
+      def determine_host
+        raise ArgumentError, 'Block required' unless block_given?
+
         if can_use_fallback_hosts?
-          client.fallback_endpoint.host
+          internet_up? do |internet_is_up_result|
+            @current_host = if internet_is_up_result
+              client.fallback_endpoint.host
+            else
+              client.endpoint.host
+            end
+            yield current_host
+          end
         else
-          client.endpoint.host
+          @current_host = client.endpoint.host
+          yield current_host
         end
       end
 
+      # @return [String] The current host that is configured following a call to method {#determine_host}
+      # @api private
+      attr_reader :current_host
+
       # @!attribute [r] port
       # @return [Integer] The default port used for this connection
       def port
@@ -270,8 +304,10 @@ module Ably
       end
 
       # @api private
-      def create_websocket_transport(&block)
-        operation = proc do
+      def create_websocket_transport
+        raise ArgumentError, 'Block required' unless block_given?
+
+        blocking_operation = proc do
           URI(client.endpoint).tap do |endpoint|
             url_params = client.auth.auth_params.merge(
               timestamp: as_since_epoch(Time.now),
@@ -295,17 +331,20 @@ module Ably
         end
 
         callback = proc do |url|
-          begin
-            @transport = EventMachine.connect(host, port, WebsocketTransport, self, url) do |websocket_transport|
-              yield websocket_transport if block_given?
+          determine_host do |host|
+            begin
+              logger.debug "Connection: Opening socket connection to #{host}:#{port} and URL '#{url}'"
+              @transport = EventMachine.connect(host, port, WebsocketTransport, self, url) do |websocket_transport|
+                yield websocket_transport if block_given?
+              end
+            rescue EventMachine::ConnectionError => error
+              manager.connection_opening_failed error
             end
-          rescue EventMachine::ConnectionError => error
-            manager.connection_opening_failed error
           end
         end
 
         # client.auth.auth_params is a blocking call, so defer this into a thread
-        EventMachine.defer operation, callback
+        EventMachine.defer blocking_operation, callback
       end
 
       # @api private
@@ -350,7 +389,7 @@ module Ably
       end
 
       # Simply wait until the next EventMachine tick to ensure Connection initialization is complete
-      def when_initialized(&block)
+      def when_initialized
         EventMachine.next_tick { yield }
       end
 

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

@@ -47,7 +47,7 @@ module Ably::Realtime
       #
       # @yield [Ably::Realtime::Connection::WebsocketTransport] block is called with new websocket transport
       # @api private
-      def setup_transport(&block)
+      def setup_transport
         if transport && !transport.ready_for_release?
           raise RuntimeError, 'Existing WebsocketTransport is connected, and must be closed first'
         end
@@ -57,14 +57,14 @@ module Ably::Realtime
           return
         end
 
-        logger.debug "ConnectionManager: Opening connection to #{connection.host}:#{connection.port}"
+        logger.debug 'ConnectionManager: Opening a websocket transport connection'
 
         connection.create_websocket_transport do |websocket_transport|
           subscribe_to_transport_events websocket_transport
           yield websocket_transport if block_given?
         end
 
-        logger.debug 'ConnectionManager: Setting up automatic connection timeout timer for #{TIMEOUTS.fetch(:open)}s'
+        logger.debug "ConnectionManager: Setting up automatic connection timeout timer for #{TIMEOUTS.fetch(:open)}s"
         create_timeout_timer_whilst_in_state(:connect, TIMEOUTS.fetch(:open)) do
           connection_opening_failed Ably::Exceptions::ConnectionTimeoutError.new("Connection to Ably timed out after #{TIMEOUTS.fetch(:open)}s", nil, 80014)
         end
@@ -74,10 +74,18 @@ module Ably::Realtime
       #
       # @api private
       def connection_opening_failed(error)
-        logger.warn "ConnectionManager: Connection to #{connection.host}:#{connection.port} failed; #{error.message}"
+        logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
         connection.transition_state_machine next_retry_state, Ably::Exceptions::ConnectionError.new("Connection failed; #{error.message}", nil, 80000)
       end
 
+      # Called whenever a new connection message is received with an error
+      #
+      # @api private
+      def connected_with_error(error)
+        logger.warn "ConnectionManager: Connected with error; #{error.message}"
+        connection.trigger :error, error
+      end
+
       # Ensures the underlying transport has been disconnected and all event emitter callbacks removed
       #
       # @api private
@@ -96,7 +104,7 @@ module Ably::Realtime
         if !transport || transport.disconnected?
           setup_transport
         else
-          transport.reconnect connection.host, connection.port
+          transport.reconnect connection.current_host, connection.port
         end
       end
 
@@ -119,6 +127,15 @@ module Ably::Realtime
         connection.transition_state_machine :closed
       end
 
+      # Connection has failed
+      #
+      # @api private
+      def fail(error)
+        connection.logger.fatal "ConnectionManager: Connection failed - #{error}"
+        connection.manager.destroy_transport
+        connection.once(:failed) { connection.trigger :error, error }
+      end
+
       # When a connection is disconnected whilst connecting, attempt reconnect and/or set state to :suspended or :failed
       #
       # @api private
@@ -192,11 +209,11 @@ module Ably::Realtime
 
       # Create a timer that will execute in timeout_in seconds.
       # If the connection state changes however, cancel the timer
-      def create_timeout_timer_whilst_in_state(timer_id, timeout_in, &block)
-        raise 'Block required for timer' unless block_given?
+      def create_timeout_timer_whilst_in_state(timer_id, timeout_in)
+        raise ArgumentError, 'Block required' unless block_given?
 
         timers[timer_id] << EventMachine::Timer.new(timeout_in) do
-          block.call
+          yield
         end
         connection.once_state_changed { clear_timers timer_id }
       end

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

@@ -40,6 +40,10 @@ module Ably::Realtime
         connection.manager.reconnect_transport
       end
 
+      after_transition(to: [:connected]) do |connection, current_transition|
+        connection.manager.connected_with_error current_transition.metadata if current_transition.metadata
+      end
+
       after_transition(to: [:disconnected, :suspended], from: [:connecting]) do |connection, current_transition|
         connection.manager.respond_to_transport_disconnected_when_connecting current_transition
       end
@@ -52,9 +56,8 @@ module Ably::Realtime
         connection.manager.destroy_transport # never reuse a transport if the connection has failed
       end
 
-      after_transition(to: [:failed]) do |connection, current_transition|
-        connection.logger.fatal "ConnectionStateMachine: Connection failed - #{current_transition.metadata}"
-        connection.manager.destroy_transport
+      before_transition(to: [:failed]) do |connection, current_transition|
+        connection.manager.fail current_transition.metadata
       end
 
       after_transition(to: [:closing], from: [:initialized, :disconnected, :suspended]) do |connection|
@@ -70,12 +73,9 @@ module Ably::Realtime
       end
 
       # Transitions responsible for updating connection#error_reason
-      before_transition(to: [:disconnected, :suspended, :failed]) do |connection, current_transition|
-        connection.set_failed_connection_error_reason current_transition.metadata
-      end
-
-      before_transition(to: [:connected, :closed]) do |connection, current_transition|
-        connection.set_failed_connection_error_reason nil
+      before_transition(to: [:connected, :closed, :disconnected, :suspended, :failed]) do |connection, current_transition|
+        reason = current_transition.metadata if is_error_type?(current_transition.metadata)
+        connection.set_failed_connection_error_reason reason
       end
 
       private

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

@@ -128,9 +128,9 @@ module Ably::Realtime
         end
       end
 
-      def create_timer(period, &block)
+      def create_timer(period)
         @timer = EventMachine::Timer.new(period) do
-          block.call
+          yield
         end
       end
 

data/lib/ably/realtime/presence.rb

@@ -57,7 +57,7 @@ module Ably::Realtime
     #
     def enter(options = {}, &success_block)
       @client_id = options.fetch(:client_id, client_id)
-      @data      = options.fetch(:data, data)
+      @data      = options.fetch(:data, nil)
       deferrable = EventMachine::DefaultDeferrable.new
 
       raise Ably::Exceptions::Standard.new('Unable to enter presence channel without a client_id', 400, 91000) unless client_id
@@ -115,7 +115,7 @@ module Ably::Realtime
     # @return (see Presence#enter)
     #
     def leave(options = {}, &success_block)
-      @data      = options.fetch(:data) if options.has_key?(:data)
+      @data      = options.fetch(:data, data) # nil value defaults leave data to existing value
       deferrable = EventMachine::DefaultDeferrable.new
 
       raise Ably::Exceptions::Standard.new('Unable to leave presence channel that is not entered', 400, 91002) unless able_to_leave?
@@ -168,7 +168,7 @@ module Ably::Realtime
     # @return (see Presence#enter)
     #
     def update(options = {}, &success_block)
-      @data      = options.fetch(:data) if options.has_key?(:data)
+      @data      = options.fetch(:data, nil)
       deferrable = EventMachine::DefaultDeferrable.new
 
       ensure_channel_attached(deferrable) do
@@ -211,9 +211,9 @@ module Ably::Realtime
     #
     # @yield [Array<Ably::Models::PresenceMessage>] array of members or the member
     #
-    # @return [EventMachine::Deferrable] Deferrable that supports both success (callback) and failure (errback) callback
+    # @return [EventMachine::Deferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
     #
-    def get(options = {}, &success_block)
+    def get(options = {})
       wait_for_sync = options.fetch(:wait_for_sync, true)
       deferrable    = EventMachine::DefaultDeferrable.new
 
@@ -222,18 +222,17 @@ module Ably::Realtime
           members.map { |key, presence| presence }.tap do |filtered_members|
             filtered_members.keep_if { |presence| presence.connection_id == options[:connection_id] } if options[:connection_id]
             filtered_members.keep_if { |presence| presence.client_id == options[:client_id] } if options[:client_id]
+          end.tap do |current_members|
+            yield current_members if block_given?
+            deferrable.succeed current_members
           end
         end
 
         if !wait_for_sync || sync_complete?
-          result = result_block.call
-          success_block.call result if block_given?
-          deferrable.succeed result
+          result_block.call
         else
           sync_pubsub.once(:done) do
-            result = result_block.call
-            success_block.call result if block_given?
-            deferrable.succeed result
+            result_block.call
           end
 
           sync_pubsub.once(:failed) do |error|
@@ -486,7 +485,7 @@ module Ably::Realtime
 
     def send_protocol_message_and_transition_state_to(action, options = {}, &success_block)
       deferrable   = options.fetch(:deferrable) { raise ArgumentError, 'option :deferrable is required' }
-      client_id    = options.fetch(:client_id) { raise ArgumentError, 'option :client_id is required' }
+      client_id    = options.fetch(:client_id)  { raise ArgumentError, 'option :client_id is required' }
       target_state = options.fetch(:target_state, nil)
       failed_state = options.fetch(:failed_state, nil)
 
@@ -509,14 +508,14 @@ module Ably::Realtime
       end
     end
 
-    def deferrable_succeed(deferrable, *args, &block)
-      block.call self, *args if block_given?
-      EventMachine.next_tick { deferrable.succeed self, *args } # allow callback to be added to the returned Deferrable
+    def deferrable_succeed(deferrable, *args)
+      yield self, *args if block_given?
+      EventMachine.next_tick { deferrable.succeed self, *args } # allow callback to be added to the returned Deferrable before calling succeed
       deferrable
     end
 
-    def deferrable_fail(deferrable, *args, &block)
-      block.call self, *args if block_given?
+    def deferrable_fail(deferrable, *args)
+      yield self, *args if block_given?
       EventMachine.next_tick { deferrable.fail self, *args } # allow errback to be added to the returned Deferrable
       deferrable
     end

data/lib/ably/util/crypto.rb

@@ -62,7 +62,7 @@ module Ably::Util
     # @return [String]
     #
     def decrypt(encrypted_payload_with_iv)
-      raise Ably::Exceptions::EncryptionError, 'iv is missing or not long enough' unless encrypted_payload_with_iv.length >= BLOCK_LENGTH*2
+      raise Ably::Exceptions::CipherError, 'iv is missing or not long enough' unless encrypted_payload_with_iv.length >= BLOCK_LENGTH*2
 
       iv = encrypted_payload_with_iv.slice(0...BLOCK_LENGTH)
       encrypted_payload = encrypted_payload_with_iv.slice(BLOCK_LENGTH..-1)

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -60,8 +60,9 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
     end
 
     context 'with lots of messages published with a single client and channel' do
-      let(:messages_sent) { 40 }
-      let(:limit)         { 20 }
+      let(:messages_sent)   { 30 }
+      let(:rate_per_second) { 4 }
+      let(:limit)           { 15 }
 
       def ensure_message_history_direction_and_paging_is_correct(direction)
         channel.history(direction: direction, limit: limit) do |history|
@@ -102,10 +103,10 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         end
       end
 
-      context 'in multiple ProtocolMessages' do
+      context 'in multiple ProtocolMessages', em_timeout: (30 / 4) + 20 do
         it 'retrieves limited history forwards with pagination' do
           messages_sent.times do |index|
-            EventMachine.add_timer(index.to_f / 10) do
+            EventMachine.add_timer(index.to_f / rate_per_second) do
               channel.publish('event', "history#{index}") do
                 next unless index == messages_sent - 1
                 ensure_message_history_direction_and_paging_is_correct :forwards
@@ -116,7 +117,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
         it 'retrieves limited history backwards with pagination' do
           messages_sent.times.to_a.reverse.each do |index|
-            EventMachine.add_timer((messages_sent - index).to_f / 10) do
+            EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
               channel.publish('event', "history#{index}") do
                 next unless index == 0
                 ensure_message_history_direction_and_paging_is_correct :backwards if index == 0