ably-rest 0.8.6 → 0.8.9

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

@@ -60,8 +60,8 @@ module Ably::Realtime
       # Get the list of presence members
       #
       # @param [Hash,String] options an options Hash to filter members
-      # @option options [String] :client_id      optional client_id for the member
-      # @option options [String] :connection_id  optional connection_id for the member
+      # @option options [String] :client_id      optional client_id filter for the member
+      # @option options [String] :connection_id  optional connection_id filter for the member
       # @option options [String] :wait_for_sync  defaults to false, if true the get method waits for the initial presence sync following channel attachment to complete before returning the members present
       #
       # @yield [Array<Ably::Models::PresenceMessage>] array of present members
@@ -99,12 +99,12 @@ module Ably::Realtime
           end
 
           reset_callbacks = proc do
-            off &in_sync_callback
-            off &failed_callback
-            channel.off &failed_callback
+            off(&in_sync_callback)
+            off(&failed_callback)
+            channel.off(&failed_callback)
           end
 
-          once :in_sync, &in_sync_callback
+          once(:in_sync, &in_sync_callback)
 
           once(:failed, &failed_callback)
           channel.unsafe_once(:detaching, :detached, :failed) do |error_reason|
@@ -131,7 +131,21 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :members, :sync_serial, :presence, :absent_member_cleanup_queue
+      def members
+        @members
+      end
+
+      def sync_serial
+        @sync_serial
+      end
+
+      def presence
+        @presence
+      end
+
+      def absent_member_cleanup_queue
+        @absent_member_cleanup_queue
+      end
 
       def channel
         presence.channel
@@ -156,9 +170,9 @@ module Ably::Realtime
         end
 
         resume_sync_proc = method(:resume_sync).to_proc
-        connection.on_resume &resume_sync_proc
+        connection.on_resume(&resume_sync_proc)
         once(:in_sync, :failed) do
-          connection.off_resume &resume_sync_proc
+          connection.off_resume(&resume_sync_proc)
         end
 
         once(:in_sync) do

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

@@ -19,8 +19,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
@@ -65,15 +64,15 @@ module Ably
         end
 
         payload = messages.map do |message|
-          Ably::Models::Message(message.dup).tap do |message|
-            message.encode self
+          Ably::Models::Message(message.dup).tap do |msg|
+            msg.encode self
 
-            next if message.client_id.nil?
-            if message.client_id == '*'
+            next if msg.client_id.nil?
+            if msg.client_id == '*'
               raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages', 400, 40012)
             end
-            unless client.auth.can_assume_client_id?(message.client_id)
-              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
+            unless client.auth.can_assume_client_id?(msg.client_id)
+              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{msg.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
             end
           end.as_json
         end
@@ -111,8 +110,8 @@ module Ably
         response = client.get(url, options)
 
         Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |message|
-          message.tap do |message|
-            decode_message message
+          message.tap do |msg|
+            decode_message msg
           end
         end
       end

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

@@ -315,7 +315,7 @@ module Ably
       #
       # @api private
       def fallback_connection
-        unless @fallback_connections
+        unless defined?(@fallback_connections) && @fallback_connections
           @fallback_connections = Ably::FALLBACK_HOSTS.shuffle.map { |host| Faraday.new(endpoint_for_host(host).to_s, connection_options) }
         end
         @fallback_index ||= 0

data/lib/submodules/ably-ruby/lib/ably/rest/middleware/exceptions.rb

@@ -7,6 +7,8 @@ module Ably
       # HTTP exceptions raised by Ably due to an error status code
       # Ably returns JSON/Msgpack error codes and messages so include this if possible in the exception messages
       class Exceptions < Faraday::Response::Middleware
+        TOKEN_EXPIRED_CODE = 40140..40149
+
         def on_complete(env)
           if env.status >= 400
             error_status_code = env.status
@@ -28,12 +30,22 @@ module Ably
 
             message = 'Unknown server error' if message.to_s.strip == ''
 
+            exception_args = [message, error_status_code, error_code]
+
             if env.status >= 500
-              raise Ably::Exceptions::ServerError.new(message, error_status_code, error_code)
-            elsif env.status == 401 && error_code == 40140
-              raise Ably::Exceptions::TokenExpired.new(message, error_status_code, error_code)
+              raise Ably::Exceptions::ServerError.new(*exception_args)
+            elsif env.status == 401
+              if TOKEN_EXPIRED_CODE.include?(error_code)
+                raise Ably::Exceptions::TokenExpired.new(*exception_args)
+              else
+                raise Ably::Exceptions::UnauthorizedRequest.new(*exception_args)
+              end
+            elsif env.status == 403
+              raise Ably::Exceptions::ForbiddenRequest.new(*exception_args)
+            elsif env.status == 404
+              raise Ably::Exceptions::ResourceMissing.new(*exception_args)
             else
-              raise Ably::Exceptions::InvalidRequest.new(message, error_status_code, error_code)
+              raise Ably::Exceptions::InvalidRequest.new(*exception_args)
             end
           end
         end

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

@@ -23,7 +23,9 @@ module Ably
       # Obtain the set of members currently present for a channel
       #
       # @param [Hash] options the options for the set of members present
-      # @option options [Integer]      :limit      Maximum number of members to retrieve up to 1,000, defaults to 100
+      # @option options [Integer]   :limit           Maximum number of members to retrieve up to 1,000, defaults to 100
+      # @option options [String]    :client_id       optional client_id filter for the member
+      # @option options [String]    :connection_id   optional connection_id filter for the member
       #
       # @return [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResult page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResult#items #items}.
       #
@@ -40,8 +42,8 @@ module Ably
         response = client.get(base_path, options)
 
         Ably::Models::PaginatedResult.new(response, base_path, client, paginated_options) do |presence_message|
-          presence_message.tap do |presence_message|
-            decode_message presence_message
+          presence_message.tap do |message|
+            decode_message message
           end
         end
       end
@@ -74,8 +76,8 @@ module Ably
         response = client.get(url, options)
 
         Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |presence_message|
-          presence_message.tap do |presence_message|
-            decode_message presence_message
+          presence_message.tap do |message|
+            decode_message message
           end
         end
       end

data/lib/submodules/ably-ruby/lib/ably/util/crypto.rb

@@ -4,52 +4,65 @@ require 'openssl'
 module Ably::Util
   class Crypto
     DEFAULTS = {
-      algorithm: 'AES',
-      mode: 'CBC',
-      key_length: 128,
+      algorithm: 'aes',
+      mode: 'cbc',
+      key_length: 256,
     }
 
     BLOCK_LENGTH = 16
 
-    # Configured options for this Crypto object, see {#initialize} for a list of configured options
+    # Configured {Ably::Models::CipherParams} for this Crypto object, see {#initialize} for a list of configureable options
     #
-    # @return [Hash]
-    attr_reader :options
+    # @return [Ably::Models::CipherParams]
+    attr_reader :cipher_params
 
     # Creates a {Ably::Util::Crypto} object
     #
-    # @param [Hash] options an options Hash used to configure the Crypto library
-    # @option options [String]  :key                 Required secret key used for encrypting and decrypting
-    # @option options [String]  :algorithm           optional (default AES), specify the encryption algorithm supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
-    # @option options [String]  :mode                optional (default CBC), specify the cipher mode supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
-    # @option options [Integer] :key_length          optional (default 128), specify the key length of the cipher supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
-    # @option options [String]  :combined            optional (default AES-128-CBC), specify in one option the algorithm, key length and cipher of the cipher supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
+    # @param [Hash] params a Hash used to configure the Crypto library's {Ably::Models::CipherParams}
+    # @option params (see Ably::Models::CipherParams#initialize)
     #
     # @return [Ably::Util::Crypto]
     #
     # @example
-    #    crypto = Ably::Util::Crypto.new(key: 'mysecret')
+    #    key = Ably::Util::Crypto.generate_random_key
+    #    crypto = Ably::Util::Crypto.new(key: key)
     #    encrypted = crypto.encrypt('secret text')
     #    crypto.decrypt(decrypted) # => 'secret text'
     #
-    def initialize(options)
-      raise ArgumentError, ':key is required' unless options.has_key?(:key)
-      @options = DEFAULTS.merge(options).freeze
+    def initialize(params)
+      @fixed_iv = params.delete(:fixed_iv) if params.kind_of?(Hash)
+      @cipher_params = Ably::Models::CipherParams(params)
     end
 
-    # Obtain a default CipherParams. This uses default algorithm, mode and
-    # padding and key length. A key and IV are generated using the default
-    # system SecureRandom; the key may be obtained from the returned CipherParams
+    # Obtain a default {Ably::Models::CipherParams}. This uses default algorithm, mode and
+    # padding and key length. An IV is generated using the default
+    # system SecureRandom; the key may be obtained from the returned {Ably::Models::CipherParams}
     # for out-of-band distribution to other clients.
+
+    # @param [Hash]  params  a Hash used to configure the Crypto library's {Ably::Models::CipherParams}
+    # @option params  (see Ably::Models::CipherParams#initialize)
+    #
+    # @return [Ably::Models::CipherParams]   Configured cipher params with :key, :algorithm, :mode, :key_length attributes
+    #
+    def self.get_default_params(params = {})
+      Ably::Models::CipherParams(params)
+    end
+
+    # Generate a random encryption key from the supplied keylength (or the
+    # default key_length of 256 if none supplied)
     #
-    # @return [Hash]   CipherParam options Hash with attributes :key, :algorithn, :mode, :key_length
+    # @param  [Integer]  key_length  Optional (default 256) key length for the generated random key. 128 and 256 bit key lengths are supported
+    # @return   Binary   String (byte array) with ASCII_8BIT encoding
     #
-    def self.get_default_params(key = nil)
-      params = DEFAULTS.merge(key: key)
-      params[:key_length] = key.unpack('b*').first.length if params[:key]
-      cipher_type = "#{params[:algorithm]}-#{params[:key_length]}-#{params[:mode]}"
-      params[:key] = OpenSSL::Cipher.new(cipher_type.upcase).random_key unless params[:key]
-      params
+    def self.generate_random_key(key_length = DEFAULTS.fetch(:key_length))
+      params = DEFAULTS.merge(key_length: key_length)
+      OpenSSL::Cipher.new(cipher_type(params)).random_key
+    end
+
+    # The Cipher algorithm string such as AES-128-CBC
+    # @api private
+    def self.cipher_type(options)
+      Ably::Models::CipherParams.cipher_type(options)
     end
 
     # Encrypt payload using configured Cipher
@@ -58,13 +71,13 @@ module Ably::Util
     # @param [Hash]   encrypt_options   an options Hash to configure the encrypt action
     # @option encrypt_options [String]  :iv optionally use the provided Initialization Vector instead of a randomly generated IV
     #
-    # @return [String] binary string with {Encoding::ASCII_8BIT} encoding
+    # @return [String] binary string with +Encoding::ASCII_8BIT+ encoding
     #
     def encrypt(payload, encrypt_options = {})
       cipher = openssl_cipher
       cipher.encrypt
       cipher.key = key
-      iv = encrypt_options[:iv] || options[:iv] || cipher.random_iv
+      iv = encrypt_options[:iv] || fixed_iv || cipher.random_iv
       cipher.iv = iv
 
       iv << cipher.update(payload) << cipher.final
@@ -90,31 +103,28 @@ module Ably::Util
       decipher.update(encrypted_payload) << decipher.final
     end
 
-    # Generate a random key
-    # @return [String]
-    def random_key
-      openssl_cipher.random_key
-    end
-
     # Generate a random IV
     # @return [String]
     def random_iv
       openssl_cipher.random_iv
     end
 
-    # The Cipher algorithm string such as AES-128-CBC
+    private
+    # Used solely for tests to fix the IV instead of randomly generate one
+    attr_reader :fixed_iv
+
+    # Generate a random key
     # @return [String]
-    def cipher_type
-      (options[:combined] || "#{options[:algorithm]}-#{options[:key_length]}-#{options[:mode]}").to_s.upcase
+    def random_key
+      openssl_cipher.random_key
     end
 
-    private
     def key
-      options[:key]
+      cipher_params.key
     end
 
     def openssl_cipher
-      OpenSSL::Cipher.new(cipher_type)
+      @openssl_cipher ||= OpenSSL::Cipher.new(cipher_params.cipher_type)
     end
   end
 end

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

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.6'
+  VERSION = '0.8.9'
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_history_spec.rb

@@ -19,7 +19,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
     let(:options)      { { :protocol => :json } }
 
     it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
-      channel.publish('event', payload) do |message|
+      channel.publish('event', payload) do
         history = channel.history
         expect(history).to be_a(Ably::Util::SafeDeferrable)
         history.callback do |page|
@@ -32,7 +32,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
     context 'with a single client publishing and receiving' do
       it 'retrieves realtime history' do
-        channel.publish('event', payload) do |message|
+        channel.publish('event', payload) do
           channel.history do |page|
             expect(page.items.length).to eql(1)
             expect(page.items[0].data).to eql(payload)
@@ -44,8 +44,8 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
     context 'with two clients publishing messages on the same channel' do
       it 'retrieves realtime history on both channels' do
-        channel.publish('event', payload) do |message|
-          channel2.publish('event', payload) do |message|
+        channel.publish('event', payload) do
+          channel2.publish('event', payload) do
             channel.history do |page|
               expect(page.items.length).to eql(2)
               expect(page.items.map(&:data).uniq).to eql([payload])

data/lib/submodules/ably-ruby/spec/acceptance/realtime/connection_failures_spec.rb

@@ -481,8 +481,6 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         it 'retains channel subscription state' do
-          messages_received = false
-
           channel.subscribe('event') do |message|
             expect(message.data).to eql('message')
             stop_reactor
@@ -712,6 +710,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         context 'when the Internet is up' do
           before do
             allow(connection).to receive(:internet_up?).and_yield(true)
+            @suspended = 0
           end
 
           it 'uses a fallback host on every subsequent disconnected attempt until suspended' do
@@ -740,14 +739,13 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 expect(host).to eql(expected_host)
               else
                 expect(custom_hosts).to include(host)
-                fallback_hosts_used << host if @suspended
+                fallback_hosts_used << host if @suspended > 0
               end
               request += 1
               raise EventMachine::ConnectionError
             end
 
             connection.on(:suspended) do
-              @suspended ||= 0
               @suspended += 1
 
               if @suspended > 3

data/lib/submodules/ably-ruby/spec/acceptance/realtime/connection_spec.rb

@@ -141,7 +141,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   started_at = Time.now.to_f
                   connection.once(:disconnected) do
                     connection.once(:disconnected) do |connection_state_change|
-                      expect(connection_state_change.reason.code).to eql(40140) # token expired
+                      expect(connection_state_change.reason.code).to eql(40142) # token expired
                       expect(Time.now.to_f - started_at).to be < 1000
                       expect(auth_requests.count).to eql(2)
                       stop_reactor
@@ -156,7 +156,7 @@ describe Ably::Realtime::Connection, :event_machine do
                     started_at = Time.now.to_f
                     disconnect_count = 0
                     connection.on(:disconnected) do |connection_state_change|
-                      expect(connection_state_change.reason.code).to eql(40140) # token expired
+                      expect(connection_state_change.reason.code).to eql(40142) # token expired
                       disconnect_count += 1
                       if disconnect_count == 6
                         expect(Time.now.to_f - started_at).to be > 4 * 0.5 # at least 4 0.5 second pauses should have happened
@@ -207,7 +207,7 @@ describe Ably::Realtime::Connection, :event_machine do
                       expect(original_token).to_not be_expired
                       started_at = Time.now
                       connection.once(:disconnected) do |connection_state_change|
-                        expect(connection_state_change.reason.code).to eq(40140) # Token expired
+                        expect(connection_state_change.reason.code).to eq(40142) # Token expired
 
                         # Token has expired, so now ensure it is not used again
                         stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', original_token_expiry_buffer
@@ -333,7 +333,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(expired_token_details).to be_expired
                   connection.once(:connected) { raise 'Connection should never connect as token has expired' }
                   connection.once(:failed) do
-                    expect(client.connection.error_reason.code).to eql(40140)
+                    expect(client.connection.error_reason.code).to eql(40142)
                     stop_reactor
                   end
                 end
@@ -800,6 +800,41 @@ describe Ably::Realtime::Connection, :event_machine do
       end
     end
 
+    context '#details' do
+      let(:connection) { client.connection }
+
+      it 'is nil before connected' do
+        connection.on(:connecting) do
+          expect(connection.details).to eql(nil)
+          stop_reactor
+        end
+      end
+
+      it 'contains the ConnectionDetails object once connected' do
+        connection.on(:connected) do
+          expect(connection.details).to be_a(Ably::Models::ConnectionDetails)
+          expect(connection.details.connection_key).to_not be_nil
+          expect(connection.details.server_id).to_not be_nil
+          stop_reactor
+        end
+      end
+
+      it 'contains the new ConnectionDetails object once a subsequent connection is created' do
+        connection.once(:connected) do
+          expect(connection.details.connection_key).to_not be_nil
+          old_key = connection.details.connection_key
+          connection.close do
+            connection.once(:connected) do
+              expect(connection.details.connection_key).to_not be_nil
+              expect(connection.details.connection_key).to_not eql(old_key)
+              stop_reactor
+            end
+            connection.connect
+          end
+        end
+      end
+    end
+
     context 'recovery' do
       let(:channel_name) { random_str }
       let(:channel) { client.channel(channel_name) }
@@ -813,7 +848,8 @@ describe Ably::Realtime::Connection, :event_machine do
           log_level:                  :none,
           disconnected_retry_timeout: 0.1,
           suspended_retry_timeout:    0.1,
-          connection_state_ttl:       0.2
+          connection_state_ttl:       0.2,
+          realtime_request_timeout:   5
         )
       end
 
@@ -889,7 +925,8 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context "opening a new connection using a recently disconnected connection's #recovery_key" do
         context 'connection#id and connection#key after recovery' do
-          it 'remains the same' do
+          it 'remains the same for id and party for key' do
+            connection_key_consistent_part_regex = /.*?!(\w{5,})-/
             previous_connection_id  = nil
             previous_connection_key = nil
 
@@ -902,8 +939,9 @@ describe Ably::Realtime::Connection, :event_machine do
             connection.once(:failed) do
               recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on(:connected) do
-                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to_not be_nil
-                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to eql(previous_connection_key[/^\w{5,}-/, 0])
+                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to_not be_nil
+                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to eql(
+                  previous_connection_key[connection_key_consistent_part_regex, 1])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end