martian

type ConnectFunc func(req *http.Request) (*http.Response, io.ReadWriteCloser, error)

type ErrorStatus struct {
	Err    error
	Status int
}

type Proxy struct {
	RequestModifier
	ResponseModifier
	Trace *ProxyTrace

	// RoundTripper specifies the round tripper to use for requests.
	RoundTripper http.RoundTripper

	// DialContext specifies the dial function for creating unencrypted TCP connections.
	// If not set and the RoundTripper is an *http.Transport, the Transport's DialContext is used.
	DialContext func(context.Context, string, string) (net.Conn, error)

	// ProxyURL specifies the upstream proxy to use for requests.
	// If not set and the RoundTripper is an *http.Transport, the Transport's ProxyURL is used.
	ProxyURL func(*http.Request) (*url.URL, error)

	// AllowHTTP disables automatic HTTP to HTTPS upgrades when the listener is TLS.
	AllowHTTP bool

	// RequestIDHeader specifies a special header name that the proxy will use to identify requests.
	// If the header is present in the request, the proxy will associate the value with the request in the logs.
	// If empty, no action is taken, and the proxy will generate a new request ID.
	RequestIDHeader string

	// ConnectRequestModifier modifies CONNECT requests to upstream proxy.
	// If ConnectPassthrough is enabled, this is ignored.
	ConnectRequestModifier func(*http.Request) error

	// ConnectFunc specifies a function to dial network connections for CONNECT requests.
	// Implementations can return ErrConnectFallback to indicate that the CONNECT request should be handled by martian.
	ConnectFunc ConnectFunc

	// ConnectTimeout specifies the maximum amount of time to connect to upstream before cancelling request.
	ConnectTimeout time.Duration

	// MITMConfig is config to use for MITMing of CONNECT requests.
	MITMConfig *mitm.Config

	// MITMFilter specifies a function to determine whether a CONNECT request should be MITMed.
	MITMFilter func(*http.Request) bool

	// MITMTLSHandshakeTimeout specifies the maximum amount of time to wait for a TLS handshake for a MITMed connection.
	// Zero means no timeout.
	MITMTLSHandshakeTimeout time.Duration

	// WithoutWarning disables the warning header added to requests and responses when modifier errors occur.
	WithoutWarning bool

	// ErrorResponse specifies a custom error HTTP response to send when a proxying error occurs.
	ErrorResponse func(req *http.Request, err error) *http.Response

	// IdleTimeout is the maximum amount of time to wait for the
	// next request. If IdleTimeout is zero, the value of ReadTimeout is used.
	// If both are zero, there is no timeout.
	IdleTimeout time.Duration

	// ReadTimeout is the maximum duration for reading the entire
	// request, including the body. A zero or negative value means
	// there will be no timeout.
	//
	// Because ReadTimeout does not let Handlers make per-request
	// decisions on each request body's acceptable deadline or
	// upload rate, most users will prefer to use
	// ReadHeaderTimeout. It is valid to use them both.
	ReadTimeout time.Duration

	// ReadHeaderTimeout is the amount of time allowed to read
	// request headers. The connection's read deadline is reset
	// after reading the headers and the Handler can decide what
	// is considered too slow for the body. If ReadHeaderTimeout
	// is zero, the value of ReadTimeout is used. If both are
	// zero, there is no timeout.
	ReadHeaderTimeout time.Duration

	// WriteTimeout is the maximum duration before timing out
	// writes of the response. It is reset whenever a new
	// request's header is read. Like ReadTimeout, it does not
	// let Handlers make decisions on a per-request basis.
	// A zero or negative value means there will be no timeout.
	WriteTimeout time.Duration

	// BaseContex is the base context for all requests.
	BaseContex context.Context //nolint:containedctx // It's intended to be used as a base context.

	// TestingSkipRoundTrip skips the round trip for requests and returns a 200 OK response.
	TestingSkipRoundTrip bool
	// contains filtered or unexported fields
}

type ProxyTrace struct {
	// ReadRequest is called with the result of reading the request.
	// It is called after the request has been read.
	ReadRequest func(ReadRequestInfo)

	// WroteResponse is called with the result of writing the response.
	// It is called after the response has been written.
	WroteResponse func(WroteResponseInfo)
}

type ReadRequestInfo struct {
	// Req is the request that was read.
	Req *http.Request
	// Err is any error encountered while reading the Request.
	Err error
}

type RequestModifier interface {
	// ModifyRequest modifies the request.
	ModifyRequest(req *http.Request) error
}

type RequestModifierFunc func(req *http.Request) error

type RequestResponseModifier interface {
	RequestModifier
	ResponseModifier
}

type ResponseModifier interface {
	// ModifyResponse modifies the response.
	ModifyResponse(res *http.Response) error
}

type ResponseModifierFunc func(res *http.Response) error

type TraceIDPrependingLogger struct {
	log.Logger
}

type WroteResponseInfo struct {
	// Res is the response that was written.
	Res *http.Response
	// Err is any error encountered while writing the Request.
	Err error
}