class NetHTTP::Client

Attributes

ca_file[R]
cert[R]
client[R]
key[R]
logger[R]
open_timeout[R]
pkcs12[R]
pkcs12_file[R]
pkcs12_passphrase[R]
proxy_from_env[R]
proxy_uri[R]
proxy_url[R]
query[R]
read_timeout[R]
response[R]
ssl_path[R]
uri[R]
url[R]
use_proxy[R]
use_ssl[R]
verify_mode[R]

Public Class Methods

new(opts = {}) click to toggle source
# File lib/client/client.rb, line 34
def initialize(opts = {})
  send('logger=', opts[:logger])
  schema_results = Core.schema_validation(opts, NetHTTP::Client::Schema.new) unless opts[:enforce_schema_validation] == false
  unless schema_results.nil?
    logger.debug("NetHTTP::Client::SchemaError -> #{schema_results}")
    raise NetHTTP::Client::SchemaError.new(schema_results.to_s)
  end

  send('uri=', opts)
  send('proxy_uri=', opts)
  send('client=', opts)
end

Public Instance Methods

ca_file=(ca_file) click to toggle source
# File lib/client/ext.rb, line 54
def ca_file=(ca_file)
  if ca_file.nil? || ca_file.to_s.empty?
    @ca_file = nil
  elsif ssl_path.nil? || ssl_path.to_s.empty?
    @ca_file = nil
  else
    @ca_file = File.binread(ssl_path + '/' + ca_file)
  end
end
call_web_service(request_opts = {}) click to toggle source
# File lib/request/request.rb, line 9
def call_web_service(request_opts = {})
  @response = case request_opts[:method].to_s.upcase
              when 'DELETE'
                delete(request_opts)
              when 'GET'
                get(request_opts)
              when 'POST'
                post(request_opts)
              when 'POST_FORM', 'POST_FORM_DATA'
                post_form(request_opts)
              when 'PUT'
                put(request_opts)
              else
                logger.debug("Request method => '#{request_opts[:method]}' not yet supported.")
                raise "Request method => '#{request_opts[:method]}' not yet supported."
              end

  @response
end
cert=() click to toggle source
# File lib/client/ext.rb, line 64
def cert=
  if pkcs12.nil? || pkcs12.to_s.empty?
    @cert = nil
  else
    @cert = OpenSSL::X509::Certificate.new(pkcs12.certificate)
  end
end
client=(opts = {}) click to toggle source
# File lib/client/client.rb, line 47
def client=(opts = {})
  if proxy_uri
    @client = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port).new(uri.host, uri.port)
  else
    @client = Net::HTTP.new(uri.host, uri.port)
  end

  send('proxy_from_env=', opts[:proxy_from_env])
  send('open_timeout=', (opts[:open_timeout] || 60))
  send('read_timeout=', (opts[:read_timeout] || 60))
  send('use_ssl=', opts[:use_ssl], uri.scheme)
  send('ssl_path=', opts[:ssl_path])
  send('pkcs12_file=', opts[:pkcs12_file])
  send('pkcs12_passphrase=', opts[:pkcs12_passphrase])
  send('pkcs12=')
  send('cert=')
  send('key=')
  send('ca_file=', opts[:ca_file])
  send('verify_mode=', opts[:verify_mode])

  @client.proxy_from_env = proxy_from_env
  @client.open_timeout = open_timeout
  @client.read_timeout = read_timeout
  @client.use_ssl = use_ssl
  if use_ssl
    @client.cert = cert
    @client.key = key
    @client.ca_file = ca_file
    @client.verify_mode = verify_mode
  end
end
delete(opts = {}) click to toggle source
# File lib/request/request.rb, line 29
def delete(opts = {})
  raise 'Empty DELETE request options provided.' if opts.empty?

  opts[:method] = 'delete'
  request_opts = request_opts(opts)
  path = if request_opts[:query]
           request_opts[:path] + request_opts[:query]
         else
           request_opts[:path]
         end

  logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
  logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
  logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
  logger.debug('Request Path => ' + path)
  logger.debug('Request Headers =>')
  logger.debug(Hash[request_opts[:headers].to_h.map { |k, v| [k.to_s, v] }])
  NetHTTP::Response.new(
    response: client.delete(
      path
    ),
    logger: logger
  )
end
get(opts = {}) click to toggle source
# File lib/request/request.rb, line 54
def get(opts = {})
  raise 'Empty GET request options provided.' if opts.empty?

  opts[:method] = 'get'
  request_opts = request_opts(opts)
  path = if request_opts[:query]
           request_opts[:path] + request_opts[:query]
         else
           request_opts[:path]
         end

  logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
  logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
  logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
  logger.debug('Request Path => ' + path)
  logger.debug('Request Headers =>')
  logger.debug(Hash[request_opts[:headers].to_h.map { |k, v| [k.to_s, v] }])
  NetHTTP::Response.new(
    response: client.get(
      path,
      request_opts[:headers]
    ),
    logger: logger
  )
end
key=() click to toggle source
# File lib/client/ext.rb, line 72
def key=
  if pkcs12.nil? || pkcs12.to_s.empty?
    @key = nil
  else
    @key = OpenSSL::PKey::RSA.new(pkcs12.key)
  end
end
logger=(logger = nil) click to toggle source
# File lib/client/client.rb, line 81
def logger=(logger = nil)
  @logger = Core.get_logger(logger)
end
open_timeout=(open_timeout) click to toggle source
# File lib/client/ext.rb, line 80
def open_timeout=(open_timeout)
  @open_timeout = open_timeout.to_s.to_i
end
pkcs12=() click to toggle source
# File lib/client/ext.rb, line 84
def pkcs12=
  if ssl_path.nil? || ssl_path.to_s.empty?
    @pkcs12 = nil
  elsif pkcs12_file.nil? || pkcs12_file.to_s.empty?
    @pkcs12 = nil
  elsif pkcs12_passphrase.nil? || pkcs12_passphrase.to_s.empty?
    @pkcs12 = nil
  else
    @pkcs12 = OpenSSL::PKCS12.new(File.binread(ssl_path + '/' + pkcs12_file), pkcs12_passphrase)
  end
end
pkcs12_file=(pkcs12_file) click to toggle source
# File lib/client/ext.rb, line 96
def pkcs12_file=(pkcs12_file)
  if pkcs12_file.nil? || pkcs12_file.to_s.empty?
    @pkcs12_file = nil
  else
    @pkcs12_file = pkcs12_file
  end
end
pkcs12_passphrase=(pkcs12_passphrase) click to toggle source
# File lib/client/ext.rb, line 104
def pkcs12_passphrase=(pkcs12_passphrase)
  if pkcs12_passphrase.nil? || pkcs12_passphrase.to_s.empty?
    @pkcs12_passphrase = nil
  else
    @pkcs12_passphrase = pkcs12_passphrase
  end
end
post(opts = {}) click to toggle source
# File lib/request/request.rb, line 80
def post(opts = {})
  raise 'Empty POST request options provided.' if opts.empty?

  opts[:method] = 'post'
  request_opts = request_opts(opts)
  path = if request_opts[:query]
           request_opts[:path] + request_opts[:query]
         else
           request_opts[:path]
         end

  logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
  logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
  logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
  logger.debug('Request Path => ' + path)
  logger.debug('Request Headers =>')
  logger.debug(Hash[request_opts[:headers].to_h.map { |k, v| [k.to_s, v] }])
  logger.debug('Request Body =>')
  logger.debug(request_opts[:body])
  NetHTTP::Response.new(
    response: client.post(
      path,
      request_opts[:body],
      request_opts[:headers]
    ),
    logger: logger
  )
end
post_form(opts = {}) click to toggle source
# File lib/request/request.rb, line 109
def post_form(opts = {})
  raise 'Empty POST_FORM request options provided.' if opts.empty?

  opts[:method] = 'post_form'
  request_opts = request_opts(opts)
  path = if request_opts[:query]
           request_opts[:path] + request_opts[:query]
         else
           request_opts[:path]
         end

  logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
  logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
  logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
  logger.debug('Request Path => ' + path)
  logger.debug('Request Headers =>')
  logger.debug(Hash[request_opts[:headers].to_h.map { |k, v| [k.to_s, v] }])
  logger.debug('Request Body =>')
  logger.debug(URI.encode_www_form(request_opts[:body]))
  NetHTTP::Response.new(
    response: client.post(
      path,
      URI.encode_www_form(request_opts[:body]),
      request_opts[:headers]
    ),
    logger: logger
  )
end
Also aliased as: post_form_data
post_form_data(opts = {})
Alias for: post_form
proxy_from_env=(proxy_from_env) click to toggle source
# File lib/client/ext.rb, line 112
def proxy_from_env=(proxy_from_env)
  if proxy_from_env == true
    @proxy_from_env = true
  else
    @proxy_from_env = false
  end
end
proxy_uri=(opts = {}) click to toggle source
# File lib/client/ext.rb, line 5
def proxy_uri=(opts = {})
  proxy_uri = opts[:proxy_uri] || opts[:proxy_url]

  begin
    if proxy_uri.to_s.empty? == false
      @proxy_uri = Core::Utilities.parse_uri(proxy_uri)
    else
      @proxy_uri = Core::Utilities.parse_uri(
        Core::Utilities.construct_uri(
          scheme: opts[:proxy_uri_scheme],
          user: opts[:proxy_uri_user],
          password: opts[:proxy_uri_password],
          host: opts[:proxy_uri_host],
          port: opts[:proxy_uri_port],
          path: opts[:proxy_uri_path],
          query: opts[:proxy_uri_query]
        )
      )
    end
  rescue RuntimeError => err
    logger.debug(err)
    @proxy_uri = nil
  end
end
put(opts = {}) click to toggle source
# File lib/request/request.rb, line 140
def put(opts = {})
  raise 'Empty PUT request options provided.' if opts.empty?

  opts[:method] = 'put'
  request_opts = request_opts(opts)
  path = if request_opts[:query]
           request_opts[:path] + request_opts[:query]
         else
           request_opts[:path]
         end

  logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
  logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
  logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
  logger.debug('Request Path => ' + path)
  logger.debug('Request Headers =>')
  logger.debug(Hash[request_opts[:headers].to_h.map { |k, v| [k.to_s, v] }])
  logger.debug('Request Body =>')
  logger.debug(request_opts[:body])
  NetHTTP::Response.new(
    response: client.put(
      path,
      request_opts[:body],
      request_opts[:headers]
    ),
    logger: logger
  )
end
read_timeout=(read_timeout) click to toggle source
# File lib/client/ext.rb, line 120
def read_timeout=(read_timeout)
  @read_timeout = read_timeout.to_s.to_i
end
request_opts(opts) click to toggle source
# File lib/request/request.rb, line 169
def request_opts(opts)
  schema_results = Core.schema_validation(opts, NetHTTP::Request::Schema.new) unless opts[:enforce_schema_validation] == false
  unless schema_results.nil?
    logger.debug("NetHTTP::Request::SchemaError -> #{schema_results}")
    raise NetHTTP::Request::SchemaError.new(schema_results.to_s)
  end

  request_method = opts[:method] || 'post'
  request_uri = Core::Utilities.parse_uri(opts[:uri] || opts[:url] || uri)
  request_path = (opts[:path] || request_uri.path || path).chomp('?')
  request_query = Core::Utilities.parse_query((opts[:query] || request_uri.query || query))
  request_headers = opts[:headers] || {}
  request_body = opts[:body] || nil

  {
    method: request_method,
    uri: request_uri,
    path: request_path,
    query: request_query,
    headers: request_headers,
    body: request_body
  }
end
ssl_path=(ssl_path) click to toggle source
# File lib/client/ext.rb, line 124
def ssl_path=(ssl_path)
  if ssl_path.nil? || ssl_path.to_s.empty?
    @ssl_path = nil
  else
    @ssl_path = ssl_path
  end
end
uri=(opts = {}) click to toggle source
# File lib/client/ext.rb, line 30
def uri=(opts = {})
  uri = opts[:uri] || opts[:url]
  begin
    if uri.to_s.empty? == false
      @uri = Core::Utilities.parse_uri(uri)
    else
      @uri = Core::Utilities.parse_uri(
        Core::Utilities.construct_uri(
          scheme: opts[:scheme],
          user: opts[:user],
          password: opts[:password],
          host: opts[:host],
          port: opts[:port],
          path: opts[:path],
          query: opts[:query]
        )
      )
    end
  rescue RuntimeError => err
    logger.debug(err)
    @uri = nil
  end
end
use_ssl=(use_ssl, scheme) click to toggle source
# File lib/client/ext.rb, line 132
def use_ssl=(use_ssl, scheme)
  @use_ssl = true
  case use_ssl
  when false
    @use_ssl = false
  when true
    @use_ssl = true
  else
    case scheme.downcase
    when 'http'
      @use_ssl = false
    when 'https'
      @use_ssl = true
    end
  end
end
verify_mode=(verify_mode) click to toggle source
# File lib/client/ext.rb, line 149
def verify_mode=(verify_mode)
  if verify_mode.nil? || verify_mode.to_s.empty?
    @verify_mode = OpenSSL::SSL::VERIFY_NONE
  else
    @verify_mode = verify_mode
  end
end