reverseproxy

type ActualRequestFilter interface {
	OnActualRequest(ctx context.Context, infor HttpInfor)
}

type BufferPool interface {
	Get() []byte
	Put([]byte)
}

type CtxKeyHandleFuncForActualRequest struct{ CtxKeyHandleFuncForActualRequest any }

type CtxKeyMap struct{ CtxKeyMap any }

type CtxKeyPath struct{ CtxKeyPath any }

type CtxKeyPathMatcher struct{ CtxKeyPathVars any }

type CurlPrinterTransport struct {
	Logger logs.Logger
	Inner  http.RoundTripper
}

type DefaultResponseFilter struct {
	*bytes.Buffer
}

type DoNothingTransport struct {
	Response *http.Response
}

type Enable interface {
	Enable(context.Context, *http.Request) bool
}

type Filter any

type FilterConfig struct {
	Name   string          `json:"name" yaml:"name"`
	Config json.RawMessage `json:"config" yaml:"config"`
}

type FilterCreator func(json.RawMessage) (Filter, error)

type HttpInfor interface {
	Method() string
	URL() *url.URL
	Status() string
	StatusCode() int
	Header() http.Header
	Cookie(string) (*http.Cookie, error)
	ContentLength() int64
	Host() string
	RemoteAddr() string
	// Body only for getting request body and only on request stage.
	Body() io.ReadCloser
	SetBody(body io.ReadCloser, size int64)
	SetBody2(body interface{})
	// BodyBuffer only for getting request body and only on request stage.
	BodyBuffer(all ...bool) *bytes.Buffer
	// Request only on request stage.
	Request() *http.Request
}

type ImmutableResponseFilter interface {
	// OnResponseChunkImmutable 对比 OnResponseChunk，不传入 w Writer，且传入的是 chunk 的拷贝，
	// 因此对后续 filter 无影响，只是用于读取 chunk 数据并处理
	OnResponseChunkImmutable(ctx context.Context, infor HttpInfor, copiedChunk []byte) (signal Signal, err error)
	// OnResponseEOFImmutable 对比 OnResponseEOF，不传入 w Writer，且传入的是 chunk 的拷贝，
	// 因此对后续 filter 无影响，只是用于读取 chunk 数据并处理
	OnResponseEOFImmutable(ctx context.Context, infor HttpInfor, copiedChunk []byte) error
}

type LoggerCtxKey struct{ LoggerCtxKey any }

type MapKeyDirectors struct{ CtxKeyDirectors any }

type MultiByteWriter struct {
	// contains filtered or unexported fields
}

type MultiResponseWriter interface {
	MultiResponseWriter(ctx context.Context) []io.ReadWriter
}

type MutexCtxKey struct{ MutexCtxKey any }

type NamingFilter struct {
	Name   string
	Filter Filter
}

type OriginalRequestFilter interface {
	OnOriginalRequest(ctx context.Context, infor HttpInfor)
}

type RequestFilter interface {
	OnRequest(ctx context.Context, w http.ResponseWriter, infor HttpInfor) (signal Signal, err error)
}

type ResponseFilter interface {
	// OnResponseChunk 每被调用一次, 传入一个 response chunk, ResponseFilter 的实现者需要自行决定如何处理这些 chunk.
	// 对大多数情况来说, 实现者可以将这些 chunk 缓存到 filter 实例中, 待 response chunks 全部传完后整体处理.
	// 注意: w Writer 是将 response chunk 传入下一个 ResponseFilter 的句柄, 要将处理后的数据按需写入这个 Writer,
	// 不然后续的 ResponseFilter 都会丢失这部分数据.
	OnResponseChunk(ctx context.Context, infor HttpInfor, w Writer, chunk []byte) (signal Signal, err error)

	// OnResponseEOF 当 OnResponseEOF 被调用时, 表示这是最后一次传入 response chunk, OnResponseEOF 应当做一些收尾工作.
	// 比如 OnResponseChunk 截留了的数据, 可以在此时写入 w Writer.
	OnResponseEOF(ctx context.Context, infor HttpInfor, w Writer, chunk []byte) error

	ImmutableResponseFilter
}

type ReverseProxy struct {
	// Director must be a function which modifies
	// the request into a new request to be sent
	// using Transport. Its response is then copied
	// back to the original client unmodified.
	// Director must not access the provided Request
	// after returning.
	Director func(*http.Request)

	// The transport used to perform proxy requests.
	// If nil, http.DefaultTransport is used.
	Transport http.RoundTripper

	// FlushInterval specifies the flush interval
	// to flush to the client while copying the
	// response body.
	// If zero, no periodic flushing is done.
	// A negative value means to flush immediately
	// after each write to the client.
	// The FlushInterval is ignored when ReverseProxy
	// recognizes a response as a streaming response, or
	// if its ContentLength is -1; for such responses, writes
	// are flushed to the client immediately.
	FlushInterval time.Duration

	// ErrorLog specifies an optional logger for errors
	// that occur when attempting to proxy the request.
	// If nil, logging is done via the log package's standard logger.
	ErrorLog *log.Logger

	// BufferPool optionally specifies a buffer pool to
	// get byte slices for use by io.CopyBuffer when
	// copying HTTP response bodies.
	BufferPool BufferPool

	// ModifyResponse is an optional function that modifies the
	// Response from the backend. It is called if the backend
	// returns a response at all, with any HTTP status code.
	// If the backend is unreachable, the optional ErrorHandler is
	// called without any call to ModifyResponse.
	//
	// If ModifyResponse returns an error, ErrorHandler is called
	// with its error value. If ErrorHandler is nil, its default
	// implementation is used.
	ModifyResponse func(*http.Response) error

	// ErrorHandler is an optional function that handles errors
	// reaching the backend or errors from ModifyResponse.
	//
	// If nil, the default is to log the provided error and return
	// a 502 Status Bad Gateway response.
	ErrorHandler func(http.ResponseWriter, *http.Request, error)

	Filters []NamingFilter
	Context context.Context
}

type Signal int

type TimerTransport struct {
	Logger logs.Logger
	Inner  http.RoundTripper
}

type Writer interface {
	io.Writer
	io.ByteWriter
}