rest_requestor 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c16e96223b812472703d763390c9795e11058d2c27a78d35c317a8ef8a53f2e
+  data.tar.gz: 96250ea144fb1e39f0f4621a92519eb0fec001cedf50ed82eaf670bc49517a28
+SHA512:
+  metadata.gz: 43f6a99dece90901df0b5413eb83e08a128fb77fddbd5d0674df82af223c3752d84dbeb665146e0aa96aae0c64a26b870ced5ab31d9b9a635298b41f708838a4
+  data.tar.gz: 6cd37575e2d8e1c6fa17b4f7754f05d9791eb9612d0e8a40e883356c442d7f425034b38d0667a7208aa4f0b1ee1256a76df83c2ab7add13d96d37a3175e8ddfa

data/lib/rest_requestor/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+class RestRequestor
+  module Config
+    # Each tier holds candidate paths; the first found in a tier is used for that tier.
+    # Tiers are merged least-to-most-specific, so project settings override env-explicit,
+    # which override home/global settings. Settings absent from a more-specific tier are
+    # inherited from less-specific ones.
+    CONFIG_TIERS = [
+      # Tier 1 — home/global (least specific)
+      [
+        -> { ENV["XDG_CONFIG_HOME"]&.then { |d| File.join(d, "rest_requestor", "config.yml") } },
+        -> { File.join(Dir.home, ".config", "rest_requestor", "config.yml") },
+        -> { File.join(Dir.home, ".rest_requestor_config.yml") }
+      ],
+      # Tier 2 — explicit path via environment variable
+      [
+        -> { (v = ENV["REST_REQUESTOR_CONFIG"]) && !v.empty? ? v : nil }
+      ],
+      # Tier 3 — project-local (most specific)
+      [
+        -> { File.join(Dir.pwd, "config", "rest_requestor_config.yml") }
+      ]
+    ].freeze
+
+    def self.load
+      CONFIG_TIERS.each_with_object({}) do |tier, result|
+        data = first_in_tier(tier)
+        result.merge!(parse(data)) if data
+      end
+    end
+
+    def self.parse(data)
+      result = {}
+
+      if (raw_ua = data["user_agent"] || data[:user_agent])
+        sanitized = raw_ua.to_s.gsub(/[^A-Za-z0-9_\-]/, "_")
+        result[:user_agent] = "#{sanitized}/#{VERSION}"
+      end
+
+      if (v = data["max_retries"] || data[:max_retries])
+        n = v.to_i
+        result[:max_retries] = n if n > 0
+      end
+
+      %i[open_timeout read_timeout].each do |key|
+        if (v = data[key.to_s] || data[key])
+          n = v.to_f
+          result[key] = n if n > 0
+        end
+      end
+
+      result
+    end
+
+    def self.first_in_tier(locations)
+      locations.each do |location|
+        path = location.call
+        next unless path && File.exist?(path)
+        begin
+          data = YAML.safe_load(File.read(path))
+          return data if data.is_a?(Hash)
+        rescue ::StandardError
+          next
+        end
+      end
+      nil
+    end
+    private_class_method :first_in_tier
+  end
+end

data/lib/rest_requestor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RestRequestor
+  VERSION = "0.4.0"
+end

data/lib/rest_requestor.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "openssl"
+require_relative "rest_requestor/version"
+require_relative "rest_requestor/config"
+
+class RestRequestor
+  class StandardError < StandardError
+    def initialize(uri, verb, resp, params = {}, msg: nil)
+      body = if resp["Content-Type"]&.include?("text/html")
+        if (m = resp.body.to_s.match(/<title>(.*)<\/title>/))
+          m[1]
+        else
+          resp.body.to_s[0..20]
+        end
+      else
+        resp.body.to_s
+      end
+      msg ||= "uri: #{uri}, Verb: #{verb}, Resp: #{resp.code} - #{resp.message}, Body: #{body}, Params: #{params}"
+      super(msg)
+    end
+  end
+
+  class RateLimitError < StandardError; end
+  class NotFoundError < StandardError; end
+  class ServiceUnavailableError < StandardError; end
+  class TooManyRedirectsError < ::StandardError; end
+
+  attr_reader :resp, :elapsed, :options
+
+  OPTION_DEFAULTS = {
+    max_retries: 7,
+    open_timeout: 10,
+    read_timeout: 30,
+    proxy_address: "127.0.0.1",
+    proxy_port: 9090,
+    user_agent: nil,
+    skip_proxy: true,
+    logger: nil
+  }
+
+  FILE_CONFIG = Config.load.freeze
+
+  # Shared across instances; cert store is immutable after setup
+  def self.ssl_cert_store
+    @ssl_cert_store ||= begin
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      # Prevent failures when CRL distribution points are unreachable
+      store.flags = OpenSSL::X509::V_FLAG_PARTIAL_CHAIN
+      store
+    end
+  end
+
+  def initialize(**kw_args)
+    @options = OPTION_DEFAULTS.merge(FILE_CONFIG).merge(kw_args)
+    warn_no_user_agent if options[:user_agent].to_s.strip.empty?
+  end
+
+  def request(uri, verb, j_params: {}, f_hash: {}, q_params: {}, auth: nil, headers: {}, body: nil, retries: 0)
+    unless [:get, :post, :put, :delete, :patch, :head].include?(verb)
+      raise ArgumentError, "Verb must be one of :get, :post, :put, :delete, :patch, :head — got #{verb.inspect}"
+    end
+    uri = add_query_string(uri, q_params) if q_params && !q_params.empty?
+
+    exec_req(uri, verb, j_params, f_hash, auth, headers, body)
+
+    case resp.code.to_i
+    when (200...300)
+      return resp.code.to_i if verb == :head
+      if resp["Content-Type"]&.include?("application/json")
+        JSON.parse(resp.body)
+      elsif resp.code.to_i == 200 && !resp.body.to_s.strip.empty?
+        begin
+          JSON.parse(resp.body.to_s)
+        rescue JSON::ParserError
+          200
+        end
+      else
+        resp.code.to_i
+      end
+    when 404 then raise NotFoundError.new(uri, verb, resp, j_params)
+    when 429
+      # Caller must handle rate limits — retry semantics vary per service
+      raise RateLimitError.new(uri, verb, resp, j_params)
+    when 503
+      if retries <= options[:max_retries]
+        retries += 1
+        waitfor = retry_delay(retries)
+        options[:logger]&.info { "Retrying (#{retries}), pausing #{waitfor} seconds" }
+        sleep waitfor
+        # q_params already incorporated into uri above; omit here to avoid double-encoding
+        request(uri, verb, j_params: j_params, f_hash: f_hash, auth: auth, headers: headers, body: body, retries: retries)
+      else
+        raise ServiceUnavailableError.new(uri, verb, resp, j_params)
+      end
+    else
+      raise StandardError.new(uri, verb, resp, j_params)
+    end
+  end
+
+  def resolve_redirects(url, limit = 10)
+    uri = URI.parse(url)
+
+    limit.times do
+      http = build_http(uri)
+      req = Net::HTTP::Head.new(uri.request_uri)
+      req["User-Agent"] = options[:user_agent] unless options[:user_agent].to_s.strip.empty?
+      response = http.request(req)
+      return uri.to_s unless response.is_a?(Net::HTTPRedirection)
+
+      uri = URI.join(uri, response["location"])
+    end
+
+    raise TooManyRedirectsError, "Too many redirects resolving #{url}"
+  end
+
+  private
+
+  def warn_no_user_agent
+    msg = "[RestRequestor] No user_agent set — many APIs require one. " \
+          "Pass user_agent: \"YourApp/1.0\" to the initializer or set it in a config file."
+    options[:logger]&.warn(msg)
+    Kernel.warn(msg)
+  end
+
+  def retry_delay(retries)
+    # Approx seconds: 1~2.5, 2~7.5, 3~17.5, 4~37.5, 5~77.5, 6~157.5, 7~317.3
+    2**retries + rand(0..(2**retries / 2.0))
+  end
+
+  def add_query_string(uri, q_params)
+    separator = uri.include?("?") ? "&" : "?"
+    uri + separator + URI.encode_www_form(q_params)
+  end
+
+  def build_http(uri_obj)
+    http = if proxy_alive?
+      Net::HTTP.new(uri_obj.host, uri_obj.port, options[:proxy_address], options[:proxy_port])
+    else
+      Net::HTTP.new(uri_obj.host, uri_obj.port)
+    end
+
+    if uri_obj.scheme == "https"
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.cert_store = self.class.ssl_cert_store
+      http.min_version = OpenSSL::SSL::TLS1_2_VERSION
+    end
+
+    http.open_timeout = options[:open_timeout]
+    http.read_timeout = options[:read_timeout]
+    http
+  end
+
+  def exec_req(uri, verb, j_params, f_hash, auth, headers, body)
+    uri_obj = URI(uri)
+    http = build_http(uri_obj)
+
+    request_class = case verb
+    when :get    then Net::HTTP::Get
+    when :post   then Net::HTTP::Post
+    when :put    then Net::HTTP::Put
+    when :delete then Net::HTTP::Delete
+    when :patch  then Net::HTTP::Patch
+    when :head   then Net::HTTP::Head
+    end
+
+    request_path = uri_obj.path
+    request_path += "?#{uri_obj.query}" if uri_obj.query
+    request_path = "/" if request_path.empty?
+
+    req = request_class.new(request_path)
+    req["User-Agent"] = options[:user_agent] unless options[:user_agent].to_s.strip.empty?
+
+    headers.each { |key, value| req[key.to_s] = value }
+
+    if !auth.nil?
+      if auth.is_a?(String) && !auth.strip.empty?
+        req["Authorization"] = auth
+      elsif auth.is_a?(Array) && auth.length == 2
+        req.basic_auth(*auth)
+      elsif auth.is_a?(Hash) && auth.keys.length == 2
+        # Assumes two-key {user:, password:} shape; order determines which is which
+        req.basic_auth(*auth.values)
+      elsif auth.respond_to?(:call)
+        auth_header = auth.call
+        req["Authorization"] = auth_header if auth_header
+      end
+    end
+
+    if !j_params.nil? && !j_params.empty?
+      req["Content-Type"] = "application/json"
+      req.body = j_params.to_json
+    elsif !f_hash.nil? && !f_hash.empty?
+      req.set_form_data(f_hash)
+    elsif !body.nil?
+      req.body = body
+    end
+
+    r_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @resp = http.request(req)
+    r_end = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @elapsed = r_end - r_start
+
+    @resp
+  end
+
+  def proxy_alive?(refresh: false)
+    remove_instance_variable(:@proxy_alive) if refresh
+    return @proxy_alive if defined?(@proxy_alive)
+
+    if options[:skip_proxy] || %w[1 true yes].include?(ENV["REST_REQUESTOR_SKIP_PROXY"].to_s.downcase)
+      return @proxy_alive = false
+    end
+
+    begin
+      uri = URI("https://httpbin.org/ip")
+      http = Net::HTTP.new(uri.host, uri.port, options[:proxy_address], options[:proxy_port])
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.cert_store = self.class.ssl_cert_store
+      http.min_version = OpenSSL::SSL::TLS1_2_VERSION
+      http.open_timeout = 5
+      http.read_timeout = 5
+      http.request(Net::HTTP::Head.new("/"))
+      @proxy_alive = true
+    rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, OpenSSL::SSL::SSLError
+      @proxy_alive = false
+    end
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: rest_requestor
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Scott Wright
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Wraps Net::HTTP with JSON handling, exponential backoff on 503 errors,
+  optional proxy support, and typed error classes.
+email:
+- scott@wrightzone.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rest_requestor.rb
+- lib/rest_requestor/config.rb
+- lib/rest_requestor/version.rb
+homepage: https://codeberg.org/jswright61/rest_requestor
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: HTTP client with retry support, proxy awareness, and structured errors
+test_files: []