ruby-http-session 1.0.1 → 2.1.0

data/lib/http/session/connection_pool.rb

@@ -0,0 +1,88 @@
+class HTTP::Session
+  class ConnectionPool
+    include MonitorMixin
+
+    DEFAULT_POOL_TIMEOUT = 5
+    DEFAULT_POOL_MAXSIZE = 5
+    DEFAULT_CONN_KEEP_ALIVE_TIMEOUT = 5
+
+    # The number of connections can be reused.
+    attr_reader :maxsize
+
+    # Returns a new instance of ConnectionPool.
+    #
+    # @param [Hash] opts
+    def initialize(opts, &blk)
+      super()
+
+      @host = opts.fetch(:host)
+      @timeout = opts.fetch(:timeout, DEFAULT_CONN_KEEP_ALIVE_TIMEOUT)
+      @maxsize = opts.fetch(:maxsize, DEFAULT_POOL_MAXSIZE)
+
+      @create_blk = blk
+      @created = 0
+      @que = []
+      @resource = new_cond
+    end
+
+    # Obtain a connection.
+    def with(timeout: DEFAULT_POOL_TIMEOUT, &blk)
+      conn = checkout(timeout: timeout)
+      blk.call(conn)
+    ensure
+      checkin(conn) if conn
+    end
+
+    # The number of connections available.
+    def size
+      @maxsize - @created + @que.size
+    end
+
+    private
+
+    def checkout(timeout:)
+      deadline = current_time + timeout
+
+      synchronize do
+        loop do
+          # Reuse a free connection.
+          if @que.size > 0
+            break @que.pop
+          end
+
+          # Create a new connection if the pool does not reach @maxsize.
+          if @created < @maxsize
+            @created += 1
+            break make_conn
+          end
+
+          # .
+          to_wait = deadline - current_time
+          raise HTTP::Session::Exceptions::PoolTimeoutError, "Waited #{timeout} sec, #{size}/#{maxsize} available" if to_wait <= 0
+
+          # Block until a connection is put back to @que.
+          @resource.wait(to_wait)
+        end
+      end
+    end
+
+    def checkin(conn)
+      synchronize do
+        # Put back to @que.
+        @que.push(conn)
+
+        # Wakes up all threads waiting for this resource.
+        @resource.broadcast
+      end
+    end
+
+    def make_conn
+      opts = {persistent: @host, keep_alive_timeout: @timeout}
+      @create_blk.call(opts)
+    end
+
+    def current_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/http/session/context/follow_context.rb

@@ -0,0 +1,24 @@
+class HTTP::Session
+  class Context
+    class FollowContext
+      def initialize(opts)
+        @request = opts[:request]
+        @verb = opts[:verb]
+        @uri = opts[:uri]
+      end
+
+      def same_origin?
+        @request.uri.origin == @uri.origin
+      end
+
+      def cross_origin?
+        !same_origin?
+      end
+
+      def should_drop_body?
+        @verb == :get &&
+          HTTP::Session::Redirector::UNSAFE_VERBS.include?(@request.verb)
+      end
+    end
+  end
+end

data/lib/http/session/context.rb

@@ -0,0 +1,13 @@
+class HTTP::Session
+  class Context
+    # @!attribute [r] follow
+    #   @return [nil, FollowContext]
+    attr_reader :follow
+
+    # @param [Hash] options
+    # @option options [nil, FollowContext] :follow
+    def initialize(options)
+      @follow = options[:follow]
+    end
+  end
+end

data/lib/http/session/cookies.rb

@@ -0,0 +1,55 @@
+class HTTP::Session
+  class Cookies
+    extend Forwardable
+    include MonitorMixin
+
+    # @!method enabled?
+    #   True when it is enabled.
+    #   @return [Boolean]
+    def_delegator :@options, :enabled?
+
+    # @param [Options::CookiesOption] options
+    def initialize(options)
+      super()
+      @options = options
+    end
+
+    # Read cookies.
+    #
+    # @return [nil, Hash]
+    def read(uri)
+      synchronize do
+        read_cookies(uri)
+      end
+    end
+
+    # Write cookies.
+    #
+    # @param [Response] res
+    # @return [void]
+    def write(res)
+      synchronize do
+        write_cookies(res)
+      end
+    end
+
+    private
+
+    def read_cookies(uri)
+      return if jar.empty?
+      jar.cookies(uri).each_with_object({}) { |c, h| h[c.name] = c.value }
+    end
+
+    def write_cookies(res)
+      req = res.request
+      res.headers.get(HTTP::Headers::SET_COOKIE).each do |header|
+        jar.parse(header, req.uri)
+      end
+    end
+
+    # Only available when #enbled? has the value true.
+    def jar
+      @options.jar
+    end
+  end
+end

data/lib/http/session/exceptions.rb

@@ -0,0 +1,7 @@
+class HTTP::Session
+  module Exceptions
+    Error = Class.new(HTTP::Error)
+    PoolTimeoutError = Class.new(Error)
+    RedirectError = Class.new(Error)
+  end
+end

data/lib/http/session/features/auto_inflate.rb

@@ -1,5 +1,3 @@
-require "set"
-
 class HTTP::Session
   module Features
     class AutoInflate < HTTP::Feature
@@ -53,8 +51,6 @@ class HTTP::Session
       ensure
         zstream.close
       end
-
-      HTTP::Options.register_feature(:hsf_auto_inflate, self)
     end
   end
 end

data/lib/http/session/features.rb

@@ -0,0 +1,5 @@
+class HTTP::Session
+  module Features
+    HTTP::Options.register_feature(:hsf_auto_inflate, HTTP::Session::Features::AutoInflate)
+  end
+end

data/lib/http/session/options/cache_option.rb

@@ -1,40 +1,34 @@
 class HTTP::Session
   class Options
     class CacheOption
+      include Optionable
+
       # @!attribute [r] store
       #   @return [ActiveSupport::Cache::Store]
       attr_reader :store
 
-      # @param [Hash] options
-      # @option options [Boolean] :private set true if it is a private cache
-      # @option options [Boolean] :shared set true if it is a shared cache
-      # @option options [ActiveSupport::Cache::Store] :store
-      def initialize(options)
-        options =
-          case options
-          when nil, false then {enabled: false}
-          when true then {enabled: true}
-          else options
-          end
-
-        # Enabled / Disabled
-        @enabled = options.fetch(:enabled, true)
+      # @param [Hash] opts
+      # @option opts [Boolean] :private set true if it is a private cache
+      # @option opts [Boolean] :shared set true if it is a shared cache
+      # @option opts [ActiveSupport::Cache::Store] :store
+      def initialize(opts)
+        initialize_options(opts)
 
         # Shared Cache / Private Cache
         @shared =
-          if options.key?(:shared)
-            raise ArgumentError, ":shared and :private cannot be used at the same time" if options.key?(:private)
-            !!options[:shared]
-          elsif options.key?(:private)
-            !options[:private]
+          if @options.key?(:shared)
+            raise ArgumentError, ":shared and :private cannot be used at the same time" if @options.key?(:private)
+            !!@options[:shared]
+          elsif @options.key?(:private)
+            !@options[:private]
           else
             true
           end
 
         # Cache Store
         @store =
-          if @enabled
-            store = options[:store]
+          if enabled?
+            store = @options[:store]
             if store.respond_to?(:read) && store.respond_to?(:write)
               store
             else
@@ -43,11 +37,6 @@ class HTTP::Session
           end
       end
 
-      # Indicates whether or not the session cache feature is enabled.
-      def enabled?
-        @enabled
-      end
-
       # True when it is a shared cache.
       #
       # Shared Cache that exists between the origin server and clients (e.g. Proxy, CDN).
@@ -64,6 +53,11 @@ class HTTP::Session
         !shared_cache?
       end
 
+      # @!visibility private
+      def freeze
+        super
+      end
+
       private
 
       def lookup_store(store)

data/lib/http/session/options/cookies_option.rb

@@ -1,21 +1,41 @@
 class HTTP::Session
   class Options
     class CookiesOption
-      # @param [Hash] options
-      def initialize(options)
-        options =
-          case options
-          when nil, false then {enabled: false}
-          when true then {enabled: true}
-          else options
+      include Optionable
+
+      # @!attribute [r] jar
+      #   @return [HTTP::CookieJar]
+      attr_reader :jar
+
+      # @param [Hash] opts
+      # @option opts [HTTP::CookieJar] :jar
+      def initialize(opts)
+        initialize_options(opts)
+
+        # CookieJar
+        @jar =
+          if enabled?
+            jar = @options[:jar]
+            lookup_jar(jar)
           end
+      end
 
-        @enabled = options.fetch(:enabled, true)
+      # @!visibility private
+      def freeze
+        super
       end
 
-      # Indicates whether or not the session cookie feature is enabled.
-      def enabled?
-        @enabled
+      private
+
+      def lookup_jar(jar)
+        case jar
+        when Hash
+          HTTP::CookieJar.new(**jar)
+        when nil
+          HTTP::CookieJar.new
+        else
+          jar
+        end
       end
     end
   end

data/lib/http/session/options/optionable.rb

@@ -0,0 +1,21 @@
+class HTTP::Session
+  class Options
+    module Optionable
+      def initialize_options(opts)
+        @options =
+          case opts
+          when nil, false then {enabled: false}
+          when true then {enabled: true}
+          else opts
+          end
+
+        @enabled =
+          @options.fetch(:enabled, true)
+      end
+
+      def enabled?
+        @enabled
+      end
+    end
+  end
+end

data/lib/http/session/options/persistent_option.rb

@@ -0,0 +1,35 @@
+class HTTP::Session
+  class Options
+    class PersistentOption
+      include Optionable
+
+      # @!attribute [r] pools
+      #   @return [Hash]
+      attr_reader :pools
+
+      # @param [Hash] opts
+      # @option opts [Hash] :pools parameters used to create ConnectionPool
+      def initialize(opts)
+        initialize_options(opts)
+
+        @pools =
+          normalize_pools(@options.fetch(:pools, {"*" => true}))
+      end
+
+      # @!visibility private
+      def freeze
+        super.tap do
+          pools.freeze
+        end
+      end
+
+      private
+
+      def normalize_pools(pools)
+        pools.transform_keys do |k|
+          (k == "*") ? k : HTTP::URI.parse(k).origin
+        end
+      end
+    end
+  end
+end

data/lib/http/session/options.rb

@@ -8,6 +8,10 @@ class HTTP::Session
     #   @return [CacheOption]
     attr_reader :cache
 
+    # @!attribute [r] persistent
+    #   @return [PersistentOption]
+    attr_reader :persistent
+
     # @!attribute [r] http
     #   @return [HTTP::Options]
     attr_reader :http
@@ -16,6 +20,7 @@ class HTTP::Session
     def initialize(options)
       @cookies = HTTP::Session::Options::CookiesOption.new(options.fetch(:cookies, false))
       @cache = HTTP::Session::Options::CacheOption.new(options.fetch(:cache, false))
+      @persistent = HTTP::Session::Options::PersistentOption.new(options.fetch(:persistent, false))
       @http = HTTP::Options.new(
         options.fetch(:http, {}).slice(
           :cookies,
@@ -76,5 +81,15 @@ class HTTP::Session
     def with_proxy(proxy)
       tap { @http = @http.with_proxy(proxy) }
     end
+
+    # @!visibility private
+    def freeze
+      super.tap do
+        cookies.freeze
+        cache.freeze
+        persistent.freeze
+        http.freeze
+      end
+    end
   end
 end

data/lib/http/session/pool_manager.rb

@@ -0,0 +1,67 @@
+class HTTP::Session
+  class PoolManager
+    include MonitorMixin
+
+    # Returns a new instance of PoolManager.
+    #
+    # @param [Options::PersistentOption] options
+    # @param [HTTP::Session] session
+    def initialize(options, session)
+      super()
+      @options = options
+      @session = session
+      @pools = {}
+    end
+
+    # Obtain a connection.
+    def with(uri, &blk)
+      return with_new_conn(&blk) unless @options.enabled?
+
+      origin = HTTP::URI.parse(uri).origin
+      return with_new_conn(&blk) unless connection_pool_usable?(origin)
+
+      with_reusable_conn(origin, &blk)
+    end
+
+    private
+
+    def with_new_conn(&blk)
+      blk.call(make_conn)
+    end
+
+    def with_reusable_conn(origin, &blk)
+      pool = connection_pool_from_origin(origin)
+      pool.with { |conn| blk.call(conn) }
+    end
+
+    def make_conn(opts = {})
+      opts = @session.default_options.http.merge(opts)
+      HTTP::Session::Client.new(opts, @session)
+    end
+
+    def connection_pool_usable?(origin)
+      opts = connection_pool_options_from_origin(origin)
+      return false if opts.nil?
+      return false if opts == false
+      true
+    end
+
+    def connection_pool_options_from_origin(origin)
+      return @options.pools[origin] if @options.pools.key?(origin)
+      @options.pools["*"]
+    end
+
+    def connection_pool_from_origin(origin)
+      synchronize do
+        return @pools[origin] if @pools.key?(origin)
+
+        opts = connection_pool_options_from_origin(origin).dup
+        opts = {} if opts == true
+        opts[:host] = origin
+        @pools[origin] = ConnectionPool.new(opts, &->(conn_opts) {
+          make_conn(conn_opts)
+        })
+      end
+    end
+  end
+end

data/lib/http/session/redirector.rb

@@ -0,0 +1,89 @@
+class HTTP::Session
+  # Mostly borrowed from [http/lib/http/redirector.rb](https://github.com/httprb/http/blob/main/lib/http/redirector.rb)
+  class Redirector
+    # HTTP status codes which indicate redirects
+    REDIRECT_CODES = HTTP::Redirector::REDIRECT_CODES
+
+    # Codes which which should raise StateError in strict mode if original
+    # request was any of {UNSAFE_VERBS}
+    STRICT_SENSITIVE_CODES = HTTP::Redirector::STRICT_SENSITIVE_CODES
+
+    # Insecure http verbs, which should trigger StateError in strict mode
+    # upon {STRICT_SENSITIVE_CODES}
+    UNSAFE_VERBS = HTTP::Redirector::UNSAFE_VERBS
+
+    # Verbs which will remain unchanged upon See Other response.
+    SEE_OTHER_ALLOWED_VERBS = HTTP::Redirector::SEE_OTHER_ALLOWED_VERBS
+
+    # @param [Hash] opts
+    # @option opts [Boolean] :strict (true) redirector hops policy
+    # @option opts [#to_i] :max_hops (5) maximum allowed amount of hops
+    def initialize(opts = {})
+      @strict = opts.fetch(:strict, true)
+      @max_hops = opts.fetch(:max_hops, 5).to_i
+      @on_redirect = opts.fetch(:on_redirect, nil)
+    end
+
+    def perform(response, &blk)
+      request = response.request
+      visited = []
+      history = []
+
+      while REDIRECT_CODES.include?(response.status.code)
+        history << response
+        visited << "#{request.verb} #{request.uri}"
+        raise HTTP::Session::Exceptions::RedirectError, "too many hops" if too_many_hops?(visited)
+        raise HTTP::Session::Exceptions::RedirectError, "endless loop" if endless_loop?(visited)
+
+        location = response.headers.get(HTTP::Headers::LOCATION).inject(:+)
+        raise HTTP::Session::Exceptions::RedirectError, "no Location header in redirect" unless location
+
+        verb = make_redirect_to_verb(response, request)
+        uri = make_redirect_to_uri(response, request, location)
+        ctx = make_redirect_to_ctx(response, request, verb, uri)
+
+        @on_redirect.call(response, request) if @on_redirect.respond_to?(:call)
+        response = blk.call(verb, uri, ctx)
+        request = response.request
+      end
+
+      response.history = history
+      response
+    end
+
+    private
+
+    def too_many_hops?(visited)
+      @max_hops >= 1 && @max_hops < visited.count
+    end
+
+    def endless_loop?(visited)
+      visited.count(visited.last) >= 2
+    end
+
+    def make_redirect_to_verb(response, request)
+      verb = request.verb
+      code = response.status.code
+
+      if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
+        raise HTTP::Session::Exceptions::RedirectError, "can't follow #{response.status} redirect" if @strict
+        verb = :get
+      end
+      if !SEE_OTHER_ALLOWED_VERBS.include?(verb) && code == 303
+        verb = :get
+      end
+
+      verb
+    end
+
+    def make_redirect_to_uri(response, request, location)
+      request.uri.join(location)
+    end
+
+    def make_redirect_to_ctx(response, request, verb, uri)
+      HTTP::Session::Context::FollowContext.new(
+        request: request, verb: verb, uri: uri
+      )
+    end
+  end
+end

data/lib/http/session/response/string_body.rb

@@ -1,5 +1,3 @@
-require "forwardable"
-
 class HTTP::Session
   class Response < SimpleDelegator
     class StringBody

data/lib/http/session/version.rb

@@ -1,5 +1,5 @@
 module HTTP
   class Session
-    VERSION = "1.0.1"
+    VERSION = "2.1.0"
   end
 end