proxy

type Addr struct {
	Address string
}

type Address struct {
	//L Local
	L Addr
	// R remote
	R Addr
}

type Conn struct {
	// HostName is the hostname field that was sent to the request router.
	// In the case of TLS, this is the SNI header, in the case of HTTPHost
	// route, it will be the host header.  In the case of a fixed
	// route, i.e. those created with AddRoute(), this will always be
	// empty. This can be useful in the case where further routing decisions
	// need to be made in the Target implementation.
	HostName string

	// Peeked are the bytes that have been read from Conn for the
	// purposes of route matching, but have not yet been consumed
	// by Read calls. It set to nil by Read when fully consumed.
	Peeked []byte

	// Conn is the underlying connection.
	// It can be type asserted against *net.TCPConn or other types
	// as needed. It should not be read from directly unless
	// Peeked is nil.
	net.Conn
}

type Context struct {
	ID int64
}

type ContextMeta struct {
	ID atomic.Int64
	// Downstream
	D TCP
	// Upstream
	U TCP
	// ACME true if we are serving acme challenge
	ACME atomic.Bool
	// Fixed is true if we are serving a fixed target
	Fixed atomic.Bool
	// NoMatch true if we have no matching route
	NoMatch atomic.Bool
	// ServerName SNI or Host of the server serving the request
	ServerName atomic.String
	// RouteName the name of the route if any
	RouteName atomic.String
	// Protocol The protocol which we are serving
	Protocol   atomic.Uint32
	Start, End time.Time
	Speed      SpeedRateConfig
	Rate       Rate
	// Labels these are labels that are attached to the request
	Labels map[string]string
	// contains filtered or unexported fields
}

type DialProxy struct {
	Network string

	// Addr is the TCP address to proxy to.
	Addr string

	// KeepAlivePeriod sets the period between TCP keep alives.
	// If zero, a default is used. To disable, use a negative number.
	// The keep-alive is used for both the client connection and
	KeepAlivePeriod time.Duration

	// DialTimeout optionally specifies a dial timeout.
	// If zero, a default is used.
	// If negative, the timeout is disabled.
	DialTimeout time.Duration

	// DialContext optionally specifies an alternate dial function
	// for TCP targets. If nil, the standard
	// net.Dialer.DialContext method is used.
	DialContext func(ctx context.Context, network, address string) (net.Conn, error)

	// OnDialError optionally specifies an alternate way to handle errors dialing Addr.
	// If nil, the error is logged and src is closed.
	// If non-nil, src is not closed automatically.
	OnDialError func(src net.Conn, dstDialErr error)

	// ProxyProtocolVersion optionally specifies the version of
	// HAProxy's PROXY protocol to use. The PROXY protocol provides
	// connection metadata to the DialProxy target, via a header
	// inserted ahead of the client's traffic. The DialProxy target
	// must explicitly support and expect the PROXY header; there is
	// no graceful downgrade.
	// If zero, no PROXY header is sent. Currently, version 1 is supported.
	ProxyProtocolVersion int
	// MetricsLabels labels included when emitting metrics about the TPC proxying
	// with this Dial
	MetricsLabels map[string]string

	UpstreamSpeed   Speed
	DownstreamSpeed Speed
}

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

type Incoming struct {
	*bufio.Reader
}

type Matcher func(ctx context.Context, hostname string) bool

type Options struct {
	HostPort        string
	ControlHostPort string
	AllowedPOrts    []int
	Labels          map[string]string
	Config          api.Config
}

type Protocol uint

type Proxy struct {

	// ListenFunc optionally specifies an alternate listen
	// function. If nil, net.Dial is used.
	// The provided net is always "tcp".
	ListenFunc func(net, laddr string) (net.Listener, error)
	// contains filtered or unexported fields
}

type Rate struct {
	By      atomic.Uint32
	Average atomic.Float64
	Burst   atomic.Int64
}

type RateBy uint

type RateConfig struct {
	Route   string
	Key     string
	Average float64
	Burst   int
}

type RateCopy struct {
	WaitN func(int) error
	net.Conn
	OnWrite func(int)
	OnRead  func(int)
}

type ServerInfo struct {
	Listener net.Listener
	Proxy    *Proxy
}

type Speed string

type SpeedRateConfig struct {
	// This is the amount of bytes read from the client by the server per second.
	// You can think of this as limit on upload speed, where tt is the server
	// receiving the data so it will use this value to limit how much it will be
	// reading per second
	// You can use this to control upload speeds
	Downstream atomic.Float64

	// This is the amount of bytes read from the proxied(upstream) end point. In this case
	// tt will use this to limit how much data it reads from upstream. You can use
	// this to control download speeds
	Upstream atomic.Float64
}

type TCP struct {
	// A socket address
	A Address
	// R bytes read from this socket.
	R atomic.Int64
	// W bytes written to this socket
	W atomic.Int64
}

type Target interface {
	// HandleConn is called when an incoming connection is
	// matched. After the call to HandleConn, the tcpproxy
	// package never touches the conn again. Implementations are
	// responsible for closing the connection when needed.
	//
	// The concrete type of conn will be of type *Conn if any
	// bytes have been consumed for the purposes of route
	// matching.
	HandleConn(context.Context, net.Conn)
}

type TargetListener struct {
	Address string // Address is the string reported by TargetListener.Addr().String().
	// contains filtered or unexported fields
}

type Updates struct {
	api.UnimplementedProxyServer
	OnConfigure func(*api.Config) error
}

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