angus-remote 0.0.1 → 0.0.2

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

@@ -0,0 +1,47 @@
+module Angus
+  module Remote
+    module Response
+
+      module Hash
+
+        def elements
+          @elements ||= {}
+        end
+
+        # Creates a hash base on the object
+        #
+        # The object must have an instance variable @elements that is a hash
+        #   that keys => element name, value => element value
+        def to_hash
+          hash = {}
+
+          elements.each do |name, value|
+            if value.is_a?(Angus::Remote::Response::Hash)
+              value.to_hash
+            elsif value.is_a?(Array)
+              hash[name] = build_hash_from_array(value)
+            else
+              hash[name] = value
+            end
+          end
+        end
+
+        private
+
+        def build_hash_from_array(elements)
+          elements.map do |element|
+            if element.is_a?(Angus::Remote::Response::Hash)
+              element.to_hash
+            elsif element.is_a?(Array)
+              build_hash_from_array(element)
+            else
+              element
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'json'
+
+require_relative 'builder'
+
+module Angus
+  module Remote
+    module Response
+
+      module Serializer
+
+        def self.serialize(response)
+          h = {}
+          h['status_code'] = response[:status_code]
+          h['body'] = response[:body]
+          h['service_code_name'] = response[:service_code_name]
+          h['service_version'] = response[:service_version]
+          h['operation_namespace'] = response[:operation_namespace]
+          h['operation_code_name'] = response[:operation_code_name]
+
+          h['body'].force_encoding('UTF-8')
+
+          JSON(h)
+        end
+
+        def self.unserialize(s)
+          s = JSON(s)
+
+          service_code_name = s['service_code_name']
+          version = s['service_version']
+
+          operation_code_name = s['operation_code_name']
+          operation_namespace = s['operation_namespace']
+          status_code = s['status_code']
+          body = s['body']
+
+          Response::Builder.build(status_code, body, service_code_name, version,
+                                  operation_namespace, operation_code_name)
+        end
+      end
+
+    end
+  end
+end

data/lib/angus/remote/service_directory.rb

@@ -0,0 +1,217 @@
+require 'json'
+require 'yaml'
+
+require 'angus/sdoc'
+
+require_relative 'builder'
+require_relative 'exceptions'
+
+module Angus
+  module Remote
+
+    module ServiceDirectory
+
+      # Path to the configuration file that has the information about the
+      # doc_url and api_url
+      SERVICES_CONFIGURATION_FILE = 'config/services.yml'
+
+      # Builds and returns a Client object for the service and version received
+      def self.lookup(code_name, version = nil)
+
+        version ||= service_version(code_name)
+
+        @clients_cache ||= {}
+        if @clients_cache.include?([code_name, version])
+          return @clients_cache[[code_name, version]]
+        end
+
+        begin
+          service_definition = self.service_definition(code_name, version)
+          client = Angus::Remote::Builder.build(code_name, service_definition,
+                                                  self.api_url(code_name, version))
+          @clients_cache[[code_name, version]] = client
+
+        rescue Errno::ECONNREFUSED
+          raise RemoteConnectionError.new(self.api_url(code_name, version))
+        end
+      end
+
+      # Returns the documentation url from the configuration file
+      #
+      # @param [String] code_name Name of the service.
+      # @param [String] version Version of the service.
+      #
+      # If no version given, it reads the version from the configuration file.
+      #
+      # @raise (see .service_version)
+      def self.doc_url(code_name, version = nil)
+        version ||= service_version(code_name)
+
+        config = service_configuration(code_name)
+
+        config["v#{version}"]['doc_url']
+      end
+
+      # Returns the documentation url for proxy operations hosted by the service.
+      #
+      # @param [String] code_name Service code name.
+      # @param [String] version Service version.
+      # @param [String] remote_code_name Service which implements proxy operations.
+      #
+      # @return [String]
+      def self.proxy_doc_url(code_name, version, remote_code_name)
+        doc_url = self.doc_url(code_name, version)
+
+        "#{doc_url}/proxy/#{remote_code_name}"
+      end
+
+      # Returns the api url from the configuration file
+      #
+      # @param [String] code_name Name of the service.
+      # @param [String] version Version of the service.
+      #
+      # If no version given, it reads the version from the configuration file.
+      #
+      # @raise (see .service_version)
+      def self.api_url(code_name, version = nil)
+        version ||= service_version(code_name)
+
+        config = service_configuration(code_name)
+
+        config["v#{version}"]["api_url"]
+      end
+
+      # Returns the configured version.
+      #
+      # @param [String] code_name Service name
+      #
+      # @return [String] Version. Ex: 0.1
+      #
+      # @raise [TooManyServiceVersions] When there are more than one configured version.
+      def self.service_version(code_name)
+        versions = service_configuration(code_name).keys
+
+        if versions.length == 1
+          versions.first.gsub(/^v/, '')
+        else
+          raise TooManyServiceVersions.new(code_name)
+        end
+      end
+
+      # Returns the connection configuration for a given service.
+      #
+      # @param [String] code_name Service name
+      #
+      # @return [Hash]
+      #
+      # @raise [ServiceConfigurationNotFound] When no configuration for the given service
+      def self.service_configuration(code_name)
+        @services_configuration ||= YAML.load_file(SERVICES_CONFIGURATION_FILE)
+
+        @services_configuration[code_name] or
+          raise ServiceConfigurationNotFound.new(code_name)
+      end
+
+      # Returns the service's definition for the given service name and version
+      #
+      # @param [String] code_name Service that acts as a proxy.
+      # @param [String] version Service version.
+      #
+      # @raise (see .service_version)
+      #
+      # @return [Angus::SDoc::Definitions::Service]
+      def self.service_definition(code_name, version = nil)
+        version ||= service_version(code_name)
+
+        @service_definitions_cache ||= {}
+        if @service_definitions_cache.include?([code_name, version])
+          return @service_definitions_cache[[code_name, version]]
+        end
+
+        service_definition = self.get_service_definition(code_name, version)
+        @service_definitions_cache[[code_name, version]] = service_definition
+      end
+
+      # Queries a service for definitions of proxy operations for the given remote service.
+      #
+      # Merges those definitions and returns the result.
+      #
+      # @param [String] code_name Service that acts as a proxy.
+      # @param [String] version Service version.
+      # @param [String] remote_code_name Remote service that implements operations for
+      #   the proxy service
+      #
+      # @return [Angus::SDoc::Definitions::Service]
+      def self.join_proxy(code_name, version, remote_code_name)
+
+        service_definition = self.service_definition(code_name, version)
+
+        @service_definitions_proxies ||= []
+        if @service_definitions_proxies.include?([code_name, version, remote_code_name])
+          return service_definition
+        end
+
+        proxy_doc_url = self.proxy_doc_url(code_name, version, remote_code_name)
+
+        definition_hash = fetch_remote_service_definition(proxy_doc_url)
+
+        proxy_service_definition = Angus::SDoc::DefinitionsReader.build_service_definition(definition_hash)
+
+        service_definition.merge(proxy_service_definition)
+
+        service_definition
+      end
+
+      # Requests a service definition.
+      #
+      # @param [String] code_name Service code name
+      # @param [String] version Service version
+      #
+      # @raise (see .service_version)
+      #
+      # @return [Angus::SDoc::Definitions::Service]
+      def self.get_service_definition(code_name, version = nil)
+        version ||= service_version(code_name)
+        doc_url = self.doc_url(code_name, version)
+
+        if doc_url.match('file://(.*)') || doc_url.match('file:///(.*)')
+          Angus::SDoc::DefinitionsReader.service_definition($1)
+        else
+          definition_hash = fetch_remote_service_definition(doc_url)
+          Angus::SDoc::DefinitionsReader.build_service_definition(definition_hash)
+        end
+      end
+
+      # Fetches a service definition from a remote http uri.
+      #
+      # @param [String] uri URI that publishes a service definition.
+      #   That uri should handle JSON format.
+      #
+      # @return [Hash] Service definition hash
+      def self.fetch_remote_service_definition(uri)
+        uri = URI(uri)
+        uri.query = URI.encode_www_form({:format => :json})
+
+        connection = Net::HTTP.new(uri.host, uri.port)
+
+        if uri.scheme == 'https'
+          connection.use_ssl = true
+          connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        response = connection.start do |http|
+          request = Net::HTTP::Get.new(uri.request_uri)
+
+          http.request(request)
+        end
+
+        JSON(response.body)
+      rescue Exception
+        raise RemoteConnectionError.new(uri)
+      end
+      private_class_method :fetch_remote_service_definition
+
+    end
+
+  end
+end

data/lib/angus/remote/utils.rb

@@ -0,0 +1,119 @@
+require 'json'
+require 'uri'
+
+require_relative 'exceptions'
+require_relative 'http/query_params'
+require_relative 'http/multipart'
+require_relative 'http/multipart_methods/multipart_put'
+require_relative 'http/multipart_methods/multipart_post'
+
+module Angus
+  module Remote
+
+    module Utils
+
+      HTTP_METHODS_WITH_BODY  = %w(post put)
+
+      RE_PATH_PARAM = /:\w+/
+
+      SEVERE_STATUS_CODES     = %w(500 501 503)
+
+      # Builds a request for the given method, path and params.
+      #
+      # @param [String] method
+      # @param [String] path
+      # @param [String] request_params
+      # @param [String] encode_as_json
+      #
+      # @return (see .build_base_request)
+      def self.build_request(method, path, request_params = {}, encode_as_json = false)
+        if encode_as_json
+          build_json_request(method, path, request_params)
+        else
+          build_normal_request(method, path, request_params)
+        end
+      end
+
+      def self.build_normal_request(method, path, params)
+        multipart_request = Http::Multipart.hash_contains_files?(params)
+
+        params = if multipart_request
+                   Http::Multipart::QUERY_STRING_NORMALIZER.call(params)
+                 else
+                   Http::QueryParams.to_params(params)
+                 end
+
+        if HTTP_METHODS_WITH_BODY.include?(method)
+          request = build_base_request(method, path, multipart_request)
+          request.body = params
+        else
+          uri = URI(path)
+          uri.query = params
+
+          request = build_base_request(method, uri.to_s)
+        end
+
+        request
+      end
+
+
+      def self.build_base_request(method, path, multipart_request = false)
+        case method.to_s.downcase
+        when 'get'
+          Net::HTTP::Get.new(path)
+        when 'post'
+          multipart_request ? Http::MultipartMethods::Post.new(path) : Net::HTTP::Post.new(path)
+        when 'put'
+          multipart_request ? Http::MultipartMethods::Put.new(path) : Net::HTTP::Put.new(path)
+        when 'delete'
+          Net::HTTP::Delete.new(path)
+        else
+          raise MethodArgumentError.new(method)
+        end
+      end
+
+      def self.build_json_request(method, path, params)
+        request = build_base_request(method, path)
+        request.body = JSON(params)
+        request['Content-Type'] = 'application/json'
+
+        request
+      end
+
+      # Builds the URI path. It applies the params to the path
+      #
+      # @param [String] path the path with place holders
+      # @param [Array<String>] path_params Array of params to be used as values in the path
+      #
+      # @return [String] the URI path
+      #
+      # @raise ArgumentError when the length of path_params doesn't match the count of placeholders
+      #
+      # @example
+      #   path = "/users/:user_id/profile/:profile_id"
+      #   path_params = [4201, 2]
+      #
+      #   build_path(path, path_params) #=> "/users/4201/profile/2"
+      def self.build_path(path, path_params)
+        matches = path.scan(RE_PATH_PARAM)
+        if matches.length != path_params.length
+          raise PathArgumentError.new(path_params.length, matches.length)
+        end
+
+        matches.each_with_index do |match, index|
+          path = path.sub(match, path_params[index].to_s)
+        end
+
+        path
+      end
+
+      # @param [#code] response
+      def self.severe_error_response?(response)
+        status_code = response.code.to_s
+        SEVERE_STATUS_CODES.include?(status_code)
+      end
+
+    end
+
+  end
+end

data/lib/angus/remote/version.rb

@@ -1,5 +1,7 @@
 module Angus
   module Remote
-    VERSION = "0.0.1"
+
+    VERSION = '0.0.2'
+
   end
-end
+end

data/lib/angus/unmarshalling.rb

@@ -0,0 +1,33 @@
+require 'bigdecimal'
+require 'date'
+
+
+module Angus
+  module Unmarshalling
+
+    def self.unmarshal_scalar(scalar, type)
+      return nil if scalar.nil?
+
+      case type
+      when :string
+        #scalar.force_encoding(Encoding::UTF_8)
+        scalar
+      when :integer
+        scalar
+      when :boolean
+        scalar
+      when :date
+        Date.iso8601(scalar)
+      when :date_time
+        DateTime.iso8601(scalar)
+      when :decimal
+        BigDecimal.new(scalar)
+      when :object
+        scalar
+      else
+        raise ArgumentError, "Unkonwn type: #{type}"
+      end
+    end
+
+  end
+end