ably 0.8.2 → 0.8.3

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

@@ -26,7 +26,7 @@ module Ably::Realtime
 
       # Commence attachment
       def detach(error = nil)
-        if connection.closed? || connection.connecting?
+        if connection.closed? || connection.connecting? || connection.suspended?
           channel.transition_state_machine :detached, error
         elsif can_transition_to?(:detached)
           send_detach_protocol_message
@@ -59,7 +59,7 @@ module Ably::Realtime
       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
-          error = Ably::Exceptions::MessageDeliveryError.new('Channel is no longer in a state suitable to deliver this message to the server') unless error
+          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
         end
@@ -123,8 +123,16 @@ module Ably::Realtime
           channel.transition_state_machine :detaching if can_transition_to?(:detaching)
         end
 
+        connection.unsafe_on(:suspended) do |error|
+          if can_transition_to?(:detaching)
+            channel.transition_state_machine :detaching, Ably::Exceptions::ConnectionSuspended.new('Connection suspended', nil, 80002, error)
+          end
+        end
+
         connection.unsafe_on(:failed) do |error|
-          channel.transition_state_machine :failed, error if can_transition_to?(:failed)
+          if can_transition_to?(:failed)
+            channel.transition_state_machine :failed, Ably::Exceptions::ConnectionFailed.new('Connection failed', nil, 80002, error)
+          end
         end
       end
 

data/lib/ably/realtime/client.rb

@@ -34,10 +34,14 @@ module Ably
       # @return [Ably::Rest::Client]
       attr_reader :rest_client
 
-      # When false the client suppresses messages originating from this connection being echoed back on the same connection.  Defaults to true
+      # When false the client suppresses messages originating from this connection being echoed back on the same connection. Defaults to true
       # @return [Boolean]
       attr_reader :echo_messages
 
+      # If false, this disables the default behaviour whereby the library queues messages on a connection in the disconnected or connecting states. Defaults to true
+      # @return [Boolean]
+      attr_reader :queue_messages
+
       # The custom realtime websocket host that is being used if it was provided with the option `:ws_host` when the {Client} was created
       # @return [String,Nil]
       attr_reader :custom_realtime_host
@@ -52,7 +56,8 @@ module Ably
 
       def_delegators :auth, :client_id, :auth_options
       def_delegators :@rest_client, :encoders
-      def_delegators :@rest_client, :environment, :use_tls?, :protocol, :protocol_binary?, :custom_host
+      def_delegators :@rest_client, :use_tls?, :protocol, :protocol_binary?
+      def_delegators :@rest_client, :environment, :custom_host, :custom_port, :custom_tls_port
       def_delegators :@rest_client, :log_level
 
       # Creates a {Ably::Realtime::Client Realtime Client} and configures the {Ably::Auth} object for the connection.
@@ -75,9 +80,10 @@ module Ably
       #
       def initialize(options)
         @rest_client           = Ably::Rest::Client.new(options)
-        @auth                  = @rest_client.auth
+        @auth                  = Ably::Realtime::Auth.new(self)
         @channels              = Ably::Realtime::Channels.new(self)
         @echo_messages         = @rest_client.options.fetch(:echo_messages, true) == false ? false : true
+        @queue_messages        = @rest_client.options.fetch(:queue_messages, true) == false ? false : true
         @custom_realtime_host  = @rest_client.options[:realtime_host] || @rest_client.options[:ws_host]
         @auto_connect          = @rest_client.options.fetch(:auto_connect, true) == false ? false : true
         @recover               = @rest_client.options[:recover]
@@ -174,12 +180,22 @@ module Ably
 
       private
       def endpoint_for_host(host)
-        URI::Generic.build(
+        port = if use_tls?
+          custom_tls_port
+        else
+          custom_port
+        end
+
+        raise ArgumentError, "Custom port must be an Integer or nil" if port && !port.kind_of?(Integer)
+
+        options = {
           scheme: use_tls? ? 'wss' : 'ws',
           host:   host
-        )
+        }
+        options.merge!(port: port) if port
+
+        URI::Generic.build(options)
       end
     end
   end
 end
-

data/lib/ably/realtime/connection.rb

@@ -184,23 +184,30 @@ module Ably
       # @return [EventMachine::Deferrable]
       # @api private
       def internet_up?
+        url = "http#{'s' if client.use_tls?}:#{Ably::INTERNET_CHECK.fetch(:url)}"
         EventMachine::DefaultDeferrable.new.tap do |deferrable|
-          EventMachine::HttpRequest.new("http#{'s' if client.use_tls?}:#{Ably::INTERNET_CHECK.fetch(:url)}").get.tap do |http|
+          EventMachine::HttpRequest.new(url).get.tap do |http|
             http.errback do
               yield false if block_given?
-              deferrable.fail
+              deferrable.fail "Unable to connect to #{url}"
             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
+              EventMachine.next_tick do
+                result = http.response_header.status == 200 && http.response.strip == Ably::INTERNET_CHECK.fetch(:ok_text)
+                yield result if block_given?
+                if result
+                  deferrable.succeed
+                else
+                  deferrable.fail "Unexpected response from #{url} (#{http.response_header.status})"
+                end
+              end
             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
+      # @return [String] recovery key that can be used by another client to recover this connection with the :recover option
       def recovery_key
         "#{key}:#{serial}" if connection_resumable?
       end
@@ -275,7 +282,7 @@ module Ably
       # @!attribute [r] port
       # @return [Integer] The default port used for this connection
       def port
-        client.use_tls? ? 443 : 80
+        client.use_tls? ? client.custom_tls_port || 443 : client.custom_port || 80
       end
 
       # @!attribute [r] logger
@@ -311,48 +318,51 @@ module Ably
         __outgoing_protocol_msgbus__.publish :protocol_message, protocol_message
       end
 
+      # @return [EventMachine::Deferrable]
       # @api private
       def create_websocket_transport
-        raise ArgumentError, 'Block required' unless block_given?
+        EventMachine::DefaultDeferrable.new.tap do |websocket_deferrable|
+          # Getting auth params can be blocking so uses a Deferrable
+          client.auth.auth_params.tap do |auth_deferrable|
+            auth_deferrable.callback do |auth_params|
+              url_params = auth_params.merge(
+                timestamp: as_since_epoch(Time.now),
+                format:    client.protocol,
+                echo:      client.echo_messages
+              )
+
+              if connection_resumable?
+                url_params.merge! resume: key, connection_serial: serial
+                logger.debug "Resuming connection key #{key} with serial #{serial}"
+              elsif connection_recoverable?
+                url_params.merge! recover: connection_recover_parts[:recover], connection_serial: connection_recover_parts[:connection_serial]
+                logger.debug "Recovering connection with key #{client.recover}"
+                once(:connected, :closed, :failed) do
+                  client.disable_automatic_connection_recovery
+                end
+              end
 
-        blocking_operation = proc do
-          URI(client.endpoint).tap do |endpoint|
-            url_params = client.auth.auth_params.merge(
-              timestamp: as_since_epoch(Time.now),
-              format:    client.protocol,
-              echo:      client.echo_messages
-            )
-
-            if connection_resumable?
-              url_params.merge! resume: key, connection_serial: serial
-              logger.debug "Resuming connection key #{key} with serial #{serial}"
-            elsif connection_recoverable?
-              url_params.merge! recover: connection_recover_parts[:recover], connection_serial: connection_recover_parts[:connection_serial]
-              logger.debug "Recovering connection with key #{client.recover}"
-              once(:connected, :closed, :failed) do
-                client.disable_automatic_connection_recovery
+              url = URI(client.endpoint).tap do |endpoint|
+                endpoint.query = URI.encode_www_form(url_params)
+              end.to_s
+
+              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|
+                    websocket_deferrable.succeed websocket_transport
+                  end
+                rescue EventMachine::ConnectionError => error
+                  websocket_deferrable.fail error
+                end
               end
             end
 
-            endpoint.query = URI.encode_www_form(url_params)
-          end.to_s
-        end
-
-        callback = proc do |url|
-          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
+            auth_deferrable.errback do |error|
+              websocket_deferrable.fail error
             end
           end
         end
-
-        # client.auth.auth_params is a blocking call, so defer this into a thread
-        EventMachine.defer blocking_operation, callback
       end
 
       # @api private
@@ -388,6 +398,13 @@ module Ably
         resume_callbacks.delete(callback)
       end
 
+      # Returns false if messages cannot be published as a result of message queueing being disabled
+      # @api private
+      def can_publish_messages?
+        connected? ||
+          ( (initialized? || connecting? || disconnected?) && client.queue_messages )
+      end
+
       # As we are using a state machine, do not allow change_state to be used
       # #transition_state_machine must be used instead
       private :change_state
@@ -451,8 +468,24 @@ module Ably
         client.recover.to_s.match(RECOVER_REGEX)
       end
 
+      def production?
+        client.environment.nil? || client.environment == :production
+      end
+
+      def custom_port?
+        if client.use_tls?
+          !!client.custom_tls_port
+        else
+          !!client.custom_port
+        end
+      end
+
+      def custom_host?
+        !!client.custom_realtime_host
+      end
+
       def can_use_fallback_hosts?
-        if client.environment.nil? && client.custom_realtime_host.nil?
+        if production? && !custom_port? && !custom_host?
           if connecting? && previous_state
             use_fallback_if_disconnected? || use_fallback_if_suspended?
           end

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

@@ -53,20 +53,25 @@ module Ably::Realtime
         end
 
         unless client.auth.authentication_security_requirements_met?
-          connection.transition_state_machine :failed, Ably::Exceptions::InsecureRequestError.new('Cannot use Basic Auth over non-TLS connections', 401, 40103)
+          connection.transition_state_machine :failed, Ably::Exceptions::InsecureRequest.new('Cannot use Basic Auth over non-TLS connections', 401, 40103)
           return
         end
 
         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?
+        connection.create_websocket_transport.tap do |socket_deferrable|
+          socket_deferrable.callback do |websocket_transport|
+            subscribe_to_transport_events websocket_transport
+            yield websocket_transport if block_given?
+          end
+          socket_deferrable.errback do |error|
+            connection_opening_failed error
+          end
         end
 
         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)
+          connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{TIMEOUTS.fetch(:open)}s", nil, 80014)
         end
       end
 
@@ -161,10 +166,10 @@ module Ably::Realtime
         end
 
         unless connection_retry_from_suspended_state?
-          return if connection_retry_for(:disconnected, ignore_states: [:connecting])
+          return if connection_retry_for(:disconnected)
         end
 
-        return if connection_retry_for(:suspended, ignore_states: [:connecting])
+        return if connection_retry_for(:suspended)
 
         # Fallback if no other criteria met
         connection.transition_state_machine :failed, current_transition.metadata
@@ -264,10 +269,10 @@ module Ably::Realtime
       #
       # @return [Boolean] True if a connection attempt has been set up, false if no further connection attempts can be made for this state
       #
-      def connection_retry_for(from_state, options = {})
+      def connection_retry_for(from_state)
         retry_params = CONNECT_RETRY_CONFIG.fetch(from_state)
 
-        if time_spent_attempting_state(from_state, options) < retry_params.fetch(:max_time_in_state)
+        if can_reattempt_connect_for_state?(from_state)
           if retries_for_state(from_state, ignore_states: [:connecting]).empty?
             logger.debug "ConnectionManager: Will attempt reconnect immediately as no previous reconnect attempts made in this state"
             EventMachine.next_tick { connection.connect }
@@ -281,6 +286,14 @@ module Ably::Realtime
         end
       end
 
+      # True if the client library has not exceeded the configured max_time_in_state for the current State
+      # For example, if the state is disconnected, and has been in a cycle of disconnected > connect > disconnected
+      #  so long as the time in this cycle of states is less than max_time_in_state, this will return true
+      def can_reattempt_connect_for_state?(state)
+        retry_params = CONNECT_RETRY_CONFIG.fetch(state)
+        time_spent_attempting_state(state, ignore_states: [:connecting]) < retry_params.fetch(:max_time_in_state)
+      end
+
       # Returns a float representing the amount of time passed since the first consecutive attempt of this state
       #
       # @param (see #retries_for_state)
@@ -335,9 +348,13 @@ module Ably::Realtime
             connection.transition_state_machine :closed
           elsif !connection.closed? && !connection.disconnected?
             exception = if reason
-              Ably::Exceptions::ConnectionClosedError.new(reason)
+              Ably::Exceptions::ConnectionClosed.new(reason)
+            end
+            if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
+              connection.transition_state_machine :suspended, exception
+            else
+              connection.transition_state_machine :disconnected, exception
             end
-            connection.transition_state_machine :disconnected, exception
           end
         end
       end
@@ -350,35 +367,33 @@ module Ably::Realtime
           end
 
           @renewing_token = true
-          logger.warn "ConnectionManager: Token has expired and is renewable, renewing token now"
+          logger.info "ConnectionManager: Token has expired and is renewable, renewing token now"
 
-          operation = proc do
-            begin
-              client.auth.authorise
-            rescue StandardError => auth_error
-              connection.transition_state_machine :failed, auth_error
-              nil
-            end
-          end
+          client.auth.authorise.tap do |authorise_deferrable|
+            authorise_deferrable.callback do |token_details|
+              logger.info 'ConnectionManager: Token renewed succesfully following expiration'
 
-          callback = proc do |token|
-            state_changed_callback = proc do
-              @renewing_token = false
-              connection.off &state_changed_callback
-            end
+              state_changed_callback = proc do
+                @renewing_token = false
+                connection.off &state_changed_callback
+              end
 
-            connection.unsafe_once :connected, :closed, :failed, &state_changed_callback
+              connection.unsafe_once :connected, :closed, :failed, &state_changed_callback
 
-            if token && !token.expired?
-              connection.connect
-            else
-              connection.transition_state_machine :failed, error unless connection.failed?
+              if token_details && !token_details.expired?
+                connection.connect
+              else
+                connection.transition_state_machine :failed, error unless connection.failed?
+              end
             end
-          end
 
-          EventMachine.defer operation, callback
+            authorise_deferrable.errback do |auth_error|
+              logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
+              connection.transition_state_machine :failed, auth_error
+            end
+          end
         else
-          logger.error "ConnectionManager: Token has expired and is not renewable"
+          logger.error "ConnectionManager: Token has expired and is not renewable - #{error}"
           connection.transition_state_machine :failed, error
         end
       end

data/lib/ably/realtime/presence.rb

@@ -82,6 +82,7 @@ module Ably::Realtime
 
       return deferrable_succeed(deferrable, &success_block) if state == STATE.Entered
 
+      ensure_presence_publishable_on_connection
       ensure_channel_attached(deferrable) do
         if entering?
           once_or_if(STATE.Entered, else: proc { |args| deferrable_fail deferrable, *args }) do
@@ -145,6 +146,7 @@ module Ably::Realtime
 
       return deferrable_succeed(deferrable, &success_block) if state == STATE.Left
 
+      ensure_presence_publishable_on_connection
       ensure_channel_attached(deferrable) do
         if leaving?
           once_or_if(STATE.Left, else: proc { |error|deferrable_fail deferrable, *args }) do
@@ -201,6 +203,7 @@ module Ably::Realtime
 
       @data = data
 
+      ensure_presence_publishable_on_connection
       ensure_channel_attached(deferrable) do
         send_protocol_message_and_transition_state_to(
           Ably::Models::PresenceMessage::ACTION.Update,
@@ -369,6 +372,12 @@ module Ably::Realtime
       end
     end
 
+    def ensure_presence_publishable_on_connection
+      if !connection.can_publish_messages?
+        raise Ably::Exceptions::MessageQueueingDisabled.new("Message cannot be published. Client is configured to disallow queueing of messages and connection is currently #{connection.state}")
+      end
+    end
+
     def ensure_channel_attached(deferrable = nil)
       if channel.attached?
         yield
@@ -413,11 +422,12 @@ module Ably::Realtime
       safe_yield block, self, *args if block_given?
       EventMachine.next_tick { deferrable.fail self, *args } # allow errback to be added to the returned Deferrable
       deferrable
-      end
+    end
 
     def send_presence_action_for_client(action, client_id, options = {}, &success_block)
-      deferrable = create_deferrable
+      ensure_presence_publishable_on_connection
 
+      deferrable = create_deferrable
       ensure_channel_attached(deferrable) do
         send_presence_protocol_message(action, client_id, options).tap do |protocol_message|
           protocol_message.callback { |message| deferrable_succeed deferrable, &success_block }
@@ -428,7 +438,7 @@ module Ably::Realtime
 
     def attach_channel_then
       if channel.detached? || channel.failed?
-        raise Ably::Exceptions::IncompatibleStateForOperation.new("Operation is not allowed when channel is in #{channel.state}", 400, 91001)
+        raise Ably::Exceptions::InvalidStateChange.new("Operation is not allowed when channel is in #{channel.state}", 400, 91001)
       else
         channel.unsafe_once(Channel::STATE.Attached) { yield }
         channel.attach
@@ -439,6 +449,10 @@ module Ably::Realtime
       channel.client
     end
 
+    def connection
+      client.connection
+    end
+
     def rest_presence
       client.rest_client.channel(channel.name).presence
     end