pooled_net_requester.rbi

# typed: strong

module DockerEngineRuby
  module Internal
    module Transport
      # @api private
      class PooledNetRequester
        extend DockerEngineRuby::Internal::Util::SorbetRuntimeSupport

        Request =
          T.type_alias do
            {
              method: Symbol,
              url: URI::Generic,
              headers: T::Hash[String, String],
              body: T.anything,
              deadline: Float
            }
          end

        # from the golang stdlib
        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
        KEEP_ALIVE_TIMEOUT = 30

        DEFAULT_MAX_CONNECTIONS = T.let(T.unsafe(nil), Integer)

        class << self
          # @api private
          sig do
            params(
              cert_store: OpenSSL::X509::Store,
              tls_cert: T.nilable(OpenSSL::X509::Certificate),
              tls_key: T.nilable(OpenSSL::PKey::PKey),
              tls_verify_peer: T::Boolean,
              url: URI::Generic
            ).returns(
              Net::HTTP
            )
          end
          def connect(cert_store:, tls_cert:, tls_key:, tls_verify_peer:, url:)
          end

          # @api private
          sig { params(conn: Net::HTTP, deadline: Float).void }
          def calibrate_socket_timeout(conn, deadline)
          end

          # @api private
          sig do
            params(
              request:
                DockerEngineRuby::Internal::Transport::PooledNetRequester::Request,
              blk: T.proc.params(arg0: String).void
            ).returns([Net::HTTPGenericRequest, T.proc.void])
          end
          def build_request(request, &blk)
          end
        end

        # @api private
        sig do
          params(
            url: URI::Generic,
            deadline: Float,
            blk: T.proc.params(arg0: Net::HTTP).void
          ).void
        end
        private def with_pool(url, deadline:, &blk)
        end

        # @api private
        sig do
          params(
            request:
              DockerEngineRuby::Internal::Transport::PooledNetRequester::Request
          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
        end
        def execute(request)
        end

        # @api private
        sig do
          params(
            size: Integer,
            tls_verify_peer: T::Boolean,
            tls_ca_cert_path: T.nilable(String),
            tls_client_cert_path: T.nilable(String),
            tls_client_key_path: T.nilable(String)
          ).returns(T.attached_class)
        end
        def self.new(
          size: DockerEngineRuby::Internal::Transport::PooledNetRequester::DEFAULT_MAX_CONNECTIONS,
          tls_verify_peer: true,
          tls_ca_cert_path: nil,
          tls_client_cert_path: nil,
          tls_client_key_path: nil
        )
        end
      end
    end
  end
end