httpx 0.3.1 → 0.4.0

data/lib/httpx/{client.rb → session.rb}

@@ -1,45 +1,47 @@
 # frozen_string_literal: true
 
 module HTTPX
-  class Client
+  class Session
     include Loggable
     include Chainable
 
     def initialize(options = {}, &blk)
       @options = self.class.default_options.merge(options)
-      @connection = Connection.new(@options)
       @responses = {}
-      @keep_open = false
+      @persistent = @options.persistent
       wrap(&blk) if block_given?
     end
 
     def wrap
       return unless block_given?
+
       begin
-        prev_keep_open = @keep_open
-        @keep_open = true
+        prev_persistent = @persistent
+        @persistent = true
         yield self
       ensure
-        @keep_open = prev_keep_open
-        close
+        @persistent = prev_persistent
       end
     end
 
-    def close
-      @connection.close
+    def close(*args)
+      pool.close(*args)
     end
 
-    def request(*args, keep_open: @keep_open, **options)
-      requests = __build_reqs(*args, **options)
-      responses = __send_reqs(*requests, **options)
+    def request(*args, **options)
+      requests = build_requests(*args, options)
+      responses = send_requests(*requests, options)
       return responses.first if responses.size == 1
+
       responses
-    ensure
-      close unless keep_open
     end
 
     private
 
+    def pool
+      Thread.current[:httpx_connection_pool] ||= Pool.new
+    end
+
     def on_response(request, response)
       @responses[request] = response
     end
@@ -49,55 +51,54 @@ module HTTPX
       stream.refuse
     end
 
-    def fetch_response(request)
+    def fetch_response(request, _, _)
       @responses.delete(request)
     end
 
-    def find_channel(request, **options)
+    def find_connection(request, connections, options)
       uri = URI(request.uri)
-      @connection.find_channel(uri) || build_channel(uri, options)
+      connection = pool.find_connection(uri, options) || build_connection(uri, options)
+      unless connections.nil? || connections.include?(connection)
+        connections << connection
+        set_connection_callbacks(connection, options)
+      end
+      connection
     end
 
-    def set_channel_callbacks(channel, options)
-      channel.on(:response, &method(:on_response))
-      channel.on(:promise, &method(:on_promise))
-      channel.on(:uncoalesce) do |uncoalesced_uri|
-        other_channel = build_channel(uncoalesced_uri, options)
-        channel.unmerge(other_channel)
+    def set_connection_callbacks(connection, options)
+      connection.on(:uncoalesce) do |uncoalesced_uri|
+        other_connection = build_connection(uncoalesced_uri, options)
+        connection.unmerge(other_connection)
       end
-      channel.on(:altsvc) do |alt_origin, origin, alt_params|
-        build_altsvc_channel(channel, alt_origin, origin, alt_params, options)
+      connection.on(:altsvc) do |alt_origin, origin, alt_params|
+        build_altsvc_connection(connection, alt_origin, origin, alt_params, options)
       end
     end
 
-    def build_channel(uri, options)
-      channel = @connection.build_channel(uri, **options)
-      set_channel_callbacks(channel, options)
-      channel
-    end
-
-    def build_altsvc_channel(existing_channel, alt_origin, origin, alt_params, options)
+    def build_altsvc_connection(existing_connection, alt_origin, origin, alt_params, options)
       altsvc = AltSvc.cached_altsvc_set(origin, alt_params.merge("origin" => alt_origin))
 
       # altsvc already exists, somehow it wasn't advertised, probably noop
       return unless altsvc
 
-      channel = @connection.find_channel(alt_origin) || build_channel(alt_origin, options)
+      connection = pool.find_connection(alt_origin, options) || build_connection(alt_origin, options)
       # advertised altsvc is the same origin being used, ignore
-      return if channel == existing_channel
+      return if connection == existing_connection
+
+      set_connection_callbacks(connection, options)
 
       log(level: 1) { "#{origin} alt-svc: #{alt_origin}" }
 
       # get uninitialized requests
       # incidentally, all requests will be re-routed to the first
       # advertised alt-svc, which incidentally follows the spec.
-      existing_channel.purge_pending do |request, args|
+      existing_connection.purge_pending do |request|
         is_idle = request.origin == origin &&
                   request.state == :idle &&
                   !request.headers.key?("alt-used")
         if is_idle
           log(level: 1) { "#{origin} alt-svc: sending #{request.uri} to #{alt_origin}" }
-          channel.send(request, args)
+          connection.send(request)
         end
         is_idle
       end
@@ -105,57 +106,92 @@ module HTTPX
       altsvc["noop"] = true
     end
 
-    def __build_reqs(*args, **options)
+    def build_requests(*args, options)
+      request_options = @options.merge(options)
+
       requests = case args.size
                  when 1
                    reqs = args.first
                    reqs.map do |verb, uri|
-                     __build_req(verb, uri, options)
+                     build_request(verb, uri, request_options)
                    end
                  when 2, 3
                    verb, uris = args
                    if uris.respond_to?(:each)
                      uris.map do |uri, **opts|
-                       __build_req(verb, uri, options.merge(opts))
+                       build_request(verb, uri, request_options.merge(opts))
                      end
                    else
-                     [__build_req(verb, uris, options)]
+                     [build_request(verb, uris, request_options)]
                    end
                  else
                    raise ArgumentError, "unsupported number of arguments"
       end
       raise ArgumentError, "wrong number of URIs (given 0, expect 1..+1)" if requests.empty?
+
       requests
     end
 
-    def __send_reqs(*requests, **options)
+    def build_connection(uri, options)
+      type = options.transport || begin
+        case uri.scheme
+        when "http"
+          "tcp"
+        when "https"
+          "ssl"
+        when "h2"
+          options = options.merge(ssl: { alpn_protocols: %w[h2] })
+          "ssl"
+        else
+          raise UnsupportedSchemeError, "#{uri}: #{uri.scheme}: unsupported URI scheme"
+        end
+      end
+      connection = options.connection_class.new(type, uri, options)
+      pool.init_connection(connection, options)
+      connection
+    end
+
+    def send_requests(*requests, options)
+      connections = []
+      request_options = @options.merge(options)
+      timeout = request_options.timeout
+
       requests.each do |request|
-        channel = find_channel(request, **options)
-        channel.send(request)
+        connection = find_connection(request, connections, request_options)
+        connection.send(request)
       end
+
       responses = []
 
-      # guarantee ordered responses
-      loop do
-        begin
-          request = requests.first
-          @connection.next_tick until (response = fetch_response(request))
+      begin
+        # guarantee ordered responses
+        loop do
+          begin
+            request = requests.first
+            pool.next_tick(timeout) until (response = fetch_response(request, connections, request_options))
 
-          responses << response
-          requests.shift
+            responses << response
+            requests.shift
 
-          break if requests.empty? || !@connection.running?
+            break if requests.empty? || pool.empty?
+          end
         end
+        responses
+      ensure
+        close(connections) unless @persistent
       end
-      responses
     end
 
-    def __build_req(verb, uri, options = {})
+    def build_request(verb, uri, options)
       rklass = @options.request_class
-      rklass.new(verb, uri, @options.merge(options))
+      request = rklass.new(verb, uri, @options.merge(options))
+      request.on(:response, &method(:on_response).curry[request])
+      request.on(:promise, &method(:on_promise))
+      request
     end
 
     @default_options = Options.new
+    @default_options.freeze
     @plugins = []
 
     class << self
@@ -163,7 +199,7 @@ module HTTPX
 
       def inherited(klass)
         super
-        klass.instance_variable_set(:@default_options, @default_options.dup)
+        klass.instance_variable_set(:@default_options, @default_options)
         klass.instance_variable_set(:@plugins, @plugins.dup)
       end
 
@@ -173,15 +209,13 @@ module HTTPX
         unless @plugins.include?(pl)
           @plugins << pl
           pl.load_dependencies(self, *args, &block) if pl.respond_to?(:load_dependencies)
+          @default_options = @default_options.dup
+          @default_options = pl.extra_options(@default_options) if pl.respond_to?(:extra_options)
+
           include(pl::InstanceMethods) if defined?(pl::InstanceMethods)
           extend(pl::ClassMethods) if defined?(pl::ClassMethods)
-          if defined?(pl::OptionsMethods) || defined?(pl::OptionsClassMethods)
-            options_klass = Class.new(@default_options.class)
-            options_klass.extend(pl::OptionsClassMethods) if defined?(pl::OptionsClassMethods)
-            options_klass.__send__(:include, pl::OptionsMethods) if defined?(pl::OptionsMethods)
-            @default_options = options_klass.new
-          end
-          opts = default_options
+
+          opts = @default_options
           opts.request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
           opts.request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
           opts.response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
@@ -192,7 +226,10 @@ module HTTPX
           opts.request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
           opts.response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
           opts.response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
+          opts.connection_class.__send__(:include, pl::ConnectionMethods) if defined?(pl::ConnectionMethods)
           pl.configure(self, *args, &block) if pl.respond_to?(:configure)
+
+          @default_options.freeze
         end
         self
       end

data/lib/httpx/timeout.rb

@@ -9,6 +9,7 @@ module HTTPX
 
     def self.new(opts = {})
       return opts if opts.is_a?(Timeout)
+
       super
     end
 
@@ -26,12 +27,10 @@ module HTTPX
         @operation_timeout = loop_timeout
       end
       reset_counter
-      @state = :idle # this is here not to trigger the log
-      transition(:idle)
     end
 
-    def timeout
-      @timeout || @total_timeout
+    def total_timeout
+      @total_timeout
     ensure
       log_time
     end
@@ -63,16 +62,8 @@ module HTTPX
       end
     end
 
-    def transition(nextstate)
-      return if @state == nextstate
-      case nextstate
-      # when :idle
-      when :idle
-        @timeout = @connect_timeout
-      when :open
-        @timeout = @operation_timeout
-      end
-      @state = nextstate
+    def no_time_left?
+      @time_left <= 0
     end
 
     private
@@ -88,8 +79,9 @@ module HTTPX
     def log_time
       return unless @time_left
       return reset_timer unless @started
+
       @time_left -= (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started)
-      raise TimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds") if @time_left <= 0
+      raise TotalTimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds") if no_time_left?
 
       reset_timer
     end

data/lib/httpx/transcoder/body.rb

@@ -4,6 +4,8 @@ require "forwardable"
 
 module HTTPX::Transcoder
   module Body
+    Error = Class.new(HTTPX::Error)
+
     module_function
 
     class Encoder
@@ -22,6 +24,8 @@ module HTTPX::Transcoder
           @raw.map(&:bytesize).reduce(0, :+)
         elsif @raw.respond_to?(:size)
           @raw.size || Float::INFINITY
+        elsif @raw.respond_to?(:length)
+          @raw.length || Float::INFINITY
         elsif @raw.respond_to?(:each)
           Float::INFINITY
         else

data/lib/httpx/transcoder/chunker.rb

@@ -18,6 +18,7 @@ module HTTPX::Transcoder
 
       def each
         return enum_for(__method__) unless block_given?
+
         @raw.each do |chunk|
           yield "#{chunk.bytesize.to_s(16)}#{CRLF}#{chunk}#{CRLF}"
         end
@@ -57,6 +58,7 @@ module HTTPX::Transcoder
           when :length
             index = @buffer.index(CRLF)
             return unless index && index.positive?
+
             # Read hex-length
             hexlen = @buffer.slice!(0, index)
             hexlen[/\h/] || raise(Error, "wrong chunk size line: #{hexlen}")
@@ -69,11 +71,13 @@ module HTTPX::Transcoder
             # consume CRLF
             return if @buffer.bytesize < crlf_size
             raise Error, "wrong chunked encoding format" unless @buffer.start_with?(CRLF * (crlf_size / 2))
+
             @buffer.slice!(0, crlf_size)
             if @chunk_length.nil?
               nextstate(:length)
             else
               return if @finished
+
               nextstate(:data)
             end
           when :data

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-27 00:00:00.000000000 Z
+date: 2019-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -68,15 +68,14 @@ files:
 - LICENSE.txt
 - README.md
 - lib/httpx.rb
+- lib/httpx/adapters/faraday.rb
 - lib/httpx/altsvc.rb
 - lib/httpx/buffer.rb
 - lib/httpx/callbacks.rb
 - lib/httpx/chainable.rb
-- lib/httpx/channel.rb
-- lib/httpx/channel/http1.rb
-- lib/httpx/channel/http2.rb
-- lib/httpx/client.rb
 - lib/httpx/connection.rb
+- lib/httpx/connection/http1.rb
+- lib/httpx/connection/http2.rb
 - lib/httpx/errors.rb
 - lib/httpx/extensions.rb
 - lib/httpx/headers.rb
@@ -99,13 +98,16 @@ files:
 - lib/httpx/plugins/follow_redirects.rb
 - lib/httpx/plugins/h2c.rb
 - lib/httpx/plugins/multipart.rb
+- lib/httpx/plugins/persistent.rb
 - lib/httpx/plugins/proxy.rb
 - lib/httpx/plugins/proxy/http.rb
 - lib/httpx/plugins/proxy/socks4.rb
 - lib/httpx/plugins/proxy/socks5.rb
+- lib/httpx/plugins/proxy/ssh.rb
 - lib/httpx/plugins/push_promise.rb
 - lib/httpx/plugins/retries.rb
 - lib/httpx/plugins/stream.rb
+- lib/httpx/pool.rb
 - lib/httpx/registry.rb
 - lib/httpx/request.rb
 - lib/httpx/resolver.rb
@@ -116,6 +118,7 @@ files:
 - lib/httpx/resolver/system.rb
 - lib/httpx/response.rb
 - lib/httpx/selector.rb
+- lib/httpx/session.rb
 - lib/httpx/timeout.rb
 - lib/httpx/transcoder.rb
 - lib/httpx/transcoder/body.rb
@@ -142,8 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: HTTPX, to the future, and beyond