ubiquity-wiredrive 1.0.0

data/lib/ubiquity/wiredrive/api/v3/client/requests.rb

@@ -0,0 +1,3 @@
+# module Ubiquity::Wiredrive::API::V3::Client::Requests end
+
+require 'ubiquity/wiredrive/api/v3/client/requests/base_request'

data/lib/ubiquity/wiredrive/api/v3/client/requests/base_request.rb

@@ -0,0 +1,238 @@
+require 'cgi'
+
+module Ubiquity
+  module Wiredrive
+    module API
+      module V3
+        class Client
+          class Requests
+            class BaseRequest
+
+              HTTP_METHOD       = :get
+              HTTP_BASE_PATH    = ''
+              HTTP_PATH         = ''
+              HTTP_SUCCESS_CODE = 200
+
+              DEFAULT_PARAMETER_SEND_IN_VALUE = :query
+
+              PARAMETERS = []
+
+              attr_accessor :client, :arguments, :options, :initial_arguments, :initial_options, :missing_required_arguments,
+                            :default_parameter_send_in_value, :processed_parameters, :initialized, :response
+
+              attr_writer :parameters, :path, :body, :query
+
+              def self.normalize_argument_hash_keys(hash)
+                return hash unless hash.is_a?(Hash)
+                Hash[hash.dup.map { |k, v| [normalize_parameter_name(k), v] }]
+              end
+
+              def self.normalize_parameter_name(name)
+                (name || '').respond_to?(:to_s) ? name.to_s.gsub('_', '').gsub('-', '').downcase : name
+              end
+
+              def self.process_parameter(param, args = {}, args_out = {}, missing_required_arguments = [], processed_parameters = {}, default_parameter_send_in_value = DEFAULT_PARAMETER_SEND_IN_VALUE, options = {})
+                args = normalize_argument_hash_keys(args) || {} if options.fetch(:normalize_argument_hash_keys, false)
+
+                _k           = param.is_a?(Hash) ? param : { :name => param, :required => false, :send_in => default_parameter_send_in_value }
+                _k[:send_in] ||= default_parameter_send_in_value
+
+                proper_parameter_name = _k[:name]
+                param_name            = normalize_parameter_name(proper_parameter_name)
+                arg_key               = (has_key = args.has_key?(param_name)) ?
+                    param_name :
+                    ((_k[:aliases] || []).map { |a| normalize_parameter_name(a) }.find { |a| has_key = args.has_key?(a) } || param_name)
+
+                value  = has_key ? args[arg_key] : _k[:default_value]
+                is_set = has_key || _k.has_key?(:default_value)
+
+                processed_parameters[proper_parameter_name] = _k.merge(:value => value, :is_set => is_set)
+
+                unless is_set
+                  missing_required_arguments << proper_parameter_name if _k[:required]
+                else
+                  args_out[proper_parameter_name] = value
+                end
+
+                { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+              rescue => e
+                raise e, "Error Processing Parameter: #{param.inspect} Args: #{args.inspect}. #{e.message}"
+              end
+
+              def self.process_parameters(params, args, options = {})
+                args                            = normalize_argument_hash_keys(args) || {}
+                args_out                        = options[:arguments_out] || {}
+                default_parameter_send_in_value = options[:default_parameter_send_in_value] || DEFAULT_PARAMETER_SEND_IN_VALUE
+                processed_parameters            = options[:processed_parameters] || {}
+                missing_required_arguments      = options[:missing_required_arguments] || []
+
+                params.each do |param|
+                  process_parameter(param, args, args_out, missing_required_arguments, processed_parameters, default_parameter_send_in_value)
+                end
+                { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+              end
+
+              def initialize(args = {}, options = {})
+                @initial_arguments = args.dup
+                @initial_options   = options.dup
+
+                @options = options.dup
+
+                initialize_attributes if options.fetch(:initialize_attributes, true)
+                after_initialize
+              end
+
+              def after_initialize
+                process_parameters if initialized
+              end
+
+              def initialize_attributes
+                @client                          = options[:client]
+                @missing_required_arguments      = []
+                @default_parameter_send_in_value = options[:default_parameter_send_in_value] || self.class::DEFAULT_PARAMETER_SEND_IN_VALUE
+                @processed_parameters            = {}
+                @arguments                       = {}
+                @eval_http_path                  = options.fetch(:eval_http_path, true)
+                @base_path                       = options[:base_path]
+
+                @parameters  = options[:parameters]
+                @http_method = options[:http_method]
+                @http_path   = options[:http_path] ||= options[:path_raw]
+
+                @path           = options[:path]
+                @path_arguments = nil
+                @path_only      = nil
+
+                @query           = options[:query]
+                @query_arguments = nil
+
+                @body           = options[:body]
+                @body_arguments = nil
+
+                @response = nil
+
+                @http_success_code = options[:http_success_code] || HTTP_SUCCESS_CODE
+
+                @initialized = true
+              end
+
+              alias :reset_attributes :initialize_attributes
+
+              def process_parameters(params = parameters, args = @initial_arguments, _options = @options)
+                before_process_parameters unless _options.fetch(:skip_before_process_parameters, false)
+                self.class.process_parameters(params, args, _options.merge(:processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments, :default_parameter_send_in_value => default_parameter_send_in_value, :arguments_out => arguments))
+                after_process_parameters unless _options.fetch(:skip_after_process_parameters, false)
+              end
+
+              def before_process_parameters
+                # TO BE IMPLEMENTED IN CHILD CLASS
+              end
+
+              def after_process_parameters
+                # TO BE IMPLEMENTED IN CHILD CLASS
+              end
+
+              alias :post_process_arguments :after_process_parameters
+
+              # @!group Attribute Readers
+
+              def http_success_code
+                @http_success_code
+              end
+
+              def arguments
+                @arguments ||= {}
+              end
+
+              def base_path
+                @base_path ||= self.class::HTTP_BASE_PATH
+              end
+
+              def body_arguments
+                @body_arguments ||= arguments.dup.delete_if { |k, _| processed_parameters[k][:send_in] != :body }
+              end
+
+              def body
+                @body ||= body_arguments.empty? ? nil : body_arguments
+              end
+
+              def client
+                @client ||= options[:client]
+              end
+
+              def eval_http_path?
+                @eval_http_path
+              end
+
+              def http_path
+                @http_path ||= self.class::HTTP_PATH
+              end
+
+              def http_method
+                @http_method ||= self.class::HTTP_METHOD
+              end
+
+              def parameters
+                @parameters ||= self.class::PARAMETERS.dup
+              end
+
+              def relative_path
+                @relative_path ||= (path.start_with?('/') ? path[1..-1] : path)
+              end
+
+              # The URI Path
+              def path
+                @path ||= File.join(base_path, (eval_http_path? ? eval(%("#{http_path}"), binding, __FILE__, __LINE__) : http_path))
+              end
+
+              def path_arguments
+                @path_arguments ||= Hash[
+                    arguments.dup.delete_if { |k, _| processed_parameters[k][:send_in] != :path }.
+                        map { |k, v| [k, CGI.escape(v.respond_to?(:to_s) ? v.to_s : '').gsub('+', '%20')] }
+                ]
+              end
+
+              def query
+                @query ||= begin
+                  query_arguments.is_a?(Hash) ? query_arguments.map { |k, v| "#{CGI.escape(k.to_s).gsub('+', '%20')}=#{CGI.escape([*v].join(',')).gsub('+', '%20')}" }.join('&') : query_arguments
+                end
+              end
+
+              def query_arguments
+                @query_arguments ||= arguments.dup.delete_if { |k, _| processed_parameters[k][:send_in] != :query }
+              end
+
+              def uri_request_path
+                [path].concat([*query].delete_if { |v| v.respond_to?(:empty?) and v.empty? }).join('?')
+              end
+
+              # @!endgroup
+
+              # def response
+              #   client.response if client
+              # end
+
+              def http_client
+                client.http_client
+              end
+
+              def http_response
+                @http_response ||= http_client.response.dup rescue nil
+              end
+
+              def execute
+                @response = http_client.call_method(http_method, { :path => relative_path, :query => query, :body => body }, options) if client
+              end
+
+              def success?
+                _response = http_response and ([*http_success_code].include?(http_response.code))
+                _response
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquity/wiredrive/api/v3/http_client.rb

@@ -0,0 +1,256 @@
+require 'cgi'
+require 'json'
+require 'logger'
+require 'net/http'
+require 'net/https'
+require 'net/http/post/multipart'
+
+require 'ubiquity/wiredrive/version'
+
+module Ubiquity
+  module Wiredrive
+    module API
+      module V3
+        class HTTPClient
+
+          class RateLimitException < StandardError; end
+
+          # Ruby uses all lower case headers but Jetty uses case sensitive headers
+          class CaseSensitiveHeaderKey < String
+            def downcase; self end
+            def capitalize; self end
+          end
+
+
+          attr_accessor :logger, :http, :http_host_address, :http_host_port, :base_uri
+          attr_accessor :hostname, :username, :password
+
+          attr_accessor :default_request_headers, :authorization_header_name, :authorization_header_value
+
+          attr_accessor :log_request_body, :log_response_body, :log_pretty_print_body
+
+          attr_accessor :request, :response
+
+          DEFAULT_HTTP_HOST_ADDRESS = 'api.wiredrive.com'
+          DEFAULT_HTTP_HOST_PORT = 443
+
+          def initialize(args = { })
+            args = args.dup
+            initialize_logger(args)
+
+            @http_host_address = args[:http_host_address] ||= DEFAULT_HTTP_HOST_ADDRESS
+            @http_host_port = args[:http_host_port] ||= DEFAULT_HTTP_HOST_PORT
+
+            initialize_http(args)
+
+            @user_agent_default = "Ubiquity Wiredrive Ruby SDK Version #{Ubiquity::Wiredrive::VERSION}"
+
+            @authorization_header_name = 'Authorization' # CaseSensitiveHeaderKey.new('Authorization')
+            @authorization_header_value = nil # @auth_token # "Bearer #{@auth_token}"
+
+            @default_request_headers = {
+              'user-agent' => @user_agent_default,
+              'Content-Type' => 'application/json; charset=utf-8',
+              'Accept' => 'application/json',
+            }
+
+            _auth_token = args[:auth_token]
+            self.auth_token = _auth_token if _auth_token
+
+            @log_request_body = args.fetch(:log_request_body, true)
+            @log_response_body = args.fetch(:log_response_body, true)
+            @log_pretty_print_body = args.fetch(:log_pretty_print_body, true)
+
+            @cancelled = false
+            @delay_between_rate_limit_retries = 5
+            @parse_response = args.fetch(:parse_response, true)
+          end
+
+          def http_host_address=(value)
+            @http_host_address = value
+            initialize_http
+          end
+
+          def initialize_logger(args = { })
+            @logger = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+            log_level = args[:log_level]
+            if log_level
+              @logger.level = log_level
+              args[:logger] = @logger
+            end
+            @logger
+          end
+
+          def initialize_http(args = { })
+            @http = Net::HTTP.new(http_host_address, http_host_port)
+            http.use_ssl = true
+
+            # TODO Add SSL Patch
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+            @base_uri = args[:base_uri] || "http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}/"
+
+            http
+          end
+
+          # Formats a HTTPRequest or HTTPResponse body for log output.
+          # @param [HTTPRequest|HTTPResponse] obj
+          # @return [String]
+          def format_body_for_log_output(obj)
+            case obj.content_type
+              when 'application/json'
+                return obj.body unless @log_pretty_print_body
+                _body = obj.body
+                JSON.pretty_generate(JSON.parse(_body)) rescue _body
+              when 'application/xml'; obj.body
+              else obj.body.inspect
+            end
+          end
+
+          # @param [Net::HTTPRequest] request
+          def send_request(request)
+            @response_parsed = nil
+            @request = request
+
+            begin
+              logger.debug { %(REQUEST: #{request.method} http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}#{request.path} HEADERS: #{request.to_hash.inspect} #{log_request_body and request.request_body_permitted? ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(request)}\n-- BODY END --" : ''}) }
+
+              @response = http.request(request)
+              logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(response)}\n-- BODY END--" : ''}) }
+              raise RateLimitException, "#{response.to_hash.inspect}" if response.code == '420'
+            rescue RateLimitException => e
+              logger.warn { "Rate Limited. Will retry in #{@delay_between_rate_limit_retries} seconds." }
+              sleep_break @delay_between_rate_limit_retries
+              retry unless @cancelled
+            end
+
+            @parse_response ? response_parsed : response.body
+          end
+
+          def sleep_break(seconds)
+            while (seconds > 0)
+              sleep(1)
+              seconds -= 1
+              break if @cancelled
+            end
+          end
+
+          def response_parsed
+            @response_parsed ||= begin
+              response_content_type = response.content_type
+              logger.debug { "Parsing Response: #{response_content_type}" }
+
+              case response_content_type
+                when 'application/json'
+                  JSON.parse(response.body) rescue response
+                # when 'text/html'
+                # when 'text/plain'
+                else
+                  response.body
+              end
+            end
+          end
+
+          def build_uri(path = '', query = nil)
+            _query = query.is_a?(Hash) ? query.map { |k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v)}" }.join('&') : query
+            _path = "#{path}#{_query and _query.respond_to?(:empty?) and !_query.empty? ? "?#{_query}" : ''}"
+            URI.parse(File.join(base_uri, _path))
+          end
+
+          if RUBY_VERSION.start_with? '1.8.'
+            def request_method_name_to_class_name(method_name)
+              method_name.to_s.capitalize
+            end
+          else
+            def request_method_name_to_class_name(method_name)
+              method_name.to_s.capitalize.to_sym
+            end
+          end
+
+          def auth_token=(value)
+            @auth_token = value
+            default_request_headers[authorization_header_name] = @auth_token # "Bearer #{@auth_token}"
+          end
+
+          # @param [Symbol] method_name (:get)
+          # @param [Hash] args
+          # @option args [Hash] :headers ({})
+          # @option args [String] :path ('')
+          # @option args [Hash] :query ({})
+          # @option args [Any] :body (nil)
+          # @param [Hash] options
+          # @option options [Hash] :default_request_headers (@default_request_headers)
+          def call_method(method_name = :get, args = { }, options = { })
+            headers = args[:headers] || options[:headers] || { }
+            path = args[:path] || ''
+            query = args[:query] || { }
+            body = args[:body]
+
+            # Allow the default request headers to be overridden
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers)
+            _default_request_headers ||= { }
+            _headers = _default_request_headers.merge(headers)
+
+            @uri = build_uri(path, query)
+            klass_name = request_method_name_to_class_name(method_name)
+            klass = Net::HTTP.const_get(klass_name)
+
+            request = klass.new(@uri.request_uri, _headers)
+
+            if request.request_body_permitted?
+              _body = (body and !body.is_a?(String)) ? JSON.generate(body) : body
+              logger.debug { "Processing Body: '#{_body}'" }
+              request.body = _body if _body
+            end
+
+            send_request(request)
+          end
+
+          def delete(path, options = { })
+            query = options.fetch(:query, { })
+            @uri = build_uri(path, query)
+
+
+            request = Net::HTTP::Delete.new(@uri.request_uri, default_request_headers)
+            body = options[:body]
+            if body
+              body = JSON.generate(body) unless body.is_a?(String)
+              request.body = body
+            end
+
+            send_request(request)
+          end
+
+          def get(path, query = nil, options = { })
+            query ||= options.fetch(:query, { })
+            @uri = build_uri(path, query)
+            request = Net::HTTP::Get.new(@uri.request_uri, default_request_headers)
+            send_request(request)
+          end
+
+          def put(path, body, options = { })
+            query = options.fetch(:query, { })
+            @uri = build_uri(path, query)
+            body = JSON.generate(body) unless body.is_a?(String)
+
+            request = Net::HTTP::Put.new(@uri.request_uri, default_request_headers)
+            request.body = body
+            send_request(request)
+          end
+
+          def post(path, body, options = { })
+            query = options.fetch(:query, { })
+            @uri = build_uri(path, query)
+            body = JSON.generate(body) unless body.is_a?(String)
+
+            request = Net::HTTP::Post.new(@uri.request_uri, default_request_headers)
+            request.body = body
+            send_request(request)
+          end
+
+        end
+
+      end
+    end
+  end
+end