angus-remote 0.0.1 → 0.0.2

data/lib/angus-remote.rb

@@ -0,0 +1,4 @@
+require 'angus/remote/client'
+require 'angus/remote/builder'
+require 'angus/remote/service_directory'
+require 'angus/remote/response/serializer'

data/lib/angus/remote/builder.rb

@@ -0,0 +1,204 @@
+require 'uri'
+
+require_relative 'client'
+require_relative 'response/builder'
+
+module Angus
+  module Remote
+
+    module Builder
+
+      DEFAULT_TIMEOUT = 60
+
+      # Builds a client for a specific service.
+      #
+      # @param [String] code_name The service's name known to the service directory
+      # @param [Angus::SDoc::Definitions::Service] service_definition
+      # @param api_url Base service api url
+      #
+      # @return [Remote::Client] object that implements each method specified as operation
+      #   in the service metadata
+      def self.build(code_name, service_definition, api_url)
+        remote_service_class = build_client_class(service_definition.name)
+
+        # TODO: define how to use the namespace in the remote client.
+        if service_definition.operations.is_a?(Hash)
+          service_definition.operations.each do |namespace, operations|
+            operations.each do |operation|
+              self.define_operation(remote_service_class, namespace, operation, code_name,
+                                    service_definition)
+            end
+          end
+        else
+          service_definition.operations.each do |operation|
+            self.define_operation(remote_service_class, code_name, operation, code_name,
+                                  service_definition)
+          end
+        end
+
+        service_definition.proxy_operations.each do |namespace, operations|
+          operations.each do |operation|
+            self.define_proxy_operation(remote_service_class, namespace, operation, code_name,
+                                        service_definition)
+          end
+        end
+
+        remote_service_class.new(api_url, self.default_timeout)
+      end
+
+      def self.define_operation(client_class, namespace, operation, service_code_name,
+                                service_definition)
+        client_class.send :define_method, operation.code_name do |encode_as_json = false,
+                                                                  path_params = nil,
+                                                                  request_params = nil|
+
+          args = [encode_as_json, path_params, request_params]
+
+          request_params = Angus::Remote::Builder.extract_var_arg!(args, Hash) || {}
+          path_params = Angus::Remote::Builder.extract_var_arg!(args, Array) || []
+          encode_as_json = Angus::Remote::Builder.extract_var_arg!(args, TrueClass) || false
+
+          request_params = Angus::Remote::Builder.apply_glossary(service_definition.glossary, request_params)
+          request_params = Angus::Remote::Builder.escape_request_params(request_params)
+
+          response = make_request(operation.path, operation.method, encode_as_json, path_params,
+                                  request_params)
+
+          Angus::Remote::Response::Builder.build_from_remote_response(response,
+                                                                        service_code_name,
+                                                                        service_definition.version,
+                                                                        namespace,
+                                                                        operation.code_name)
+        end
+      end
+
+      def self.define_proxy_operation(client_class, namespace, operation, service_code_name,
+                                      service_definition)
+        client_class.send :define_method, operation.code_name do |encode_as_json = false,
+                                                                  path_params = nil,
+                                                                  request_params = nil|
+
+          service_definition = Angus::Remote::ServiceDirectory.join_proxy(
+            service_code_name,
+            service_definition.version,
+            operation.service_name
+          )
+
+          args = [encode_as_json, path_params, request_params]
+
+          request_params = Angus::Remote::Builder.extract_var_arg!(args, Hash) || {}
+          path_params = Angus::Remote::Builder.extract_var_arg!(args, Array) || []
+          encode_as_json = Angus::Remote::Builder.extract_var_arg!(args, TrueClass) || false
+
+          request_params = Angus::Remote::Builder.apply_glossary(service_definition.glossary,
+                                                                   request_params)
+
+          request_params = Angus::Remote::Builder.escape_request_params(request_params)
+
+          response = make_request(operation.path, operation.method, encode_as_json, path_params,
+                                  request_params)
+
+          Angus::Remote::Response::Builder.build_from_remote_response(response,
+                                                                        service_code_name,
+                                                                        service_definition.version,
+                                                                        namespace,
+                                                                        operation.code_name)
+        end
+      end
+
+      # Build a client class for the service
+      #
+      # @param [String] service_name the name of the service
+      # @param [String] api_url the url for consuming the service's api
+      #
+      # @return [Class] A class client, that inherits from {Angus::Remote::Client}
+      def self.build_client_class(service_name)
+        remote_service_class = Class.new(Angus::Remote::Client)
+
+        remote_service_class.class_eval <<-END
+          def self.name
+            "#<Client_#{service_name}>"
+          end
+
+          def self.to_s
+            name
+          end
+        END
+
+        remote_service_class
+      end
+
+
+      # Applies glossary to params.
+      #
+      # Converts the params that are long names to short names
+      #
+      # @param [Glossary] glossary of terms
+      # @param [Hash] params
+      #
+      # @return [Hash] params with long names
+      def self.apply_glossary(glossary, params)
+        terms_hash = glossary.terms_hash_with_long_names
+
+        applied_params = {}
+
+        params.each do |name, value|
+          if terms_hash.include?(name.to_s)
+            term = terms_hash[name.to_s]
+            applied_params[term.short_name.to_sym] = value
+          else
+            applied_params[name] = value
+          end
+        end
+
+        applied_params
+      end
+
+      # Extract an argument of class +klass+ from an array of +args+
+      #
+      # Returns the first value from +args+ (starting from the end of args) whose class matches +klass+
+      # @param args Array of arguments
+      # @param klass Class that should match the returned value
+      #
+      def self.extract_var_arg!(args, klass)
+        arg = nil
+        arg_found = false
+
+        i = args.length
+        while !arg_found && i > 0
+          i -= 1
+          arg = args[i]
+          arg_found = true if arg.is_a?(klass)
+        end
+
+        if arg_found
+          args.delete_at(i)
+          arg
+        end
+      end
+
+      def self.escape_request_params(request_params)
+        encoded = {}
+        request_params.each do |name, value|
+          encoded_name = URI.escape(name.to_s)
+          if value.is_a? Hash
+            value = self.escape_request_params(value)
+          end
+          encoded[encoded_name] = value
+        end
+        encoded
+      end
+
+
+      def self.default_timeout
+        @default_timeout || DEFAULT_TIMEOUT
+      end
+
+      def self.default_timeout=(default_timeout)
+        @default_timeout = default_timeout
+      end
+
+    end
+
+  end
+end

data/lib/angus/remote/client.rb

@@ -0,0 +1,79 @@
+require 'json'
+require 'persistent_http'
+
+require_relative 'exceptions'
+require_relative 'utils'
+
+require_relative 'response/builder'
+
+module Angus
+  module Remote
+
+    # A client for service invocation
+    class Client
+      def initialize(api_url, timeout = nil)
+        api_url = api_url[0..-2] if api_url[-1] == '/'
+
+        @connection = PersistentHTTP.new(
+          :pool_size    => 10,
+          :pool_timeout => 10,
+          :warn_timeout => 0.25,
+          :force_retry  => false,
+          :url          => api_url,
+
+          :read_timeout => timeout,
+          :open_timeout => timeout
+        )
+
+        @api_base_path = @connection.default_path
+      end
+
+      # Makes a request to the service
+      #
+      # @param [String] path The operation URL path. It can have place holders,
+      #   ex: /user/:user_id/profile
+      # @param [String] method The http method for the request: get, post, put, delete
+      # @param [String] encode_as_json If true, the request params are encoded as json in the
+      #   request body
+      # @param [String] path_params Params that go into the path. This is an array, the first
+      #   element in the array goes in the first path placeholder.
+      # @param [String] request_params Params that go as url params or as data encoded in the body.
+      #
+      # @return [Net::HTTPResponse] The remote service response.
+      #
+      # @raise (see Utils.build_request)
+      # @raise [RemoteSevereError] When the remote response status code is of severe error.
+      #   see Utils.severe_error_response?
+      # @raise [RemoteConnectionError] When the remote service refuses the connection.
+      def make_request(path, method, encode_as_json, path_params, request_params)
+        path = @api_base_path + Utils.build_path(path, path_params)
+
+        request = Utils.build_request(method, path, request_params, encode_as_json)
+
+        begin
+          response = @connection.request(request)
+
+          if Utils.severe_error_response?(response)
+            raise RemoteSevereError.new(get_error_messages(response.body))
+          end
+
+          response
+        rescue Errno::ECONNREFUSED, PersistentHTTP::Error
+          raise RemoteConnectionError.new(@api_base_path)
+        end
+      end
+
+      def to_s
+        "#<#{self.class}:#{object_id}>"
+      end
+
+      private
+
+      def get_error_messages(response_body)
+        json_response = JSON(response_body) rescue { 'messages' => [] }
+        Response::Builder::build_messages(json_response['messages'])
+      end
+    end
+
+  end
+end

data/lib/angus/remote/exceptions.rb

@@ -0,0 +1,50 @@
+module Angus
+  module Remote
+
+    class RemoteSevereError < Exception
+
+      attr_reader :messages
+
+      def initialize(messages)
+        @messages = messages
+      end
+
+    end
+
+    class RemoteConnectionError < Exception
+
+      def initialize(url)
+        @remote_url = url
+      end
+
+      def message
+        "Remote Connection Error: #@remote_url"
+      end
+
+    end
+
+    class MethodArgumentError < Exception
+
+      def initialize(method)
+        @method = method
+      end
+
+      def message
+        "Invalid http method: #@method"
+      end
+    end
+
+    class PathArgumentError < Exception
+
+      def initialize(current, expected)
+        @current = current
+        @expected = expected
+      end
+
+      def message
+        "Wrong number of arguments (#@current for #@expected)"
+      end
+    end
+
+  end
+end

data/lib/angus/remote/http/multipart.rb

@@ -0,0 +1,54 @@
+require 'tempfile'
+require 'net/http/post/multipart'
+
+module Http
+  module Multipart
+
+    TRANSFORMABLE_TYPES = [File, Tempfile, StringIO]
+
+    QUERY_STRING_NORMALIZER = Proc.new do |params|
+      Multipart.flatten_params(params).map do |(k,v)|
+        [k, Multipart.transformable_type?(v) ? Multipart.file_to_upload_io(v) : v]
+      end
+    end
+
+    def self.file_to_upload_io(file)
+      if file.respond_to? :original_filename
+        filename = file.original_filename
+      else
+        filename =  File.split(file.path).last
+      end
+      content_type = 'application/octet-stream'
+      UploadIO.new(file, content_type, filename)
+    end
+
+    def self.hash_contains_files?(hash)
+      hash.is_a?(Hash) && self.flatten_params(hash).select do |(k,v)|
+        self.transformable_type?(v) || v.is_a?(UploadIO)
+      end.size > 0
+    end
+
+    def self.transformable_type?(object)
+      TRANSFORMABLE_TYPES.any? { |klass| object.is_a?(klass) }
+    end
+
+    def self.flatten_params(params={}, prefix='')
+      flattened = []
+      params.each do |(k,v)|
+        if params.is_a?(Array)
+          v = k
+          k = ''
+        end
+
+        flattened_key = prefix == '' ? "#{k}" : "#{prefix}[#{k}]"
+        if v.is_a?(Hash) || v.is_a?(Array)
+          flattened += flatten_params(v, flattened_key)
+        else
+          flattened << [flattened_key, v]
+        end
+      end
+      flattened
+    end
+
+  end
+end

data/lib/angus/remote/http/multipart_methods/multipart_base.rb

@@ -0,0 +1,36 @@
+require 'net/http/post/multipart'
+
+module Http
+  module MultipartMethods
+
+    module MultipartBase
+      DEFAULT_BOUNDARY = '-----------RubyMultipartPost'
+      # prevent reinitialization of headers
+      def initialize_http_header(initheader)
+        super
+        set_headers_for_body
+      end
+
+      def body=(value)
+        @body_parts = value.map {|(k,v)| Parts::Part.new(boundary, k, v)}
+        @body_parts << Parts::EpiloguePart.new(boundary)
+        set_headers_for_body
+      end
+
+      def boundary
+        DEFAULT_BOUNDARY
+      end
+
+      private
+
+      def set_headers_for_body
+        if @body_parts
+          self.set_content_type('multipart/form-data', {'boundary' => boundary})
+          self.content_length = @body_parts.inject(0) { |sum,i| sum + i.length }
+          self.body_stream = CompositeReadIO.new(*@body_parts.map { |part| part.to_io })
+        end
+      end
+    end
+
+  end
+end

data/lib/angus/remote/http/multipart_methods/multipart_post.rb

@@ -0,0 +1,11 @@
+require_relative 'multipart_base'
+
+module Http
+  module MultipartMethods
+
+    class Post < Net::HTTP::Post
+      include MultipartBase
+    end
+
+  end
+end

data/lib/angus/remote/http/multipart_methods/multipart_put.rb

@@ -0,0 +1,11 @@
+require_relative 'multipart_base'
+
+module Http
+  module MultipartMethods
+
+    class Put < Net::HTTP::Put
+      include MultipartBase
+    end
+
+  end
+end