ubiquity-wiredrive 1.0.0

data/lib/ubiquity/wiredrive/api/v2/client/paginator.rb

@@ -0,0 +1,134 @@
+class Ubiquity::Wiredrive::API::V3::Client::Paginator
+
+  attr_accessor :api_client
+
+  attr_reader :total_results, :last_page_number, :next_page_number, :prev_page_number, :page_size
+
+  def initialize(api_client)
+    @api_client = api_client
+
+    process_response
+  end
+
+  def logger
+    api_client.logger
+  end
+
+  def http_client
+    api_client.http_client
+  end
+
+  def process_response
+    http_response = http_client.response
+
+    @total_results = http_response['total']
+    @paginated = !!total_results
+
+    process_link_header(http_response['links']) if paginated?
+  end
+
+  def process_link_header(link)
+    links = link.split(',')
+    @next_page_number = nil
+    @prev_page_number = nil
+
+    links.map! do |k, v|
+      # href, rel = l.split('; ')
+      # rel = rel.match(/"(\w*)/)[1]
+      # href = href.match(/<(.*)>/)[1]
+      # _, query = href.split('?')
+      # query_as_hash = Hash[ query.split('&').map { |v| v.split('=') } ]
+      # @page_size = query_as_hash['_pageSize']
+      #
+      # case rel
+      #   when 'next'
+      #     @next_page_number = query_as_hash['_page']
+      #     @next_page_href = href
+      #   when 'last'
+      #     @last_page_number = query_as_hash['_page']
+      #     @last_page_href = href
+      #   when 'prev'
+      #     @prev_page_number = query_as_hash['_page']
+      #     @prev_page_href = href
+      # end
+      #
+      # [ rel, href ]
+      [ k, v ]
+    end
+    @has_next_page = !!@next_page_number
+    @has_prev_page = !!@prev_page_number
+
+    Hash[links]
+  end
+
+  def request
+    @request ||= api_client.request
+  end
+
+  def request_args_out
+    @request_args_out ||= request.initial_arguments.dup
+  end
+
+  def request_options_out
+    @request_options_out ||= { :client => api_client }.merge request.initial_options.dup
+  end
+
+  def paginated?
+    @paginated
+  end
+
+  def next_page?
+    @has_next_page
+  end
+
+  def next_page_get(_next_page_number = @next_page_number)
+    page_get(_next_page_number)
+  end
+
+  def page_get(page_number)
+    logger.debug { "Getting Page #{page_number} of #{last_page_number}" }
+    new_request = request.class.new(request_args_out.merge('_page' => page_number), request_options_out)
+    _response = new_request.execute
+    process_response
+    _response
+  end
+
+  def pages_get(pages, options = { })
+    consolidate = options.fetch(:consolidate, true)
+    pages = pages.to_a if pages.respond_to?(:to_a)
+    pages_out = pages.map { |v| page_get(v) }
+    pages_out.flatten! if consolidate
+    pages_out
+  end
+
+  def prev_page?
+    @has_prev_page
+  end
+
+  def prev_page_get(_prev_page_number = @prev_page_number)
+    return [ ] unless paginated?
+    page_get(_prev_page_number)
+  end
+
+  def include_remaining_pages
+    response = api_client.response.dup
+    response.concat(remaining_pages_get)
+  end
+
+  def remaining_pages_get
+    return [ ] unless paginated? && next_page?
+    _next_page_number = @next_page_number
+    remaining_results = [ ]
+
+    loop do
+      response = next_page_get(_next_page_number)
+      break unless response.is_a?(Array)
+      remaining_results.concat(response)
+
+      break unless next_page?
+      _next_page_number = next_page_number
+    end
+    remaining_results
+  end
+
+end

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

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

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

@@ -0,0 +1,225 @@
+require 'cgi'
+
+class Ubiquity::Wiredrive::API::V2::Client::Requests::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
+

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

@@ -0,0 +1,246 @@
+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 V2
+        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
+
+          attr_accessor :log_request_body, :log_response_body, :log_pretty_print_body
+
+          attr_accessor :request, :response
+
+          DEFAULT_HTTP_HOST_ADDRESS = 'api.wiredrive.rc'
+          DEFAULT_HTTP_HOST_PORT = 443
+
+          def initialize(args = { })
+            args = args.dup
+            initialize_logger(args)
+            initialize_http(args)
+
+            @auth_token = args[:auth_token]
+            @base_uri = args[:base_uri] || "http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}/v2/"
+
+            @user_agent_default = "Ubiquity Wiredrive Ruby SDK Version #{Ubiquity::Wiredrive::VERSION}"
+
+            authorization_header_name = CaseSensitiveHeaderKey.new('Authorization')
+            authorization_header_value = "Bearer #{@auth_token}"
+
+
+            @default_request_headers = {
+                'user-agent' => @user_agent_default,
+                'Content-Type' => 'application/json; charset=utf-8',
+                'Accept' => 'application/json',
+                authorization_header_name => authorization_header_value,
+            }
+
+            @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
+            @parse_response = args.fetch(:parse_response, true)
+          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_host_address = args[:http_host_address] ||= DEFAULT_HTTP_HOST_ADDRESS
+            @http_host_port = args[:http_host_port] ||= DEFAULT_HTTP_HOST_PORT
+            @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
+
+            http
+          end
+
+          # Formats a HTTPRequest or HTTPResponse body for log output.
+          # @param [HTTPRequest|HTTPResponse] obj
+          # @return [String]
+          def format_body_for_log_output(obj)
+            if obj.content_type == 'application/json'
+              if @log_pretty_print_body
+                _body = obj.body
+                output = "\n" << JSON.pretty_generate(JSON.parse(_body)) rescue _body
+                return output
+              else
+                return obj.body
+              end
+            else
+              return 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? ? "BODY: #{format_body_for_log_output(request)}" : ''}) }
+
+              @response = http.request(request)
+              logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? "BODY: #{format_body_for_log_output(response)}" : ''}) }
+              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
+
+          # @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