proxy

type FileDescriptor struct {
	Address engine.Address
	File    *os.File
}

type NewProxyFn func(id int) (Proxy, error)

type Options struct {
	MetricsClient             metrics.Client
	DialTimeout               time.Duration
	ReadTimeout               time.Duration
	WriteTimeout              time.Duration
	MaxHeaderBytes            int
	DefaultListener           *engine.Listener
	TrustForwardHeader        bool
	Files                     []*FileDescriptor
	TimeProvider              timetools.TimeProvider
	NotFoundMiddleware        plugin.Middleware
	Router                    router.Router
	IncomingConnectionTracker conntracker.ConnectionTracker
	FrontendListeners         plugin.FrontendListeners
	CacheProvider             cacheprovider.T
	Aliases                   map[string]string
}

type Proxy interface {
	engine.StatsProvider

	Init(snapshot engine.Snapshot) error

	UpsertHost(engine.Host) error
	DeleteHost(engine.HostKey) error

	UpsertListener(engine.Listener) error
	DeleteListener(engine.ListenerKey) error

	UpsertBackend(engine.Backend) error
	DeleteBackend(engine.BackendKey) error

	UpsertFrontend(engine.Frontend) error
	DeleteFrontend(engine.FrontendKey) error

	UpsertMiddleware(engine.FrontendKey, engine.Middleware) error
	DeleteMiddleware(engine.MiddlewareKey) error

	UpsertServer(engine.BackendKey, engine.Server) error
	DeleteServer(engine.ServerKey) error

	// TakeFiles takes file descriptors representing sockets in listening state to start serving on them
	// instead of binding. This is nessesary if the child process needs to inherit sockets from the parent
	// (e.g. for graceful restarts)
	TakeFiles([]*FileDescriptor) error

	// GetFiles exports listening socket's underlying dupped file descriptors, so they can later
	// be passed to child process or to another Server
	GetFiles() ([]*FileDescriptor, error)

	Start() error
	Stop(wait bool)
}