ably-rest 0.8.6 → 0.8.9

data/lib/submodules/ably-ruby/ably.gemspec

@@ -8,10 +8,10 @@ Gem::Specification.new do |spec|
   spec.version       = Ably::VERSION
   spec.authors       = ['Lewis Marshall', "Matthew O'Riordan"]
   spec.email         = ['lewis@lmars.net', 'matt@ably.io']
-  spec.description   = %q{A Ruby client library for ably.io, the realtime messaging service}
-  spec.summary       = %q{A Ruby client library for ably.io, the realtime messaging service}
+  spec.description   = %q{A Ruby client library for ably.io realtime messaging}
+  spec.summary       = %q{A Ruby client library for ably.io realtime messaging implemented using EventMachine}
   spec.homepage      = 'http://github.com/ably/ably-ruby'
-  spec.license       = 'MIT'
+  spec.license       = 'Apache 2'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'statesman', '~> 1.0.0'
   spec.add_runtime_dependency 'faraday', '~> 0.9'
   spec.add_runtime_dependency 'json'
-  spec.add_runtime_dependency 'websocket-driver', '~> 0.3'
+  spec.add_runtime_dependency 'websocket-driver', '~> 0.6'
   spec.add_runtime_dependency 'msgpack', '>= 0.6.2'
   spec.add_runtime_dependency 'addressable', '>= 2.0.0'
 

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

@@ -54,6 +54,10 @@ module Ably
         raise ArgumentError, 'Expected token_params to be a Hash'
       end
 
+      # Ensure instance variables are defined
+      @client_id = nil
+      @client_id_validated = nil
+
       ensure_valid_auth_attributes auth_options
 
       @client              = client
@@ -401,8 +405,13 @@ module Ably
     end
 
     private
-    attr_reader :client
-    attr_reader :token_option
+    def client
+      @client
+    end
+
+    def token_option
+      @token_option
+    end
 
     def ensure_valid_auth_attributes(attributes)
       if attributes[:timestamp]
@@ -453,7 +462,7 @@ module Ably
     end
 
     def split_api_key_into_key_and_secret!(options)
-      api_key_parts = options[:key].to_s.match(/(?<name>[\w_-]+\.[\w_-]+):(?<secret>[\w_-]+)/)
+      api_key_parts = options[:key].to_s.match(/(?<name>[\w-]+\.[\w-]+):(?<secret>[\w-]+)/)
       raise ArgumentError, 'key is invalid' unless api_key_parts
 
       options[:key_name]   = api_key_parts[:name].encode(Encoding::UTF_8)
@@ -576,7 +585,7 @@ module Ably
       token_request = Ably::Models::TokenRequest(token_request)
 
       response = client.post("/keys/#{token_request.key_name}/requestToken",
-                             token_request.hash, send_auth_header: false,
+                             token_request.attributes, send_auth_header: false,
                              disable_automatic_reauthorise: true)
 
       Ably::Models::TokenDetails.new(response.body)

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

@@ -32,6 +32,15 @@ module Ably
     # An invalid request was received by Ably
     class InvalidRequest < BaseAblyException; end
 
+    # Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet been provided
+    class UnauthorizedRequest < BaseAblyException; end
+
+    # The request was a valid request, but Ably is refusing to respond to it
+    class ForbiddenRequest < BaseAblyException; end
+
+    # The requested resource could not be found but may be available again in the future
+    class ResourceMissing < BaseAblyException; end
+
     # Ably Protocol message received that is invalid
     class ProtocolError < BaseAblyException; end
 
@@ -92,7 +101,7 @@ module Ably
     # The token request could not be created
     class TokenRequestFailed < BaseAblyException; end
 
-    # The token has expired
+    # The token has expired, 40140..40149
     class TokenExpired < BaseAblyException; end
 
     # The message could not be delivered to the server

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

@@ -37,7 +37,9 @@ module Ably
     def_delegators :logger, :fatal, :error, :warn, :info, :debug
 
     private
-    attr_reader :client
+    def client
+      @client
+    end
 
     def color(color_value, string)
       "\033[#{color_value}m#{string}\033[0m"

data/lib/submodules/ably-ruby/lib/ably/models/cipher_params.rb

@@ -0,0 +1,114 @@
+require 'base64'
+require 'ably/util/crypto'
+
+module Ably::Models
+  # Convert cipher param attributes to a {CipherParams} object
+  #
+  # @param attributes (see #initialize)
+  #
+  # @return [CipherParams]
+  def self.CipherParams(attributes)
+    case attributes
+    when CipherParams
+      return attributes
+    else
+      CipherParams.new(attributes || {})
+    end
+  end
+
+  # CipherParams is used to configure a channel for encryption
+  #
+  class CipherParams
+    include Ably::Modules::ModelCommon
+
+    # @param params [Hash]
+    # @option params [String,Binary]  :key         Required private key must be either a binary (e.g. a ASCII_8BIT encoded string), or a base64-encoded string. If the key is a base64-encoded string, the it will be automatically converted into a binary
+    # @option params [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 params [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 params [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 params [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}
+    #
+    def initialize(params = {})
+      @attributes = IdiomaticRubyWrapper(params.clone)
+
+      raise Ably::Exceptions::CipherError, ':key param is required' unless attributes[:key]
+      raise Ably::Exceptions::CipherError, ':key param must be a base64-encoded string or byte array (ASCII_8BIT enocdede string)' unless key.kind_of?(String)
+      attributes[:key] = decode_key(key) if key.kind_of?(String) && key.encoding != Encoding::ASCII_8BIT
+
+      if attributes[:combined]
+        match = /(?<algorithm>\w+)-(?<key_length>\d+)-(?<mode>\w+)/.match(attributes[:combined])
+        raise Ably::Exceptions::CipherError, "Invalid :combined param, expecting format such as AES-256-CBC" unless match
+        attributes[:algorithm] = match[:algorithm]
+        attributes[:key_length] = match[:key_length].to_i
+        attributes[:mode] = match[:mode]
+      end
+
+      if attributes[:key_length] && (key_length != attributes[:key_length])
+        raise Ably::Exceptions::CipherError, "Incompatible :key length of #{key_length} and provided :key_length of #{attributes[:key_length]}"
+      end
+
+      if algorithm == 'aes' && mode == 'cbc'
+        unless [128, 256].include?(key_length)
+          raise Ably::Exceptions::CipherError, "Unsupported key length #{key_length} for aes-cbc encryption. Encryption key must be 128 or 256 bits (16 or 32 ASCII characters)"
+        end
+      end
+
+      attributes.freeze
+    end
+
+    # The Cipher algorithm string such as AES-128-CBC
+    # @param [Hash]  params  Hash containing :algorithm, :key_length and :mode key values
+    #
+    # @return [String]
+    def self.cipher_type(params)
+      "#{params[:algorithm]}-#{params[:key_length]}-#{params[:mode]}".to_s.upcase
+    end
+
+    # @!attribute [r] algorithm
+    # @return [String] The algorithm to use for encryption, currently only +AES+ is supported
+    def algorithm
+      attributes.fetch(:algorithm) do
+        Ably::Util::Crypto::DEFAULTS.fetch(:algorithm)
+      end.downcase
+    end
+
+    # @!attribute [r] key
+    # @return [Binary] Private key used to encrypt and decrypt payloads
+    def key
+      attributes[:key]
+    end
+
+    # @!attribute [r] key_length
+    # @return [Integer] The length in bits of the +key+
+    def key_length
+      key.unpack('b*').first.length
+    end
+
+    # @!attribute [r] mode
+    # @return [String] The cipher mode, currently only +CBC+ is supported
+    def mode
+      attributes.fetch(:mode) do
+        Ably::Util::Crypto::DEFAULTS.fetch(:mode)
+      end.downcase
+    end
+
+    # @!attribute [r] cipher_type
+    # @return [String] The complete Cipher algorithm string such as AES-128-CBC
+    def cipher_type
+      self.class.cipher_type(algorithm: algorithm, key_length: key_length, mode: mode)
+    end
+
+    # @!attribute [r] attributes
+    # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
+    def attributes
+      @attributes
+    end
+
+    private
+
+    def decode_key(encoded_key)
+      normalised_key = encoded_key.gsub('_', '/').gsub('-', '+')
+      Base64.decode64(normalised_key)
+    end
+  end
+end

data/lib/submodules/ably-ruby/lib/ably/models/connection_details.rb

@@ -28,26 +28,29 @@ module Ably::Models
     # @option attributes [Integer]   :max_frame_size        maximum size for a single frame of data sent to Ably. This restriction applies to a {Ably::Models::ProtocolMessage} sent over a realtime connection, or the total body size for a REST request
     # @option attributes [Integer]   :max_inbound_rate      maximum allowable number of requests per second from a client
     # @option attributes [Integer]   :connection_state_ttl  duration in seconds that Ably will persist the connection state when a Realtime client is abruptly disconnected
+    # @option attributes [String]    :server_id             unique identifier of the Ably server where the connection is established
     #
     def initialize(attributes = {})
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
-      hash[:connection_state_ttl] = (hash[:connection_state_ttl].to_f / 1000).round if hash[:connection_state_ttl]
-      hash.freeze
+      if self.attributes[:connection_state_ttl]
+        self.attributes[:connection_state_ttl] = (self.attributes[:connection_state_ttl].to_f / 1000).round
+      end
+      self.attributes.freeze
     end
 
-    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl).each do |attribute|
+    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl server_id).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def has_client_id?
-      hash.has_key?(:client_id)
+      attributes.has_key?(:client_id)
     end
 
-    # @!attribute [r] hash
+    # @!attribute [r] attributes
     # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
-    def hash
+    def attributes
       @hash_object
     end
   end

data/lib/submodules/ably-ruby/lib/ably/models/error_info.rb

@@ -8,7 +8,7 @@ module Ably::Models
   #   @return [Integer] Ably error code (see ably-common/protocol/errors.json)
   # @!attribute [r] status
   #   @return [Integer] HTTP Status Code corresponding to this error, where applicable
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class ErrorInfo
@@ -21,12 +21,12 @@ module Ably::Models
 
     %w(message code status_code).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
     alias_method :status, :status_code
 
-    def hash
+    def attributes
       @hash_object
     end
 

data/lib/submodules/ably-ruby/lib/ably/models/idiomatic_ruby_wrapper.rb

@@ -57,14 +57,14 @@ module Ably::Models
         $stderr.puts "<IdiomaticRubyWrapper#initialize> WARNING: Wrapping a IdiomaticRubyWrapper with another IdiomaticRubyWrapper"
       end
 
-      @hash = mixedCaseHashObject
-      @stop_at = Array(stop_at).each_with_object({}) do |key, hash|
-        hash[convert_to_snake_case_symbol(key)] = true
+      @attributes = mixedCaseHashObject
+      @stop_at = Array(stop_at).each_with_object({}) do |key, object|
+        object[convert_to_snake_case_symbol(key)] = true
       end.freeze
     end
 
     def [](key)
-      value = hash[source_key_for(key)]
+      value = attributes[source_key_for(key)]
       if stop_at?(key) || !value.kind_of?(Hash)
         value
       else
@@ -73,7 +73,7 @@ module Ably::Models
     end
 
     def []=(key, value)
-      hash[source_key_for(key)] = value
+      attributes[source_key_for(key)] = value
     end
 
     def fetch(key, default = nil)
@@ -91,7 +91,7 @@ module Ably::Models
     end
 
     def size
-      hash.size
+      attributes.size
     end
 
     def keys
@@ -103,14 +103,14 @@ module Ably::Models
     end
 
     def has_key?(key)
-      hash.has_key?(source_key_for(key))
+      attributes.has_key?(source_key_for(key))
     end
 
     # Method ensuring this {IdiomaticRubyWrapper} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
     def each
       return to_enum(:each) unless block_given?
 
-      hash.each do |key, value|
+      attributes.each do |key, value|
         key = convert_to_snake_case_symbol(key)
         value = self[key]
         yield key, value
@@ -138,9 +138,10 @@ module Ably::Models
       end
     end
 
-    # Access to the raw Hash object provided to the constructer of this wrapper
-    def hash
-      @hash
+    # @!attribute [r] Hash
+    # @return [Hash] Access to the raw Hash object provided to the constructer of this wrapper
+    def attributes
+      @attributes
     end
 
     # Takes the underlying Hash object and returns it in as a JSON ready Hash object using snakeCase for compability with the Ably service.
@@ -149,8 +150,8 @@ module Ably::Models
     #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
     #   wrapper.as_json({ 'mixedCase': true, 'snakeCase': 1 })
     def as_json(*args)
-      hash.each_with_object({}) do |key_val, new_hash|
-        key, val                 = key_val
+      attributes.each_with_object({}) do |key_val, new_hash|
+        key                      = key_val[0]
         mixed_case_key           = convert_to_mixed_case(key)
         wrapped_val              = self[key]
         wrapped_val              = wrapped_val.as_json(args) if wrapped_val.kind_of?(IdiomaticRubyWrapper)
@@ -171,26 +172,32 @@ module Ably::Models
     #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
     #   wrapper.to_hash({ mixed_case: true, snake_case: 1 })
     def to_hash(*args)
-      each_with_object({}) do |key_val, hash|
-        key, val  = key_val
-        val       = val.to_hash(args) if val.kind_of?(IdiomaticRubyWrapper)
-        hash[key] = val
+      each_with_object({}) do |key_val, object|
+        key, val    = key_val
+        val         = val.to_hash(args) if val.kind_of?(IdiomaticRubyWrapper)
+        object[key] = val
       end
     end
 
     # Method to create a duplicate of the underlying Hash object
     # Useful when underlying Hash is frozen
     def dup
-      Ably::Models::IdiomaticRubyWrapper.new(hash.dup)
+      Ably::Models::IdiomaticRubyWrapper.new(attributes.dup, stop_at: stop_at.keys)
     end
 
     # Freeze the underlying data
     def freeze
-      hash.freeze
+      attributes.freeze
     end
 
     def to_s
-      hash.to_s
+      attributes.to_s
+    end
+
+    # @!attribute [r] hash
+    # @return [Integer] Compute a hash-code for this hash. Two hashes with the same content will have the same hash code
+    def hash
+      attributes.hash
     end
 
     private
@@ -214,7 +221,7 @@ module Ably::Models
       ]
 
       preferred_format = format_preferences.detect do |format|
-        hash.has_key?(format.call(symbolized_key))
+        attributes.has_key?(format.call(symbolized_key))
       end || format_preferences.first
 
       preferred_format.call(symbolized_key)

data/lib/submodules/ably-ruby/lib/ably/models/message.rb

@@ -34,7 +34,7 @@ module Ably::Models
   #   @return [String] A globally unique message ID
   # @!attribute [r] connection_id
   #   @return [String] The connection_id of the publisher of the message
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class Message
@@ -45,51 +45,51 @@ module Ably::Models
 
     # {Message} initializer
     #
-    # @param  hash_object [Hash]            object with the underlying message details
+    # @param  attributes [Hash]             object with the underlying message detail key value attributes
     # @param  [Hash]      options           an options Hash for this initializer
     # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
     # @option options     [Logger]          :logger            An optional Logger to be used by {Ably::Modules::SafeDeferrable} if an exception is caught in a callback
     #
-    def initialize(hash_object, options = {})
+    def initialize(attributes, options = {})
       @logger           = options[:logger] # Logger expected for SafeDeferrable
       @protocol_message = options[:protocol_message]
-      @raw_hash_object  = hash_object
+      @raw_hash_object  = attributes
 
-      set_hash_object hash_object
+      set_attributes_object attributes
 
       ensure_utf_8 :name,      name,      allow_nil: true
       ensure_utf_8 :client_id, client_id, allow_nil: true
       ensure_utf_8 :encoding,  encoding,  allow_nil: true
     end
 
-    %w( name client_id encoding connection_id ).each do |attribute|
+    %w( name client_id encoding ).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def data
-      @data ||= hash[:data].freeze
+      @data ||= attributes[:data].freeze
     end
 
     def id
-      hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
+      attributes.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
     end
 
     def connection_id
-      hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
+      attributes.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
     end
 
     def timestamp
-      if hash[:timestamp]
-        as_time_from_epoch(hash[:timestamp])
+      if attributes[:timestamp]
+        as_time_from_epoch(attributes[:timestamp])
       else
         protocol_message.timestamp
       end
     end
 
-    def hash
-      @hash_object
+    def attributes
+      @attributes
     end
 
     def to_json(*args)
@@ -120,14 +120,16 @@ module Ably::Models
     end
 
     private
-    attr_reader :raw_hash_object
+    def raw_hash_object
+      @raw_hash_object
+    end
 
     def protocol_message_index
       protocol_message.messages.map(&:object_id).index(self.object_id)
     end
 
-    def set_hash_object(hash)
-      @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
+    def set_attributes_object(new_attributes)
+      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data])
     end
 
     def logger