ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,49 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      # Encode the body of the message according to the mime type
+      class Encoder < ::Faraday::Response::Middleware
+        CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+
+        def call(env)
+          encode env if env.body
+          @app.call env
+        end
+
+        private
+        def encode(env)
+          env.body = case request_type(env)
+          when 'application/x-msgpack'
+            to_msgpack(env.body)
+          when 'application/json', '', nil
+            env.request_headers[CONTENT_TYPE] = 'application/json'
+            to_json(env.body)
+          else
+            env.body
+          end
+        end
+
+        def to_msgpack(body)
+          body.to_msgpack
+        end
+
+        def to_json(body)
+          if body.kind_of?(String)
+            body
+          else
+            body.to_json
+          end
+        end
+
+        def request_type(env)
+          type = env.request_headers[CONTENT_TYPE].to_s
+          type = type.split(';', 2).first if type.index(';')
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      # 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
+        def on_complete(env)
+          if env.status >= 400
+            error_status_code = env.status
+            error_code = nil
+
+            if env.body.kind_of?(Hash)
+              error = env.body.fetch('error', {})
+              error_status_code = error['statusCode'].to_i if error['statusCode']
+              error_code = error['code'].to_i if error['code']
+
+              if error
+                message = "#{error['message']} (status: #{error_status_code}, code: #{error_code})"
+              else
+                message = env.body
+              end
+            else
+              message = env.body
+            end
+
+            message = 'Unknown server error' if message.to_s.strip == ''
+
+            if env.status >= 500
+              raise Ably::Exceptions::ServerError, message
+            else
+              raise Ably::Exceptions::InvalidRequest.new(message, error_status_code, error_code)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'faraday'
+
+module Ably
+  module Rest
+    module Middleware
+      # HTTP exceptions raised due to a status code error on a 3rd party site
+      # Used by auth calls
+      class ExternalExceptions < Faraday::Response::Middleware
+        def on_complete(env)
+          if env.status >= 400
+            error_status_code = env.status
+            message = "Error #{error_status_code}: #{(env.body || '')[0...200]}"
+
+            if error_status_code >= 500
+              raise Ably::Exceptions::ServerError, message
+            else
+              raise Ably::Exceptions::InvalidRequest, message
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      class FailIfUnsupportedMimeType < Faraday::Response::Middleware
+        def on_complete(env)
+          unless env.response_headers['Ably-Middleware-Parsed'] == true
+            raise Ably::Exceptions::InvalidResponseBody,
+                  "Content Type #{env.response_headers['Content-Type']} is not supported by this client library"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'faraday'
+
+module Ably
+  module Rest
+    module Middleware
+      class Logger < Faraday::Response::Middleware
+        extend Forwardable
+
+        def initialize(app, logger = nil)
+          super(app)
+          @logger = logger || begin
+            require 'logger'
+            ::Logger.new(STDOUT)
+          end
+        end
+
+        def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+        def call(env)
+          debug "=> URL: #{env.method} #{env.url}, Headers: #{dump_headers env.request_headers}"
+          debug "=> Body: #{body_for(env)}"
+          super
+        end
+
+        def on_complete(env)
+          debug "<= Status: #{env.status}, Headers: #{dump_headers env.response_headers}"
+          debug "<= Body: #{body_for(env)}"
+        end
+
+        private
+        def dump_headers(headers)
+          headers.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        end
+
+        def body_for(env)
+          return '' if !env.body || env.body.empty?
+
+          if env.request_headers['Content-Type'] == 'application/x-msgpack'
+            MessagePack.unpack(env.body)
+          else
+            env.body
+          end
+
+        rescue StandardError
+          readable_body(env.body)
+        end
+
+        def readable_body(body)
+          if body.respond_to?(:encoding) && body.encoding == Encoding::ASCII_8BIT
+            body.unpack('H*')
+          else
+            body
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      class ParseJson < Faraday::Response::Middleware
+        def on_complete(env)
+          if env.response_headers['Content-Type'] == 'application/json'
+            env.body = parse(env.body) unless env.response_headers['Ably-Middleware-Parsed'] == true
+            env.response_headers['Ably-Middleware-Parsed'] = true
+          end
+        end
+
+        def parse(body)
+          if body.length > 0
+            JSON.parse(body)
+          else
+            body
+          end
+        rescue JSON::ParserError => e
+          raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'faraday'
+require 'msgpack'
+
+module Ably
+  module Rest
+    module Middleware
+      class ParseMessagePack < Faraday::Response::Middleware
+        def on_complete(env)
+          if env.response_headers['Content-Type'] == 'application/x-msgpack'
+            env.body = parse(env.body) unless env.response_headers['Ably-Middleware-Parsed'] == true
+            env.response_headers['Ably-Middleware-Parsed'] = true
+          end
+        end
+
+        def parse(body)
+          if body.length > 0
+            MessagePack.unpack(body)
+          else
+            body
+          end
+        rescue MessagePack::MalformedFormatError => e
+          raise Ably::Exceptions::InvalidResponseBody, "Expected MessagePack response: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Ably
+  module Rest
+    class Presence
+      include Ably::Modules::Conversions
+
+      # {Ably::Rest::Client} for this Presence object
+      # @return {Ably::Rest::Client}
+      attr_reader :client
+
+      # {Ably::Rest::Channel} this Presence object is associated with
+      # @return {Ably::Rest::Channel}
+      attr_reader :channel
+
+      # Initialize a new Presence object
+      #
+      # @param client [Ably::Rest::Client]
+      # @param channel [Channel] The channel object
+      def initialize(client, channel)
+        @client  = client
+        @channel = channel
+      end
+
+      # Obtain the set of members currently present for a channel
+      #
+      # @param [Hash] options the options for the set of members present
+      # @option options [Integer,Time] :start      Time or millisecond since epoch
+      # @option options [Integer,Time] :end        Time or millisecond since epoch
+      # @option options [Symbol]       :direction  `:forwards` or `:backwards`
+      # @option options [Integer]      :limit      Maximum number of members to retrieve up to 10,000
+      #
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
+      #
+      def get(options = {})
+        options = options.dup
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        response = client.get(base_path, options)
+
+        Ably::Models::PaginatedResource.new(response, base_path, client, paginated_options) do |presence_message|
+          presence_message.tap do |presence_message|
+            decode_message presence_message
+          end
+        end
+      end
+
+      # Return the presence messages history for the channel
+      #
+      # @param [Hash] options the options for the message history request
+      # @option options [Integer,Time] :start      Time or millisecond since epoch
+      # @option options [Integer,Time] :end        Time or millisecond since epoch
+      # @option options [Symbol]       :direction  `:forwards` or `:backwards`
+      # @option options [Integer]      :limit      Maximum number of presence messages to retrieve up to 10,000
+      #
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
+      #
+      def history(options = {})
+        url = "#{base_path}/history"
+        options = options.dup
+
+        [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        response = client.get(url, options)
+
+        Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |presence_message|
+          presence_message.tap do |presence_message|
+            decode_message presence_message
+          end
+        end
+      end
+
+      private
+      def base_path
+        "/channels/#{CGI.escape(channel.name)}/presence"
+      end
+
+      def decode_message(presence_message)
+        presence_message.decode self.channel
+      rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+        client.logger.error "Decoding Error on presence channel '#{channel.name}', presence message client_id '#{presence_message.client_id}'. #{e.class.name}: #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'msgpack'
+require 'openssl'
+
+module Ably::Util
+  class Crypto
+    DEFAULTS = {
+      algorithm: 'AES',
+      mode: 'CBC',
+      key_length: 128,
+    }
+
+    BLOCK_LENGTH = 16
+
+    # Configured options for this Crypto object, see {#initialize} for a list of configured options
+    #
+    # @return [Hash]
+    attr_reader :options
+
+    # 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}
+    #
+    # @return [Ably::Util::Crypto]
+    #
+    # @example
+    #    crypto = Ably::Util::Crypto.new(key: 'mysecret')
+    #    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
+    end
+
+    # Encrypt payload using configured Cipher
+    #
+    # @param [String] payload           the payload to be encrypted
+    # @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
+    #
+    def encrypt(payload, encrypt_options = {})
+      cipher = openssl_cipher
+      cipher.encrypt
+      cipher.key = key
+      iv = encrypt_options[:iv] || options[:iv] || cipher.random_iv
+      cipher.iv = iv
+
+      iv << cipher.update(payload) << cipher.final
+    end
+
+    # Decrypt payload using configured Cipher
+    #
+    # @param [String] encrypted_payload_with_iv  the encrypted payload to be decrypted
+    #
+    # @return [String]
+    #
+    def decrypt(encrypted_payload_with_iv)
+      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)
+
+      decipher = openssl_cipher
+      decipher.decrypt
+      decipher.key = key
+      decipher.iv = iv
+
+      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
+    # @return [String]
+    def cipher_type
+      (options[:combined] || "#{options[:algorithm]}-#{options[:key_length]}-#{options[:mode]}").to_s.upcase
+    end
+
+    private
+    def key
+      options[:key]
+    end
+
+    def openssl_cipher
+      OpenSSL::Cipher.new(cipher_type)
+    end
+  end
+end