angus-remote 0.0.1 → 0.0.2

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

@@ -0,0 +1,53 @@
+module Http
+  module QueryParams
+
+    # @return <String> This hash as a query string
+    #
+    # @example
+    #   { :name => "Bob",
+    #     :address => {
+    #       :street => '111 Ruby Ave.',
+    #       :city => 'Ruby Central',
+    #       :phones => ['111-111-1111', '222-222-2222']
+    #     }
+    #   }.to_params
+    #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+    def self.to_params(hash)
+      params = hash.map { |k,v| normalize_param(k,v) }.join
+      params.chop! # trailing &
+      params
+    end
+
+    # @param key<Object> The key for the param.
+    # @param value<Object> The value for the param.
+    #
+    # @return <String> This key value pair as a param
+    #
+    # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones&"
+    def self.normalize_param(key, value)
+      param = ''
+      stack = []
+
+      if value.is_a?(Array)
+        param << value.map { |element| normalize_param("#{key}[]", element) }.join
+      elsif value.is_a?(Hash)
+        stack << [key,value]
+      else
+        param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+      end
+
+      stack.each do |parent, hash|
+        hash.each do |k, v|
+          if v.is_a?(Hash)
+            stack << ["#{parent}[#{k}]", v]
+          else
+            param << normalize_param("#{parent}[#{k}]", v)
+          end
+        end
+      end
+
+      param
+    end
+
+  end
+end

data/lib/angus/remote/message.rb

@@ -0,0 +1,14 @@
+module Angus
+  module Remote
+
+    # A message returned by the service's response
+    class Message
+
+      attr_accessor :description
+      attr_accessor :key
+      attr_accessor :level
+
+    end
+
+  end
+end

data/lib/angus/remote/proxy_client.rb

@@ -0,0 +1,58 @@
+require 'json'
+require 'persistent_http'
+
+require_relative 'exceptions'
+require_relative 'proxy_client_utils'
+
+module Angus
+  module Remote
+
+    # A client for service invocation when proxing requests.
+    class ProxyClient
+
+      DEFAULT_TIMEOUT = 10
+
+      def initialize(url, timeout = DEFAULT_TIMEOUT)
+        url = url[0..-2] if url[-1] == '/'
+
+        @connection = PersistentHTTP.new(
+          :pool_size    => 4,
+          :pool_timeout => 10,
+          :warn_timeout => 0.25,
+          :force_retry  => false,
+          :url          => url,
+
+          :read_timeout => timeout,
+          :open_timeout => timeout
+        )
+
+        @api_base_path = @connection.default_path
+      end
+
+      # Makes a request to the service
+      #
+      def make_request(method, path, query, headers = {}, body = nil)
+        full_path = @api_base_path + path
+
+        request = ProxyClientUtils.build_request(method, full_path, query, headers, body)
+
+        begin
+          response = @connection.request(request)
+
+          from_headers = ProxyClientUtils.normalize_headers(
+             ProxyClientUtils.filter_response_headers(response.to_hash)
+          )
+
+          [response.code.to_i, from_headers, [response.body]]
+        rescue Errno::ECONNREFUSED
+          raise RemoteConnectionError.new(self.class.base_uri)
+        end
+      end
+
+      def to_s
+        "#<#{self.class}:#{object_id}>"
+      end
+    end
+
+  end
+end

data/lib/angus/remote/proxy_client_utils.rb

@@ -0,0 +1,70 @@
+require 'uri'
+require 'json'
+
+require_relative 'exceptions'
+require_relative 'http/query_params'
+
+module Angus
+  module Remote
+
+    module ProxyClientUtils
+
+      ALLOWED_RESPONSE_HEADERS = ['content-type']
+
+      def self.build_request(method, path, query, headers = {}, body = nil)
+        uri = URI(path)
+        uri.query = query
+
+        full_uri = uri.to_s
+
+        request = case method.to_s.downcase
+        when 'get'
+          Net::HTTP::Get.new(full_uri)
+        when 'post'
+          Net::HTTP::Post.new(full_uri)
+        when 'put'
+          Net::HTTP::Put.new(full_uri)
+        when 'delete'
+          Net::HTTP::Delete.new(full_uri)
+        else
+          raise MethodArgumentError.new(method)
+        end
+
+        headers.each do |k, v|
+          request[k] = v
+        end
+
+        request.body = body
+
+        request
+      end
+
+      def self.filter_response_headers(headers)
+        headers.select { |h, v| ALLOWED_RESPONSE_HEADERS.include?(h) }
+      end
+
+      # Converts any header value that is an array to its first value.
+      #
+      # @param [Hash] header
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   normalize_headers({'content-type'=>['application/json;charset=utf-8']})
+      #
+      #   -> {'content-type'=>'application/json;charset=utf-8'}
+      def self.normalize_headers(headers)
+        normalized = headers.map do |h, v|
+          if v.is_a?(Array)
+           [h, v.first]
+          else
+           [h, v]
+          end
+        end
+
+        Hash[normalized]
+      end
+    end
+
+  end
+end

data/lib/angus/remote/remote_response.rb

@@ -0,0 +1,44 @@
+require_relative 'response/hash'
+
+module Angus
+  module Remote
+
+    # A service's response
+    #
+    # Acts as an array to store information at HTTP level, like the status_code
+    class RemoteResponse
+      include Angus::Remote::Response::Hash
+
+      attr_accessor :status
+      attr_accessor :status_code
+      attr_accessor :messages
+
+      def initialize
+        @http_response_info = {}
+      end
+
+      def []=(key, value)
+        @http_response_info[key] = value
+      end
+
+      def [](key)
+        @http_response_info[key]
+      end
+
+      def to_s
+        "#<#{self.class}:#{object_id}>"
+      end
+
+      def to_hash
+        {
+          :http_status_code => @http_response_info[:status_code],
+          :body => @http_response_info[:body],
+          :service_name => @http_response_info[:service_name],
+          :operation_name => @http_response_info[:operation_name],
+        }
+      end
+
+    end
+
+  end
+end

data/lib/angus/remote/representation.rb

@@ -0,0 +1,18 @@
+require_relative 'response/hash'
+
+module Angus
+  module Remote
+
+    class Representation
+      include Angus::Remote::Response::Hash
+
+      attr_accessor :elements
+
+      def initialize
+        @http_response_info = {}
+        @elements = {}
+      end
+    end
+
+  end
+end

data/lib/angus/remote/response/builder.rb

@@ -0,0 +1,308 @@
+require 'bigdecimal'
+require 'date'
+require 'json'
+
+require_relative '../message'
+require_relative '../remote_response'
+
+require_relative 'hash'
+
+require_relative '../service_directory'
+
+
+# TODO: move to another gem and possibly change its name
+require_relative '../../unmarshalling'
+
+module Angus
+  module Remote
+    module Response
+
+      module Builder
+
+        # Builds a Response
+        #
+        # The r parameter should contain in the body, encoded as json, the values / objects
+        # specified in the operation response metadata
+        #
+        # @param [Integer] status_code HTTP status_code
+        # @param body [String] HTTP body
+        # @param service_name [String] Name of the service that the response belongs to
+        # @param version [String] Version of the service that the response belongs to
+        # @param operation_namespace [String] Namespace of the operation that the response belongs to
+        # @param operation_name [String] Name of the operation that the response belongs to
+        #
+        # @return A Response object that responds to the methods:
+        #   - status
+        #   - messages
+        #
+        #   Also, provides one method for each value / object / array returned
+        def self.build(status_code, body, service_code_name, version, operation_namespace,
+                       operation_code_name)
+          service_definition = Angus::Remote::ServiceDirectory.service_definition(
+            service_code_name, version
+          )
+
+          representations = service_definition.representations
+          glossary = service_definition.glossary
+
+          operation_definition = service_definition.operation_definition(operation_namespace,
+                                                                         operation_code_name)
+
+          json_response = JSON(body)
+
+          response_class = build_response_class(operation_definition.name)
+
+          response = response_class.new
+
+          # TODO use constants
+          response[:status_code] = status_code
+          response[:body] = body
+          response[:service_code_name] = service_code_name
+          response[:service_version] = version
+          response[:operation_namespace] = operation_namespace
+          response[:operation_code_name] = operation_code_name
+
+          response.status = json_response['status']
+          response.messages = self.build_messages(json_response['messages'])
+
+          representations_hash = self.representations_hash(representations)
+          glossary_terms_hash = glossary.terms_hash
+
+          operation_definition.response_elements.each do |element|
+            self.build_response_method(json_response, response_class, response,
+                                       representations_hash, glossary_terms_hash, element)
+          end
+
+          response
+        end
+
+        # Builds the methods for each value / object / array
+        #
+        # The r parameter should contain in the body, encoded as json, the values / objects
+        # specified in the operation response metadata
+        def self.build_response_method(json_response, response_class, response,
+                                       representations_hash, glossary_terms_hash, element)
+          if (json_response.has_key?(element.name))
+            hash_value = json_response[element.name]
+          elsif (element.required == false)
+            hash_value = element.default
+          else
+            return
+          end
+
+          object_value = nil
+
+          if element.type && representations_hash.include?(element.type)
+            object_value = self.build_from_representation(hash_value, element.type,
+                                                          representations_hash, glossary_terms_hash)
+          elsif element.elements_type
+            object_value = self.build_collection_from_representation(hash_value,
+                                                                     element.elements_type,
+                                                                     representations_hash,
+                                                                     glossary_terms_hash)
+          elsif element.type && element.type.to_sym == :variable
+            object_value = self.build_from_variable_fields(hash_value)
+          elsif element.type
+            begin
+              object_value = Angus::Unmarshalling.unmarshal_scalar(hash_value,
+                                                                     element.type.to_sym)
+            rescue ArgumentError
+              object_value = nil
+            end
+          end
+
+          # Don't apply the glossary to response elements
+          response.elements[element.name] = object_value
+
+          # Instead, apply the glossary to method names
+          getter_method_name = self.apply_glossary(element.name, glossary_terms_hash)
+
+          response_class.send :define_method, getter_method_name do
+            object_value
+          end
+        end
+
+        # Builds a Response based on a service's response
+        #
+        # The remote_response parameter should contain in the body,
+        # encoded as json, the values / objects
+        # specified in the operation response metadata.
+        #
+        # @param [Http] remote_response HTTP response object, must respond to methods :body and :code
+        # @param [String] service_name  Name of the invoked service
+        # @param version [String] Version of the invoked service
+        # @param operation_namespace [String] Namespace of the invoked operation
+        # @param operation_name [String] Name of the invoked operation
+        #
+        # @return (see #build)
+        def self.build_from_remote_response(remote_response, service_code_name, version,
+                                            operation_namespace, operation_code_name)
+
+          status_code = remote_response.code
+          body = remote_response.body
+
+          self.build(status_code, body, service_code_name, version, operation_namespace,
+                     operation_code_name)
+        end
+
+        # Searches for a short name in the glossary and returns the corresponding long name
+        #
+        # If name is not a short name, returns the name
+        #
+        # @param [String] name
+        # @param [Hash<String, GlossaryTerm>] glossary_terms_hash, where keys are short names
+        #
+        # @return long name
+        def self.apply_glossary(name, glossary_terms_hash)
+          if glossary_terms_hash.include?(name)
+            name = glossary_terms_hash[name].long_name
+          end
+
+          return name
+        end
+
+        # Build a response class for the operation
+        #
+        # @param [String] operation_name the name of the operation
+        #
+        # @return [Class] A class client, that inherits from {Angus::Remote::Response}
+        def self.build_response_class(operation_name)
+          response_class = Class.new(Angus::Remote::RemoteResponse)
+          response_class.class_eval <<-END
+            def self.name
+              "#<Response_#{operation_name.gsub(' ', '_')}>"
+            end
+
+            def self.to_s
+              name
+            end
+          END
+
+          response_class
+        end
+
+        # Receives an array of messages and returns an array of Message objects
+        def self.build_messages(messages)
+          messages ||= []
+
+          messages.map do |m|
+            message = Angus::Remote::Message.new
+            message.description = m['dsc']
+            message.key = m['key']
+            message.level = m['level']
+
+            message
+          end
+        end
+
+        # Receives a hash, a type and an array of representations and
+        # build an object that has one method for each attribute of the type.
+        def self.build_from_representation(hash_value, type, representations, glossary_terms_hash)
+          return nil if hash_value.nil?
+
+          representation_class = Class.new do
+            include Angus::Remote::Response::Hash
+          end
+
+          representation_object = representation_class.new
+
+          if representations.include?(type)
+            representation = representations[type]
+            return nil if representation.nil?
+            representation.fields.each do |field|
+              field_raw_value = hash_value[field.name]
+              field_value = nil
+              unless field_raw_value.nil? && field.required == false
+                if field.type && representations.include?(field.type)
+                  field_value = self.build_from_representation(field_raw_value, field.type,
+                                                               representations,
+                                                               glossary_terms_hash)
+                elsif field.elements_type
+                  field_value = self.build_collection_from_representation(field_raw_value,
+                                                                          field.elements_type,
+                                                                          representations,
+                                                                          glossary_terms_hash)
+                elsif field.type && field.type.to_sym == :variable
+                  field_value = self.build_from_variable_fields(field_raw_value)
+                elsif field.type
+                  field_value = Angus::Unmarshalling.unmarshal_scalar(field_raw_value,
+                                                                        field.type.to_sym)
+                end
+              end
+
+              # Don't apply the glossary to response elements
+              representation_object.elements[field.name] = field_value
+
+              # Instead, apply the glossary to method names
+              getter_method_name = self.apply_glossary(field.name, glossary_terms_hash)
+
+              representation_class.send :define_method, field.name.to_sym do
+                field_value
+              end
+            end
+          else
+            if type.to_sym == :variable
+              representation_object = self.build_from_variable_fields(hash_value)
+            else
+              begin
+                representation_object = Angus::Unmarshalling.unmarshal_scalar(hash_value,
+                                                                                type.to_sym)
+              rescue ArgumentError
+                representation_object = nil
+              end
+            end
+          end
+
+
+          return representation_object
+        end
+
+        # Builds an array of objects that corresponds to the received type
+        def self.build_collection_from_representation(value_array, type, representations,
+                                                      glossary_terms_hash)
+          collection = []
+
+          value_array.each do |raw_value|
+            collection << build_from_representation(raw_value, type, representations,
+                                                    glossary_terms_hash)
+          end
+
+          collection
+        end
+
+        # Builds an object from variable fields
+        def self.build_from_variable_fields(variable_fields_hash)
+
+          return nil if variable_fields_hash.nil?
+
+          representation_class = Class.new do
+            include Angus::Remote::Response::Hash
+          end
+
+          representation_object = representation_class.new
+
+          variable_fields_hash.each do |key_name, field_value|
+            representation_object.elements[key_name] = field_value
+            representation_class.send :define_method, key_name.to_sym do
+              field_value
+            end
+          end
+
+          representation_object
+
+        end
+
+        # Receives an array of representations and returns a hash of representations where
+        # the keys are the representation's names and the values are the representations
+        def self.representations_hash(representations)
+          hash = {}
+          representations.each do |representation|
+            hash[representation.name] = representation
+          end
+          hash
+        end
+      end
+
+    end
+  end
+end