prifma

type AfterWriteResponseModule interface {
	AfterWriteResponse(req *http.Request, resp Response) error
}

type BeforeHandleRequestModule interface {
	BeforeHandleRequest(req *http.Request) error
}

type Condition interface {
	Test(req *http.Request) bool
}

type ConditionDstDomain struct {
	Tester ConditionTester
}

type ConditionHeader struct {
	Tester ConditionTester
	Name   string
}

type ConditionSrcIp struct {
	Tester ConditionTester
}

type ConditionTester interface {
	Test(val string) bool
}

type ConditionTesterCIDR struct {
	Net *net.IPNet
}

type ConditionTesterEquals struct {
	Value string
}

type ConditionTesterRegexp struct {
	Regexp *regexp.Regexp
}

type ConfigMain struct {
	ConfigServer conf.Block
	ConfigModule conf.Block
}

type ConfigModule struct {
	Server Server
	Conds  []Condition
}

type ConfigServer struct {
	Server Server
}

type DefaultDialer struct {
	IpV4   net.IP
	IpV6   net.IP
	Dialer net.Dialer
}

type DefaultHandleRequestResult struct {
	Server    Server
	Request   *http.Request
	Response  Response
	Dialer    Dialer
	Transport *http.Transport
}

type DefaultModulesManager struct {
	ModulesArray []Module
	ModulesMap   map[string]int
	CondModules  map[Condition]ModulesManager
}

type DefaultServer struct {
	ModulesManager ModulesManager
	ListenType     ListenType
	ErrorLog       *log.Logger
	Config         conf.Block
	Server         http.Server
}

type Dialer interface {
	GetIpV4() net.IP
	GetIpV6() net.IP
	GetLocalIp(hostname string) (net.IP, error)

	SetIpV4(ip net.IP)
	SetIpV6(ip net.IP)

	DialContext(ctx context.Context, network, address string) (net.Conn, error)
}

type HandleRequestModule interface {
	HandleRequest(result HandleRequestResult) (HandleRequestResult, error)
}

type HandleRequestResult interface {
	SetRequest(req *http.Request)
	SetDialer(dialer Dialer)
	SetProxy(proxy ProxyFunc)
	SetProxyConnectHeader(header http.Header)
	SetResponse(resp Response)

	GetRequest() *http.Request
	GetDialer() Dialer
	GetProxy() ProxyFunc
	GetProxyConnectHeader() http.Header
	GetResponse() Response
	GetServer() Server

	GetRoundTripper() http.RoundTripper
}

type ListenType byte

type Module interface {
	GetDirective() string
	Clone() Module

	conf.Block
}

type ModulesManager interface {
	GetModule(directive string, conds ...Condition) Module
	GetModulesForRequest(req *http.Request) []Module
}

type ProxyFunc func(*http.Request) (*url.URL, error)

type RequestHandler struct {
	Server Server
}

type Response interface {
	Write(rw http.ResponseWriter, result HandleRequestResult) error
	GetCode() int
	GetLAddr() net.Addr
	GetRAddr() net.Addr
}

type ResponseError struct {
	Code  int
	Error string
}

type Server interface {
	GetModulesManager() ModulesManager
	GetListenIp() net.IP
	GetListenPort() int
	GetListenType() ListenType
	GetErrorLog() *log.Logger
	GetReadTimeout() time.Duration
	GetReadHeaderTimeout() time.Duration
	GetWriteTimeout() time.Duration
	GetIdleTimeout() time.Duration

	SetListenIp(ip string) error
	SetListenPort(port string) error
	SetListenType(typ string) error
	SetErrorLog(filename string) error
	SetReadTimeout(timeout string) error
	SetReadHeaderTimeout(timeout string) error
	SetWriteTimeout(timeout string) error
	SetIdleTimeout(timeout string) error

	LoadConfig(filename string) error
	ListenAndServe() error
}