docker-engine-api 0.2.1

data/lib/docker_engine_api/internal/transport/pooled_net_requester.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module DockerEngineAPI
+  module Internal
+    module Transport
+      # @api private
+      class PooledNetRequester
+        extend DockerEngineAPI::Internal::Util::SorbetRuntimeSupport
+
+        # from the golang stdlib
+        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+        KEEP_ALIVE_TIMEOUT = 30
+
+        DEFAULT_MAX_CONNECTIONS = [Etc.nprocessors, 99].max
+
+        class << self
+          # @api private
+          #
+          # @param cert_store [OpenSSL::X509::Store]
+          # @param url [URI::Generic]
+          #
+          # @return [Net::HTTP]
+          def connect(cert_store:, url:)
+            port =
+              case [url.port, url.scheme]
+              in [Integer, _]
+                url.port
+              in [nil, "http" | "ws"]
+                Net::HTTP.http_default_port
+              in [nil, "https" | "wss"]
+                Net::HTTP.https_default_port
+              end
+
+            Net::HTTP.new(url.host, port).tap do
+              _1.use_ssl = %w[https wss].include?(url.scheme)
+              _1.max_retries = 0
+
+              (_1.cert_store = cert_store) if _1.use_ssl?
+            end
+          end
+
+          # @api private
+          #
+          # @param conn [Net::HTTP]
+          # @param deadline [Float]
+          def calibrate_socket_timeout(conn, deadline)
+            timeout = deadline - DockerEngineAPI::Internal::Util.monotonic_secs
+            conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
+          end
+
+          # @api private
+          #
+          # @param request [Hash{Symbol=>Object}] .
+          #
+          #   @option request [Symbol] :method
+          #
+          #   @option request [URI::Generic] :url
+          #
+          #   @option request [Hash{String=>String}] :headers
+          #
+          # @param blk [Proc]
+          #
+          # @yieldparam [String]
+          # @return [Array(Net::HTTPGenericRequest, Proc)]
+          def build_request(request, &blk)
+            method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
+            req = Net::HTTPGenericRequest.new(
+              method.to_s.upcase,
+              !body.nil?,
+              method != :head,
+              URI(url.to_s) # ensure we construct a URI class of the right scheme
+            )
+
+            headers.each { req[_1] = _2 }
+
+            case body
+            in nil
+              req["content-length"] ||= 0 unless req["transfer-encoding"]
+            in String
+              req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"]
+              req.body_stream = DockerEngineAPI::Internal::Util::ReadIOAdapter.new(body, &blk)
+            in StringIO
+              req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
+              req.body_stream = DockerEngineAPI::Internal::Util::ReadIOAdapter.new(body, &blk)
+            in Pathname | IO | Enumerator
+              req["transfer-encoding"] ||= "chunked" unless req["content-length"]
+              req.body_stream = DockerEngineAPI::Internal::Util::ReadIOAdapter.new(body, &blk)
+            end
+
+            [req, req.body_stream&.method(:close)]
+          end
+        end
+
+        # @api private
+        #
+        # @param url [URI::Generic]
+        # @param deadline [Float]
+        # @param blk [Proc]
+        #
+        # @raise [Timeout::Error]
+        # @yieldparam [Net::HTTP]
+        private def with_pool(url, deadline:, &blk)
+          origin = DockerEngineAPI::Internal::Util.uri_origin(url)
+          timeout = deadline - DockerEngineAPI::Internal::Util.monotonic_secs
+          pool =
+            @mutex.synchronize do
+              @pools[origin] ||= ConnectionPool.new(size: @size) do
+                self.class.connect(cert_store: @cert_store, url: url)
+              end
+            end
+
+          pool.with(timeout: timeout, &blk)
+        end
+
+        # @api private
+        #
+        # @param request [Hash{Symbol=>Object}] .
+        #
+        #   @option request [Symbol] :method
+        #
+        #   @option request [URI::Generic] :url
+        #
+        #   @option request [Hash{String=>String}] :headers
+        #
+        #   @option request [Object] :body
+        #
+        #   @option request [Float] :deadline
+        #
+        # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
+        def execute(request)
+          url, deadline = request.fetch_values(:url, :deadline)
+
+          req = nil
+          finished = false
+
+          # rubocop:disable Metrics/BlockLength
+          enum = Enumerator.new do |y|
+            next if finished
+
+            with_pool(url, deadline: deadline) do |conn|
+              eof = false
+              closing = nil
+              ::Thread.handle_interrupt(Object => :never) do
+                ::Thread.handle_interrupt(Object => :immediate) do
+                  req, closing = self.class.build_request(request) do
+                    self.class.calibrate_socket_timeout(conn, deadline)
+                  end
+
+                  self.class.calibrate_socket_timeout(conn, deadline)
+                  unless conn.started?
+                    conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
+                    conn.start
+                  end
+
+                  self.class.calibrate_socket_timeout(conn, deadline)
+                  ::Kernel.catch(:jump) do
+                    conn.request(req) do |rsp|
+                      y << [req, rsp]
+                      ::Kernel.throw(:jump) if finished
+
+                      rsp.read_body do |bytes|
+                        y << bytes.force_encoding(Encoding::BINARY)
+                        ::Kernel.throw(:jump) if finished
+
+                        self.class.calibrate_socket_timeout(conn, deadline)
+                      end
+                      eof = true
+                    end
+                  end
+                end
+              ensure
+                begin
+                  conn.finish if !eof && conn&.started?
+                ensure
+                  closing&.call
+                end
+              end
+            end
+          rescue Timeout::Error
+            raise DockerEngineAPI::Errors::APITimeoutError.new(url: url, request: req)
+          rescue StandardError
+            raise DockerEngineAPI::Errors::APIConnectionError.new(url: url, request: req)
+          end
+          # rubocop:enable Metrics/BlockLength
+
+          _, response = enum.next
+          body = DockerEngineAPI::Internal::Util.fused_enum(enum, external: true) do
+            finished = true
+            loop { enum.next }
+          end
+          [Integer(response.code), response, body]
+        end
+
+        # @api private
+        #
+        # @param size [Integer]
+        def initialize(size: self.class::DEFAULT_MAX_CONNECTIONS)
+          @mutex = Mutex.new
+          @size = size
+          @cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
+          @pools = {}
+        end
+
+        define_sorbet_constant!(:Request) do
+          T.type_alias { {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float} }
+        end
+      end
+    end
+  end
+end

data/lib/docker_engine_api/internal/type/array_of.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module DockerEngineAPI
+  module Internal
+    module Type
+      # @api private
+      #
+      # @abstract
+      #
+      # @generic Elem
+      #
+      # Array of items of a given type.
+      class ArrayOf
+        include DockerEngineAPI::Internal::Type::Converter
+        include DockerEngineAPI::Internal::Util::SorbetRuntimeSupport
+
+        private_class_method :new
+
+        # @overload [](type_info, spec = {})
+        #
+        # @param type_info [Hash{Symbol=>Object}, Proc, DockerEngineAPI::Internal::Type::Converter, Class]
+        #
+        # @param spec [Hash{Symbol=>Object}] .
+        #
+        #   @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+        #
+        #   @option spec [Proc] :enum
+        #
+        #   @option spec [Proc] :union
+        #
+        #   @option spec [Boolean] :"nil?"
+        #
+        # @return [self]
+        def self.[](...) = new(...)
+
+        # @api public
+        #
+        # @param other [Object]
+        #
+        # @return [Boolean]
+        def ===(other) = other.is_a?(Array) && other.all?(item_type)
+
+        # @api public
+        #
+        # @param other [Object]
+        #
+        # @return [Boolean]
+        def ==(other)
+          # rubocop:disable Layout/LineLength
+          other.is_a?(DockerEngineAPI::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
+          # rubocop:enable Layout/LineLength
+        end
+
+        # @api public
+        #
+        # @return [Integer]
+        def hash = [self.class, item_type].hash
+
+        # @api private
+        #
+        # @param value [Array<Object>, Object]
+        #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
+        #
+        #   @option state [Hash{Symbol=>Object}] :exactness
+        #
+        #   @option state [Class<StandardError>] :error
+        #
+        #   @option state [Integer] :branched
+        #
+        # @return [Array<Object>, Object]
+        def coerce(value, state:)
+          exactness = state.fetch(:exactness)
+
+          unless value.is_a?(Array)
+            exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Array}")
+            return value
+          end
+
+          target = item_type
+          exactness[:yes] += 1
+          value
+            .map do |item|
+              case [nilable?, item]
+              in [true, nil]
+                exactness[:yes] += 1
+                nil
+              else
+                DockerEngineAPI::Internal::Type::Converter.coerce(target, item, state: state)
+              end
+            end
+        end
+
+        # @api private
+        #
+        # @param value [Array<Object>, Object]
+        #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :can_retry
+        #
+        # @return [Array<Object>, Object]
+        def dump(value, state:)
+          target = item_type
+          if value.is_a?(Array)
+            value.map do
+              DockerEngineAPI::Internal::Type::Converter.dump(target, _1, state: state)
+            end
+          else
+            super
+          end
+        end
+
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          T::Array[DockerEngineAPI::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+        end
+
+        # @api private
+        #
+        # @return [generic<Elem>]
+        protected def item_type = @item_type_fn.call
+
+        # @api private
+        #
+        # @return [Boolean]
+        protected def nilable? = @nilable
+
+        # @api private
+        #
+        # @param type_info [Hash{Symbol=>Object}, Proc, DockerEngineAPI::Internal::Type::Converter, Class]
+        #
+        # @param spec [Hash{Symbol=>Object}] .
+        #
+        #   @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+        #
+        #   @option spec [Proc] :enum
+        #
+        #   @option spec [Proc] :union
+        #
+        #   @option spec [Boolean] :"nil?"
+        def initialize(type_info, spec = {})
+          @item_type_fn = DockerEngineAPI::Internal::Type::Converter.type_info(type_info || spec)
+          @meta = DockerEngineAPI::Internal::Type::Converter.meta_info(type_info, spec)
+          @nilable = spec.fetch(:nil?, false)
+        end
+
+        # @api private
+        #
+        # @param depth [Integer]
+        #
+        # @return [String]
+        def inspect(depth: 0)
+          items = DockerEngineAPI::Internal::Type::Converter.inspect(item_type, depth: depth.succ)
+
+          "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
+        end
+      end
+    end
+  end
+end