httpx 0.0.1

data/lib/httpx/io.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+require "ipaddr"
+
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader :ip, :port
+
+    def initialize(hostname, port, options)
+      @state = :idle
+      @options = Options.new(options)
+      @fallback_protocol = @options.fallback_protocol
+      @port = port
+      if @options.io
+        @io = case @options.io
+              when Hash
+                @ip = TCPSocket.getaddress(hostname)
+                @options.io[@ip] || @options.io["#{@ip}:#{@port}"]
+              else
+                @ip = hostname
+                @options.io
+        end
+        unless @io.nil?
+          @keep_open = true
+          @state = :connected
+        end
+      else
+        @ip = TCPSocket.getaddress(hostname)
+      end
+      @io ||= build_socket
+    end
+
+    def scheme
+      "http"
+    end
+
+    def to_io
+      @io.to_io
+    end
+
+    def protocol
+      @fallback_protocol
+    end
+
+    def connect
+      return unless closed?
+      begin
+        if @io.closed?
+          transition(:idle)
+          @io = build_socket
+        end
+        @io.connect_nonblock(Socket.sockaddr_in(@port, @ip))
+      rescue Errno::EISCONN
+      end
+      transition(:connected)
+    rescue Errno::EINPROGRESS,
+           Errno::EALREADY,
+           ::IO::WaitReadable
+    end
+
+    if RUBY_VERSION < "2.3"
+      def read(size, buffer)
+        @io.read_nonblock(size, buffer)
+        buffer.bytesize
+      rescue ::IO::WaitReadable
+        0
+      rescue EOFError
+        nil
+      end
+
+      def write(buffer)
+        siz = @io.write_nonblock(buffer)
+        buffer.slice!(0, siz)
+        siz
+      rescue ::IO::WaitWritable
+        0
+      rescue EOFError
+        nil
+      end
+    else
+      def read(size, buffer)
+        ret = @io.read_nonblock(size, buffer, exception: false)
+        return 0 if ret == :wait_readable
+        return if ret.nil?
+        buffer.bytesize
+      end
+
+      def write(buffer)
+        siz = @io.write_nonblock(buffer, exception: false)
+        return 0 if siz == :wait_writable
+        return if siz.nil?
+        buffer.slice!(0, siz)
+        siz
+      end
+    end
+
+    def close
+      return if @keep_open || closed?
+      begin
+        @io.close
+      ensure
+        transition(:closed)
+      end
+    end
+
+    def connected?
+      @state == :connected
+    end
+
+    def closed?
+      @state == :idle || @state == :closed
+    end
+
+    def inspect
+      id = @io.closed? ? "closed" : @io.fileno
+      "#<TCP(fd: #{id}): #{@ip}:#{@port} (state: #{@state})>"
+    end
+
+    private
+
+    def build_socket
+      addr = IPAddr.new(@ip)
+      Socket.new(addr.family, :STREAM, 0)
+    end
+
+    def transition(nextstate)
+      case nextstate
+      # when :idle
+      when :connected
+        return unless @state == :idle
+      when :closed
+        return unless @state == :connected
+      end
+      log(1, "#{inspect}: ") { nextstate.to_s }
+      @state = nextstate
+    end
+  end
+
+  class SSL < TCP
+    TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
+      { alpn_protocols: %w[h2 http/1.1] }
+    else
+      {}
+    end
+
+    def initialize(_, _, options)
+      @ctx = OpenSSL::SSL::SSLContext.new
+      ctx_options = TLS_OPTIONS.merge(options.ssl)
+      @ctx.set_params(ctx_options) unless ctx_options.empty?
+      super
+      @state = :negotiated if @keep_open
+    end
+
+    def scheme
+      "https"
+    end
+
+    def protocol
+      @io.alpn_protocol || super
+    rescue StandardError
+      super
+    end
+
+    def close
+      super
+      # allow reconnections
+      # connect only works if initial @io is a socket
+      @io = @io.io if @io.respond_to?(:io)
+      @negotiated = false
+    end
+
+    def connect
+      super
+      if @keep_open
+        @state = :negotiated
+        return
+      end
+      return if @state == :negotiated ||
+                @state != :connected
+      @io = OpenSSL::SSL::SSLSocket.new(@io, @ctx)
+      @io.hostname = @hostname
+      @io.sync_close = true
+      @io.connect
+      transition(:negotiated)
+    end
+
+    if RUBY_VERSION < "2.3"
+      def read(*)
+        super
+      rescue ::IO::WaitWritable
+        0
+      end
+
+      def write(*)
+        super
+      rescue ::IO::WaitReadable
+        0
+      end
+    else
+      if OpenSSL::VERSION < "2.0.6"
+        def read(size, buffer)
+          @io.read_nonblock(size, buffer)
+          buffer.bytesize
+        rescue ::IO::WaitReadable,
+               ::IO::WaitWritable
+          0
+        rescue EOFError
+          nil
+        end
+      end
+    end
+
+    def inspect
+      id = @io.closed? ? "closed" : @io.to_io.fileno
+      "#<SSL(fd: #{id}): #{@ip}:#{@port} state: #{@state}>"
+    end
+
+    private
+
+    def transition(nextstate)
+      case nextstate
+      when :negotiated
+        return unless @state == :connected
+      when :closed
+        return unless @state == :negotiated ||
+                      @state == :connected
+      end
+      super
+    end
+  end
+  module IO
+    extend Registry
+    register "tcp", TCP
+    register "ssl", SSL
+  end
+end

data/lib/httpx/loggable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Loggable
+    def log(level = @options.debug_level, label = "", &msg)
+      return unless @options.debug
+      return unless @options.debug_level >= level
+      @options.debug << (+label << msg.call << "\n")
+    end
+  end
+end

data/lib/httpx/options.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Options
+    MAX_CONCURRENT_REQUESTS = 100
+    MAX_RETRIES = 3
+    WINDOW_SIZE = 1 << 14 # 16K
+    MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
+
+    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
+        return options if options.is_a?(self)
+        super
+      end
+
+      def defined_options
+        @defined_options ||= []
+      end
+
+      def def_option(name, &interpreter)
+        defined_options << name.to_sym
+        interpreter ||= ->(v) { v }
+
+        attr_accessor name
+        protected :"#{name}="
+
+        define_method(:"with_#{name}") do |value|
+          dup { |opts| opts.send(:"#{name}=", instance_exec(value, &interpreter)) }
+        end
+      end
+    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                  => {},
+        :max_concurrent_requests  => MAX_CONCURRENT_REQUESTS,
+        :max_retries              => MAX_RETRIES,
+        :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),
+      }
+
+      defaults.merge!(options)
+      defaults[:headers] = Headers.new(defaults[:headers])
+      defaults.each { |(k, v)| self[k] = v }
+    end
+
+    def_option(:headers) do |headers|
+      self.headers.merge(headers)
+    end
+
+    def_option(:timeout) do |opts|
+      self.timeout = Timeout.new(opts)
+    end
+
+    def_option(:max_concurrent_requests) do |num|
+      max = Integer(num)
+      raise Error, ":max_concurrent_requests must be positive" unless max.positive?
+      self.max_concurrent_requests = max
+    end
+
+    def_option(:window_size) do |num|
+      self.window_size = Integer(num)
+    end
+
+    def_option(:body_threshold_size) do |num|
+      self.body_threshold_size = Integer(num)
+    end
+
+    %w[
+      params form json body
+      follow ssl http2_settings max_retries
+      request_class response_class headers_class request_body_class response_body_class
+      io fallback_protocol debug debug_level
+    ].each do |method_name|
+      def_option(method_name)
+    end
+
+    def merge(other)
+      h1 = to_hash
+      h2 = other.to_hash
+
+      merged = h1.merge(h2) do |k, v1, v2|
+        case k
+        when :headers, :ssl, :http2_settings, :timeout
+          v1.merge(v2)
+        else
+          v2
+        end
+      end
+
+      self.class.new(merged)
+    end
+
+    def to_hash
+      hash_pairs = self.class
+                       .defined_options
+                       .flat_map { |opt_name| [opt_name, send(opt_name)] }
+      Hash[*hash_pairs]
+    end
+
+    def dup
+      dupped = super
+      dupped.headers             = headers.dup
+      dupped.ssl                 = ssl.dup
+      dupped.request_class       = request_class.dup
+      dupped.response_class      = response_class.dup
+      dupped.headers_class       = headers_class.dup
+      dupped.request_body_class  = request_body_class.dup
+      dupped.response_body_class = response_body_class.dup
+      yield(dupped) if block_given?
+      dupped
+    end
+
+    protected
+
+    def []=(option, val)
+      send(:"#{option}=", val)
+    end
+  end
+end

data/lib/httpx/plugins/authentication.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Authentication
+      module InstanceMethods
+        def authentication(token)
+          headers("authorization" => token)
+        end
+      end
+    end
+    register_plugin :authentication, Authentication
+  end
+end

data/lib/httpx/plugins/basic_authentication.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module BasicAuthentication
+      def self.load_dependencies(klass, *)
+        require "base64"
+        klass.plugin(:authentication)
+      end
+
+      module InstanceMethods
+        def basic_authentication(user, password)
+          authentication("Basic #{Base64.strict_encode64("#{user}:#{password}")}")
+        end
+        alias_method :basic_auth, :basic_authentication
+      end
+    end
+    register_plugin :basic_authentication, BasicAuthentication
+  end
+end

data/lib/httpx/plugins/compression.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Compression
+      extend Registry
+      def self.configure(klass, *)
+        klass.plugin(:"compression/gzip")
+        klass.plugin(:"compression/deflate")
+      end
+
+      module InstanceMethods
+        def initialize(opts = {})
+          super(opts.merge(headers: { "accept-encoding" => Compression.registry.keys }))
+        end
+      end
+
+      module RequestBodyMethods
+        def initialize(*)
+          super
+          return if @body.nil?
+          @headers.get("content-encoding").each do |encoding|
+            @body = Encoder.new(@body, Compression.registry(encoding).encoder)
+          end
+          @headers["content-length"] = @body.bytesize unless chunked?
+        end
+      end
+
+      module ResponseBodyMethods
+        def initialize(*)
+          super
+          @_decoders = @headers.get("content-encoding").map do |encoding|
+            Compression.registry(encoding).decoder
+          end
+          @_compressed_length = if @headers.key?("content-length")
+            @headers["content-length"].to_i
+          else
+            Float::INFINITY
+          end
+        end
+
+        def write(chunk)
+          @_compressed_length -= chunk.bytesize
+          chunk = decompress(chunk)
+          super(chunk)
+        end
+
+        def close
+          super
+          @_decoders.each(&:close)
+        end
+
+        private
+
+        def decompress(buffer)
+          @_decoders.reverse_each do |decoder|
+            buffer = decoder.decode(buffer)
+            buffer << decoder.finish if @_compressed_length <= 0
+          end
+          buffer
+        end
+      end
+
+      class Encoder
+        def initialize(body, deflater)
+          @body = body.respond_to?(:read) ? body : StringIO.new(body.to_s)
+          @buffer = StringIO.new("".b, File::RDWR)
+          @deflater = deflater
+        end
+
+        def each(&blk)
+          return enum_for(__method__) unless block_given?
+          unless @buffer.size.zero?
+            @buffer.rewind
+            return @buffer.each(&blk)
+          end
+          deflate(&blk)
+        end
+
+        def bytesize
+          deflate
+          @buffer.size
+        end
+
+        def to_s
+          deflate
+          @buffer.rewind
+          @buffer.read
+        end
+
+        def close
+          @buffer.close
+          @body.close
+        end
+
+        private
+
+        def deflate(&blk)
+          return unless @buffer.size.zero?
+          @body.rewind
+          @deflater.deflate(@body, @buffer, chunk_size: 16_384, &blk)
+        end
+      end
+
+      class Decoder
+        extend Forwardable
+
+        def_delegator :@inflater, :finish
+
+        def_delegator :@inflater, :close
+
+        def initialize(inflater)
+          @inflater = inflater
+        end
+
+        def decode(chunk)
+          @inflater.inflate(chunk)
+        end
+      end
+    end
+    register_plugin :compression, Compression
+  end
+end