httpx 0.11.3 → 0.14.0

data/lib/httpx/io/udp.rb

@@ -39,16 +39,20 @@ module HTTPX
       end
     end
 
-    def write(buffer)
-      siz = @io.send(buffer.to_s, 0, @host, @port)
-      log { "WRITE: #{siz} bytes..." }
-      buffer.shift!(siz)
-      siz
-    end
-
     # :nocov:
     if (RUBY_ENGINE == "truffleruby" && RUBY_ENGINE_VERSION < "21.1.0") ||
        RUBY_VERSION < "2.3"
+      def write(buffer)
+        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s))
+        log { "WRITE: #{siz} bytes..." }
+        buffer.shift!(siz)
+        siz
+      rescue ::IO::WaitWritable
+        0
+      rescue EOFError
+        nil
+      end
+
       def read(size, buffer)
         data, _ = @io.recvfrom_nonblock(size)
         buffer.replace(data)
@@ -59,6 +63,18 @@ module HTTPX
       rescue IOError
       end
     else
+
+      def write(buffer)
+        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s), exception: false)
+        return 0 if siz == :wait_writable
+        return if siz.nil?
+
+        log { "WRITE: #{siz} bytes..." }
+
+        buffer.shift!(siz)
+        siz
+      end
+
       def read(size, buffer)
         ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
         return 0 if ret == :wait_readable
@@ -68,6 +84,14 @@ module HTTPX
       rescue IOError
       end
     end
+
+    # In JRuby, sendmsg_nonblock is not implemented
+    def write(buffer)
+      siz = @io.send(buffer.to_s, 0, @host, @port)
+      log { "WRITE: #{siz} bytes..." }
+      buffer.shift!(siz)
+      siz
+    end if RUBY_ENGINE == "jruby"
     # :nocov:
   end
 end

data/lib/httpx/io/unix.rb

@@ -6,34 +6,43 @@ module HTTPX
   class UNIX < TCP
     extend Forwardable
 
-    def_delegator :@uri, :port, :scheme
+    using URIExtensions
 
-    def initialize(uri, addresses, options)
-      @uri = uri
+    attr_reader :path
+
+    alias_method :host, :path
+
+    def initialize(origin, addresses, options)
       @addresses = addresses
+      @hostname = origin.host
       @state = :idle
       @options = Options.new(options)
-      @path = @options.transport_options[:path]
       @fallback_protocol = @options.fallback_protocol
       if @options.io
         @io = case @options.io
               when Hash
-                @options.io[@path]
+                @options.io[origin.authority]
               else
                 @options.io
         end
-        unless @io.nil?
-          @keep_open = true
-          @state = :connected
+        raise Error, "Given IO objects do not match the request authority" unless @io
+
+        @path = @io.path
+        @keep_open = true
+        @state = :connected
+      else
+        if @options.transport_options
+          # :nocov:
+          warn ":#{__method__} is deprecated, use :addresses instead"
+          @path = @options.transport_options[:path]
+          # :nocov:
+        else
+          @path = addresses.first
         end
       end
       @io ||= build_socket
     end
 
-    def hostname
-      @uri.host
-    end
-
     def connect
       return unless closed?
 
@@ -51,6 +60,12 @@ module HTTPX
            ::IO::WaitReadable
     end
 
+    # :nocov:
+    def inspect
+      "#<#{self.class}(path: #{@path}): (state: #{@state})>"
+    end
+    # :nocov:
+
     private
 
     def build_socket

data/lib/httpx/options.rb

@@ -4,13 +4,39 @@ module HTTPX
   class Options
     WINDOW_SIZE = 1 << 14 # 16K
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
+    CONNECT_TIMEOUT = 60
+    OPERATION_TIMEOUT = 60
+    KEEP_ALIVE_TIMEOUT = 20
+
+    DEFAULT_OPTIONS = {
+      :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
+      :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
+      :ssl => {},
+      :http2_settings => { settings_enable_push: 0 },
+      :fallback_protocol => "http/1.1",
+      :timeout => {
+        connect_timeout: CONNECT_TIMEOUT,
+        operation_timeout: OPERATION_TIMEOUT,
+        keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
+      },
+      :headers => {},
+      :window_size => WINDOW_SIZE,
+      :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
+      :request_class => Class.new(Request),
+      :response_class => Class.new(Response),
+      :headers_class => Class.new(Headers),
+      :request_body_class => Class.new(Request::Body),
+      :response_body_class => Class.new(Response::Body),
+      :connection_class => Class.new(Connection),
+      :transport => nil,
+      :transport_options => nil,
+      :addresses => nil,
+      :persistent => false,
+      :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
+      :resolver_options => { cache: true },
+    }.freeze
 
     class << self
-      def inherited(klass)
-        super
-        klass.instance_variable_set(:@defined_options, @defined_options.dup)
-      end
-
       def new(options = {})
         # let enhanced options go through
         return options if self == Options && options.class > self
@@ -19,31 +45,30 @@ module HTTPX
         super
       end
 
-      def defined_options
-        @defined_options ||= []
-      end
+      def def_option(name, layout = nil, &interpreter)
+        attr_reader name
 
-      def def_option(name, &interpreter)
-        defined_options << name.to_sym
+        if layout
+          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+            def #{name}=(value)
+              return if value.nil?
 
-        attr_reader name
+              value = begin
+                #{layout}
+              end
+
+              @#{name} = value
+            end
+          OUT
 
-        if interpreter
+        elsif interpreter
           define_method(:"#{name}=") do |value|
             return if value.nil?
 
             instance_variable_set(:"@#{name}", instance_exec(value, &interpreter))
           end
-
-          define_method(:"with_#{name}") do |value|
-            merge(name => instance_exec(value, &interpreter))
-          end
         else
           attr_writer name
-
-          define_method(:"with_#{name}") do |value|
-            merge(name => value)
-          end
         end
 
         protected :"#{name}="
@@ -51,75 +76,71 @@ module HTTPX
     end
 
     def initialize(options = {})
-      defaults = {
-        :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
-        :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
-        :ssl => {},
-        :http2_settings => { settings_enable_push: 0 },
-        :fallback_protocol => "http/1.1",
-        :timeout => Timeout.new,
-        :headers => {},
-        :window_size => WINDOW_SIZE,
-        :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
-        :request_class => Class.new(Request),
-        :response_class => Class.new(Response),
-        :headers_class => Class.new(Headers),
-        :request_body_class => Class.new(Request::Body),
-        :response_body_class => Class.new(Response::Body),
-        :connection_class => Class.new(Connection),
-        :transport => nil,
-        :transport_options => nil,
-        :persistent => false,
-        :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
-        :resolver_options => { cache: true },
-      }
-
-      defaults.merge!(options)
+      defaults = DEFAULT_OPTIONS.merge(options)
       defaults.each do |(k, v)|
         next if v.nil?
 
-        __send__(:"#{k}=", v)
+        begin
+          __send__(:"#{k}=", v)
+        rescue NoMethodError
+          raise Error, "unknown option: #{k}"
+        end
       end
     end
 
-    def_option(:headers) do |headers|
+    def_option(:origin, <<-OUT)
+      URI(value)
+    OUT
+
+    def_option(:headers, <<-OUT)
       if self.headers
-        self.headers.merge(headers)
+        self.headers.merge(value)
       else
-        Headers.new(headers)
+        Headers.new(value)
       end
-    end
+    OUT
 
-    def_option(:timeout) do |opts|
-      Timeout.new(opts)
-    end
+    def_option(:timeout, <<-OUT)
+      timeouts = Hash[value]
 
-    def_option(:max_concurrent_requests) do |num|
-      raise Error, ":max_concurrent_requests must be positive" unless num.positive?
+      if timeouts.key?(:loop_timeout)
+        warn ":loop_timeout is deprecated, use :operation_timeout instead"
+        timeouts[:operation_timeout] = timeouts.delete(:loop_timeout)
+      end
 
-      num
-    end
+      timeouts
+    OUT
 
-    def_option(:max_requests) do |num|
-      raise Error, ":max_requests must be positive" unless num.positive?
+    def_option(:max_concurrent_requests, <<-OUT)
+      raise Error, ":max_concurrent_requests must be positive" unless value.positive?
 
-      num
-    end
+      value
+    OUT
 
-    def_option(:window_size) do |num|
-      Integer(num)
-    end
+    def_option(:max_requests, <<-OUT)
+      raise Error, ":max_requests must be positive" unless value.positive?
 
-    def_option(:body_threshold_size) do |num|
-      Integer(num)
-    end
+      value
+    OUT
 
-    def_option(:transport) do |tr|
-      transport = tr.to_s
-      raise Error, "#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
+    def_option(:window_size, <<-OUT)
+      Integer(value)
+    OUT
+
+    def_option(:body_threshold_size, <<-OUT)
+      Integer(value)
+    OUT
+
+    def_option(:transport, <<-OUT)
+      transport = value.to_s
+      raise Error, "\#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
 
       transport
-    end
+    OUT
+
+    def_option(:addresses, <<-OUT)
+      Array(value)
+    OUT
 
     %w[
       params form json body ssl http2_settings
@@ -153,6 +174,8 @@ module HTTPX
 
       h1 = to_hash
 
+      return self if h1 == h2
+
       merged = h1.merge(h2) do |k, v1, v2|
         case k
         when :headers, :ssl, :http2_settings, :timeout
@@ -166,10 +189,10 @@ module HTTPX
     end
 
     def to_hash
-      hash_pairs = self.class
-                       .defined_options
-                       .flat_map { |opt_name| [opt_name, send(opt_name)] }
-      Hash[*hash_pairs]
+      hash_pairs = instance_variables.map do |ivar|
+        [ivar[1..-1].to_sym, instance_variable_get(ivar)]
+      end
+      Hash[hash_pairs]
     end
 
     def initialize_dup(other)

data/lib/httpx/parser/http1.rb

@@ -66,7 +66,6 @@ module HTTPX
         @status_code = code.to_i
         raise(Error, "wrong status code (#{@status_code})") unless (100..599).cover?(@status_code)
 
-        # @buffer.slice!(0, idx + 1)
         @buffer = @buffer.byteslice((idx + 1)..-1)
         nextstate(:headers)
       end
@@ -74,7 +73,8 @@ module HTTPX
       def parse_headers
         headers = @headers
         while (idx = @buffer.index("\n"))
-          line = @buffer.slice!(0, idx + 1).sub(/\s+\z/, "")
+          line = @buffer.byteslice(0..idx).sub(/\s+\z/, "")
+          @buffer = @buffer.byteslice((idx + 1)..-1)
           if line.empty?
             case @state
             when :headers
@@ -96,11 +96,11 @@ module HTTPX
           separator_index = line.index(":")
           raise Error, "wrong header format" unless separator_index
 
-          key = line[0..separator_index - 1]
+          key = line.byteslice(0..(separator_index - 1))
           raise Error, "wrong header format" if key.start_with?("\s", "\t")
 
           key.strip!
-          value = line[separator_index + 1..-1]
+          value = line.byteslice((separator_index + 1)..-1)
           value.strip!
           raise Error, "wrong header format" if value.nil?
 

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin applies AWS Sigv4 to requests, using the AWS SDK credentials and configuration.
+    #
+    # It requires the "aws-sdk-core" gem.
+    #
+    module AwsSdkAuthentication
+      #
+      # encapsulates access to an AWS SDK credentials store.
+      #
+      class Credentials
+        def initialize(aws_credentials)
+          @aws_credentials = aws_credentials
+        end
+
+        def username
+          @aws_credentials.access_key_id
+        end
+
+        def password
+          @aws_credentials.secret_access_key
+        end
+
+        def security_token
+          @aws_credentials.session_token
+        end
+      end
+
+      class << self
+        attr_reader :credentials, :region
+
+        def load_dependencies(_klass)
+          require "aws-sdk-core"
+
+          client = Class.new(Seahorse::Client::Base) do
+            @identifier = :httpx
+            set_api(Aws::S3::ClientApi::API)
+            add_plugin(Aws::Plugins::CredentialsConfiguration)
+            add_plugin(Aws::Plugins::RegionalEndpoint)
+            class << self
+              attr_reader :identifier
+            end
+          end.new
+
+          @credentials = Credentials.new(client.config[:credentials])
+          @region = client.config[:region]
+        end
+
+        def configure(klass)
+          klass.plugin(:aws_sigv4)
+        end
+
+        def extra_options(options)
+          options.merge(max_concurrent_requests: 1)
+        end
+      end
+
+      module InstanceMethods
+        #
+        # aws_authentication
+        # aws_authentication(credentials: Aws::Credentials.new('akid', 'secret'))
+        # aws_authentication()
+        #
+        def aws_sdk_authentication(**options)
+          credentials = AwsSdkAuthentication.credentials
+          region = AwsSdkAuthentication.region
+
+          aws_sigv4_authentication(
+            credentials: credentials,
+            region: region,
+            provider_prefix: "aws",
+            header_provider_field: "amz",
+            **options
+          )
+        end
+        alias_method :aws_auth, :aws_sdk_authentication
+      end
+    end
+    register_plugin :aws_sdk_authentication, AwsSdkAuthentication
+  end
+end