ably-rest 0.8.6 → 0.8.9

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

@@ -1,5 +1,6 @@
 require 'eventmachine'
 require 'websocket/driver'
+require 'em-http-request'
 
 require 'ably/modules/event_emitter'
 

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

@@ -189,9 +189,13 @@ module Ably
       private
       # The synchronous Auth class instanced by the Rest client
       # @return [Ably::Auth]
-      attr_reader :auth_sync
+      def auth_sync
+        @auth_sync
+      end
 
-      attr_reader :client
+      def client
+        @client
+      end
     end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/realtime/channel.rb

@@ -82,8 +82,7 @@ module Ably
       # @param  client [Ably::Rest::Client]
       # @param  name [String] The name of the channel
       # @param  channel_options [Hash]     Channel options, currently reserved for Encryption options
-      # @option channel_options [Boolean]  :encrypted       setting this to true for this channel will encrypt & decrypt all messages automatically
-      # @option channel_options [Hash]     :cipher_params   A hash of options to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of +cipher_params+ options
+      # @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
@@ -294,7 +293,9 @@ module Ably
       private :change_state
 
       private
-      attr_reader :queue
+      def queue
+        @queue
+      end
 
       def setup_event_handlers
         __incoming_msgbus__.subscribe(:message) do |message|
@@ -323,7 +324,7 @@ module Ably
           end
         end
 
-        queue.push *messages
+        queue.push(*messages)
 
         if attached?
           process_queue
@@ -385,8 +386,8 @@ module Ably
       end
 
       def create_message(message)
-        Ably::Models::Message(message.dup).tap do |message|
-          message.encode self
+        Ably::Models::Message(message.dup).tap do |msg|
+          msg.encode self
         end
       end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/channel/channel_manager.rb

@@ -94,8 +94,14 @@ module Ably::Realtime
       end
 
       private
+      def channel
+        @channel
+      end
+
+      def connection
+        @connection
+      end
 
-      attr_reader :channel, :connection
       def_delegators :channel, :can_transition_to?
 
       # If the connection has not previously connected, connect now

data/lib/submodules/ably-ruby/lib/ably/realtime/client.rb

@@ -90,13 +90,13 @@ module Ably
         @auth                  = Ably::Realtime::Auth.new(self)
         @channels              = Ably::Realtime::Channels.new(self)
         @connection            = Ably::Realtime::Connection.new(self, options)
-        @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]
+        @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]
 
-        raise ArgumentError, "Recovery key is invalid" if @recover && !@recover.match(Connection::RECOVER_REGEX)
+        raise ArgumentError, "Recovery key '#{recover}' is invalid" if recover && !recover.match(Connection::RECOVER_REGEX)
       end
 
       # Return a {Ably::Realtime::Channel Realtime Channel} for the given name
@@ -150,11 +150,6 @@ module Ably
         endpoint_for_host(custom_realtime_host || [environment, DOMAIN].compact.join('-'))
       end
 
-
-      def connection
-        @connection
-      end
-
       # (see Ably::Rest::Client#register_encoder)
       def register_encoder(encoder)
         rest_client.register_encoder encoder
@@ -176,7 +171,7 @@ module Ably
       # @return [URI::Generic] Fallback endpoint used to connect to the realtime Ably service. Note, after each connection attempt, a new random {Ably::FALLBACK_HOSTS fallback host} is used
       # @api private
       def fallback_endpoint
-        unless @fallback_endpoints
+        unless defined?(@fallback_endpoints) && @fallback_endpoints
           @fallback_endpoints = Ably::FALLBACK_HOSTS.shuffle.map { |fallback_host| endpoint_for_host(fallback_host) }
         end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -13,7 +13,13 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :client, :connection
+      def client
+        @client
+      end
+
+      def connection
+        @connection
+      end
 
       def channels
         client.channels
@@ -144,6 +150,7 @@ module Ably::Realtime
       def process_connected_message(protocol_message)
         if client.auth.token_client_id_allowed?(protocol_message.connection_details.client_id)
           client.auth.configure_client_id protocol_message.connection_details.client_id
+          client.connection.set_connection_details protocol_message.connection_details
           connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
         else
           reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' specified by the server is incompatible with the library's configured client ID '#{client.client_id}'", 400, 40012)
@@ -195,7 +202,7 @@ module Ably::Realtime
 
       def subscribe_to_incoming_protocol_messages
         connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |*args|
-          dispatch_protocol_message *args
+          dispatch_protocol_message(*args)
         end
       end
     end

data/lib/submodules/ably-ruby/lib/ably/realtime/client/outgoing_message_dispatcher.rb

@@ -17,7 +17,13 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :client, :connection
+      def client
+        @client
+      end
+
+      def connection
+        @connection
+      end
 
       def can_send_messages?
         connection.connected? || connection.closing?

data/lib/submodules/ably-ruby/lib/ably/realtime/connection.rb

@@ -58,7 +58,7 @@ module Ably
       ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
 
       # Expected format for a connection recover key
-      RECOVER_REGEX = /^(?<recover>[\w-]+):(?<connection_serial>\-?\w+)$/
+      RECOVER_REGEX = /^(?<recover>[\w!-]+):(?<connection_serial>\-?\w+)$/
 
       # Defaults for automatic connection recovery and timeouts
       DEFAULTS = {
@@ -84,6 +84,10 @@ module Ably
       # @return [Ably::Models::ErrorInfo,Ably::Exceptions::BaseAblyException]
       attr_reader :error_reason
 
+      # Connection details of the currently established connection
+      # @return [Ably::Models::ConnectionDetails]
+      attr_reader :details
+
       # {Ably::Realtime::Client} associated with this connection
       # @return [Ably::Realtime::Client]
       attr_reader :client
@@ -178,12 +182,12 @@ module Ably
 
           once(:connected) do
             deferrable.succeed
-            off &fail_callback
+            off(&fail_callback)
           end
 
           once(:failed, :closed, :closing) do
             deferrable.fail
-            off &succeed_callback
+            off(&succeed_callback)
           end
         end
       end
@@ -356,10 +360,10 @@ module Ably
       # @api private
       def send_protocol_message(protocol_message)
         add_message_serial_if_ack_required_to(protocol_message) do
-          Ably::Models::ProtocolMessage.new(protocol_message, logger: logger).tap do |protocol_message|
-            add_message_to_outgoing_queue protocol_message
-            notify_message_dispatcher_of_new_message protocol_message
-            logger.debug("Connection: Prot msg queued =>: #{protocol_message.action} #{protocol_message}")
+          Ably::Models::ProtocolMessage.new(protocol_message, logger: logger).tap do |message|
+            add_message_to_outgoing_queue message
+            notify_message_dispatcher_of_new_message message
+            logger.debug("Connection: Prot msg queued =>: #{message.action} #{message}")
           end
         end
       end
@@ -437,6 +441,11 @@ module Ably
         @error_reason = nil
       end
 
+      # @api private
+      def set_connection_details(connection_details)
+        @details = connection_details
+      end
+
       # Executes registered callbacks for a successful connection resume event
       # @api private
       def resumed
@@ -476,7 +485,9 @@ module Ably
       # A connection serial guarantees the server has received the message and is thus used for connection
       # recovery and resumes.
       # @return [Integer] starting at -1 indicating no messages sent, 0 when the first message is sent
-      attr_reader :client_serial
+      def client_serial
+        @client_serial
+      end
 
       def resume_callbacks
         @resume_callbacks ||= []

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/connection_manager.rb

@@ -1,3 +1,5 @@
+require 'ably/rest/middleware/exceptions'
+
 module Ably::Realtime
   class Connection
     # ConnectionManager is responsible for all actions relating to underlying connection and transports,
@@ -10,12 +12,13 @@ module Ably::Realtime
     class ConnectionManager
       # Error codes from the server that can potentially be resolved
       RESOLVABLE_ERROR_CODES = {
-        token_expired: 40140
+        token_expired: Ably::Rest::Middleware::Exceptions::TOKEN_EXPIRED_CODE
       }
 
       def initialize(connection)
-        @connection = connection
-        @timers     = Hash.new { |hash, key| hash[key] = [] }
+        @connection     = connection
+        @timers         = Hash.new { |hash, key| hash[key] = [] }
+        @renewing_token = false
 
         connection.unsafe_on(:closed) do
           connection.reset_resume_info
@@ -58,7 +61,7 @@ module Ably::Realtime
         end
 
         logger.debug "ConnectionManager: Setting up automatic connection timeout timer for #{realtime_request_timeout}s"
-        create_timeout_timer_whilst_in_state(:connect, realtime_request_timeout) do
+        create_timeout_timer_whilst_in_state(:connecting, realtime_request_timeout) do
           connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{realtime_request_timeout}s", nil, 80014)
         end
       end
@@ -123,7 +126,7 @@ module Ably::Realtime
       def close_connection
         connection.send_protocol_message(action: Ably::Models::ProtocolMessage::ACTION.Close)
 
-        create_timeout_timer_whilst_in_state(:close, realtime_request_timeout) do
+        create_timeout_timer_whilst_in_state(:closing, realtime_request_timeout) do
           force_close_connection if connection.closing?
         end
       end
@@ -153,7 +156,7 @@ module Ably::Realtime
         return unless can_retry_connection? # do not always reattempt connection or change state as client may be re-authorising
 
         if error.kind_of?(Ably::Models::ErrorInfo)
-          if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
+          if RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)
             next_state = get_next_retry_state_info
             logger.debug "ConnectionManager: Transport disconnected because of token expiry, pausing #{next_state.fetch(:pause)}s before reattempting to connect"
             EventMachine.add_timer(next_state.fetch(:pause)) { renew_token_and_reconnect error }
@@ -181,7 +184,7 @@ module Ably::Realtime
           logger.debug "ConnectionManager: Transport disconnected whilst connection in #{connection.state} state"
         end
 
-        if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
+        if error.kind_of?(Ably::Models::ErrorInfo) && !RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)
           connection.emit :error, error
           logger.error "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}"
         end
@@ -213,11 +216,15 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :connection
+      def connection
+        @connection
+      end
 
       # Timers used to manage connection state, for internal use by the client library
       # @return [Hash]
-      attr_reader :timers
+      def timers
+        @timers
+      end
 
       def transport
         connection.transport

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/websocket_transport.rb

@@ -98,11 +98,20 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :connection, :driver, :reason_closed
+      def driver
+        @driver
+      end
+
+      def connection
+        @connection
+      end
+
+      def reason_closed
+        @reason_closed
+      end
 
       # Send object down the WebSocket driver connection as a serialized string/byte array based on protocol
       # @param [Object] object to serialize and send to the WebSocket driver
-      # @api public
       def send_object(object)
         case client.protocol
         when :json
@@ -122,7 +131,7 @@ module Ably::Realtime
       end
 
       def clear_timer
-        if @timer
+        if defined?(@timer) && @timer
           @timer.cancel
           @timer = nil
         end

data/lib/submodules/ably-ruby/lib/ably/realtime/presence.rb

@@ -59,26 +59,16 @@ module Ably::Realtime
     # Enter this client into this channel. This client will be added to the presence set
     # and presence subscribers will see an enter message for this client.
     #
-    # @param [Hash] options an options Hash to specify client data and/or client ID
-    # @option options [String] :data      optional data (eg a status message) for this member
-    # @option options [String] :client_id the optional id of the client.
-    #                                     This option is provided to support connections from server instances that act on behalf of
-    #                                     multiple client_ids. In order to be able to enter the channel with this method, the client
-    #                                     library must have been instanced either with a key, or with a token bound to the wildcard clientId.
+    # @param [String,Hash,nil]   data   optional data (eg a status message) for this member
     #
     # @yield [Ably::Realtime::Presence] On success, will call the block with this {Ably::Realtime::Presence} object
     # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
     #
-    def enter(options = {}, &success_block)
-      client_id  = options.fetch(:client_id, self.client_id)
-      data       = options.fetch(:data, nil)
+    def enter(data = nil, &success_block)
       deferrable = create_deferrable
 
-      ensure_supported_client_id client_id
-      ensure_supported_payload data unless data.nil?
-
+      ensure_supported_payload data
       @data = data
-      @client_id = client_id
 
       return deferrable_succeed(deferrable, &success_block) if state == STATE.Entered
 
@@ -94,8 +84,8 @@ module Ably::Realtime
             Ably::Models::PresenceMessage::ACTION.Enter,
             deferrable:   deferrable,
             target_state: STATE.Entered,
-            client_id:    client_id,
             data:         data,
+            client_id:    client_id,
             failed_state: STATE.Failed,
             &success_block
           )
@@ -111,36 +101,30 @@ module Ably::Realtime
     # either with a key, or with a token bound to the wildcard client_id
     #
     # @param [String]  client_id   id of the client
-    #
-    # @param [Hash]    options         an options Hash for this client event
-    # @option options [String] :data   optional data (eg a status message) for this member
+    # @param [String,Hash,nil]   data   optional data (eg a status message) for this member
     #
     # @yield [Ably::Realtime::Presence] On success, will call the block with this {Ably::Realtime::Presence} object
     # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
     #
-    def enter_client(client_id, options = {}, &success_block)
-      raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+    def enter_client(client_id, data = nil, &success_block)
       ensure_supported_client_id client_id
-      ensure_supported_payload options[:data] if options.has_key?(:data)
+      ensure_supported_payload data
 
-      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Enter, client_id, options, &success_block)
+      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Enter, client_id, data, &success_block)
     end
 
     # Leave this client from this channel. This client will be removed from the presence
     # set and presence subscribers will see a leave message for this client.
     #
-    # @param [Hash,String] options an options Hash to specify client data and/or client ID
-    # @option options [String] :data      optional data (eg a status message) for this member
+    # @param (see Presence#enter)
     #
     # @yield (see Presence#enter)
     # @return (see Presence#enter)
     #
-    def leave(options = {}, &success_block)
-      data       = options.fetch(:data, self.data) # nil value defaults leave data to existing value
+    def leave(data = nil, &success_block)
       deferrable = create_deferrable
 
-      ensure_supported_client_id client_id
-      ensure_supported_payload data unless data.nil?
+      ensure_supported_payload data
       raise Ably::Exceptions::Standard.new('Unable to leave presence channel that is not entered', 400, 91002) unless able_to_leave?
 
       @data = data
@@ -159,8 +143,8 @@ module Ably::Realtime
             Ably::Models::PresenceMessage::ACTION.Leave,
             deferrable:   deferrable,
             target_state: STATE.Left,
-            client_id:    client_id,
             data:         data,
+            client_id:    client_id,
             failed_state: STATE.Failed,
             &success_block
           )
@@ -172,35 +156,30 @@ module Ably::Realtime
     # presence set and presence subscribers will see a leave message for this client.
     #
     # @param (see Presence#enter_client)
-    # @option options (see Presence#enter_client)
     #
     # @yield (see Presence#enter_client)
     # @return (see Presence#enter_client)
     #
-    def leave_client(client_id, options = {}, &success_block)
-      raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+    def leave_client(client_id, data = nil, &success_block)
       ensure_supported_client_id client_id
-      ensure_supported_payload options[:data] if options.has_key?(:data)
+      ensure_supported_payload data
 
-      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Leave, client_id, options, &success_block)
+      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Leave, client_id, data, &success_block)
     end
 
     # Update the presence data for this client. If the client is not already a member of
     # the presence set it will be added, and presence subscribers will see an enter or
     # update message for this client.
     #
-    # @param [Hash,String] options an options Hash to specify client data
-    # @option options [String] :data      optional data (eg a status message) for this member
+    # @param (see Presence#enter)
     #
     # @yield (see Presence#enter)
     # @return (see Presence#enter)
     #
-    def update(options = {}, &success_block)
-      data       = options.fetch(:data, nil)
+    def update(data = nil, &success_block)
       deferrable = create_deferrable
 
-      ensure_supported_client_id client_id
-      ensure_supported_payload data unless data.nil?
+      ensure_supported_payload data
 
       @data = data
 
@@ -224,17 +203,15 @@ module Ably::Realtime
     # enables it to represent an arbitrary clientId.
     #
     # @param (see Presence#enter_client)
-    # @option options (see Presence#enter_client)
     #
     # @yield (see Presence#enter_client)
     # @return (see Presence#enter_client)
     #
-    def update_client(client_id, options = {}, &success_block)
-      raise ArgumentError, 'options must be a Hash' unless options.kind_of?(Hash)
+    def update_client(client_id, data = nil, &success_block)
       ensure_supported_client_id client_id
-      ensure_supported_payload options[:data] if options.has_key?(:data)
+      ensure_supported_payload data
 
-      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Update, client_id, options, &success_block)
+      send_presence_action_for_client(Ably::Models::PresenceMessage::ACTION.Update, client_id, data, &success_block)
     end
 
     # Get the presence state for this Channel.
@@ -250,11 +227,11 @@ module Ably::Realtime
       ensure_channel_attached(deferrable) do
         members.get(options).tap do |members_map_deferrable|
           members_map_deferrable.callback do |*args|
-            safe_yield block, *args if block_given?
-            deferrable.succeed *args
+            safe_yield(block, *args) if block_given?
+            deferrable.succeed(*args)
           end
           members_map_deferrable.errback do |*args|
-            deferrable.fail *args
+            deferrable.fail(*args)
           end
         end
       end
@@ -344,8 +321,8 @@ module Ably::Realtime
     end
 
     # @return [Ably::Models::PresenceMessage] presence message is returned allowing callbacks to be added
-    def send_presence_protocol_message(presence_action, client_id, options = {})
-      presence_message = create_presence_message(presence_action, client_id, options)
+    def send_presence_protocol_message(presence_action, client_id, data)
+      presence_message = create_presence_message(presence_action, client_id, data)
       unless presence_message.client_id
         raise Ably::Exceptions::Standard.new('Unable to enter create presence message without a client_id', 400, 91000)
       end
@@ -361,12 +338,12 @@ module Ably::Realtime
       presence_message
     end
 
-    def create_presence_message(action, client_id, options = {})
+    def create_presence_message(action, client_id, data)
       model = {
         action:   Ably::Models::PresenceMessage.ACTION(action).to_i,
-        clientId: client_id
+        clientId: client_id,
+        data:     data
       }
-      model.merge!(data: options.fetch(:data)) if options.has_key?(:data)
 
       Ably::Models::PresenceMessage.new(model, logger: logger).tap do |presence_message|
         presence_message.encode self.channel
@@ -406,13 +383,7 @@ module Ably::Realtime
       target_state = options.fetch(:target_state, nil)
       failed_state = options.fetch(:failed_state, nil)
 
-      protocol_message_options = if options.has_key?(:data)
-        { data: options.fetch(:data) }
-      else
-        { }
-      end
-
-      send_presence_protocol_message(action, client_id, protocol_message_options).tap do |protocol_message|
+      send_presence_protocol_message(action, client_id, options[:data]).tap do |protocol_message|
         protocol_message.callback do |message|
           change_state target_state, message if target_state
           deferrable_succeed deferrable, &success_block
@@ -426,23 +397,23 @@ module Ably::Realtime
     end
 
     def deferrable_succeed(deferrable, *args, &block)
-      safe_yield block, self, *args if block_given?
+      safe_yield(block, 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)
-      safe_yield block, *args if block_given?
-      EventMachine.next_tick { deferrable.fail *args } # allow errback to be added to the returned Deferrable
+      safe_yield(block, *args) if block_given?
+      EventMachine.next_tick { deferrable.fail(*args) } # allow errback to be added to the returned Deferrable
       deferrable
     end
 
-    def send_presence_action_for_client(action, client_id, options = {}, &success_block)
+    def send_presence_action_for_client(action, client_id, data, &success_block)
       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|
+        send_presence_protocol_message(action, client_id, data).tap do |protocol_message|
           protocol_message.callback { |message| deferrable_succeed deferrable, &success_block }
           protocol_message.errback  { |error| deferrable_fail deferrable, error }
         end