class Ubiquity::Wiredrive::API::V3::HTTPClient

Constants

DEFAULT_HTTP_HOST_ADDRESS
DEFAULT_HTTP_HOST_PORT

Attributes

authorization_header_name[RW]
authorization_header_value[RW]
base_uri[RW]
default_request_headers[RW]
hostname[RW]
http[RW]
http_host_address[RW]
http_host_port[RW]
log_pretty_print_body[RW]
log_request_body[RW]
log_response_body[RW]
logger[RW]
password[RW]
request[RW]
response[RW]
username[RW]

Public Class Methods

new(args = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 37
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

Public Instance Methods

auth_token=(value) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 170
def auth_token=(value)
  @auth_token = value
  default_request_headers[authorization_header_name] = @auth_token # "Bearer #{@auth_token}"
end
build_uri(path = '', query = nil) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 154
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
call_method(method_name = :get, args = { }, options = { }) click to toggle source

@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)

# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 183
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
delete(path, options = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 209
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
format_body_for_log_output(obj) click to toggle source

Formats a HTTPRequest or HTTPResponse body for log output. @param [HTTPRequest|HTTPResponse] obj @return [String]

# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 99
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
get(path, query = nil, options = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 224
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
http_host_address=(value) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 69
def http_host_address=(value)
  @http_host_address = value
  initialize_http
end
initialize_http(args = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 84
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
initialize_logger(args = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 74
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
post(path, body, options = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 241
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
put(path, body, options = { }) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 231
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
request_method_name_to_class_name(method_name) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 161
def request_method_name_to_class_name(method_name)
  method_name.to_s.capitalize
end
response_parsed() click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 138
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
send_request(request) click to toggle source

@param [Net::HTTPRequest] request

# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 111
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
sleep_break(seconds) click to toggle source
# File lib/ubiquity/wiredrive/api/v3/http_client.rb, line 130
def sleep_break(seconds)
  while (seconds > 0)
    sleep(1)
    seconds -= 1
    break if @cancelled
  end
end