server

type AlwaysAllowConnection struct{}

type AlwaysOfflineState struct{}

type AlwaysOnlineState struct{}

type Backend interface {
	ReqCh() chan<- BackendRequest
	HasActiveConn() bool
	Update(cfg BackendConfig) error
	Close()
}

type BackendAction byte

type BackendAnswer struct {
	ServerName string
	// contains filtered or unexported fields
}

type BackendConfig struct {
	Name                string
	UpdateProxyProtocol bool
	SendProxyProtocol   bool
	DisconnectPacket    mc.Packet
	OfflineStatusPacket mc.Packet

	HsModifier  HandshakeModifier
	ConnCreator ConnectionCreator
	ConnLimiter ConnectionLimiter
	ServerState StateAgent
	StatusCache StatusCache
}

type BackendFactoryFunc func(config.BackendWorkerConfig) Backend

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

type BackendRequest struct {
	Type       mc.HandshakeState
	Handshake  mc.ServerBoundHandshake
	ServerAddr string
	Addr       net.Addr
	Username   string
	Ch         chan<- BackendAnswer
}

type BackendWorker struct {
	Name                string
	SendProxyProtocol   bool
	OfflineStatusPacket mc.Packet
	DisconnectPacket    mc.Packet

	HsModifier  HandshakeModifier
	ConnCreator ConnectionCreator
	ConnLimiter ConnectionLimiter
	ServerState StateAgent
	StatusCache StatusCache
	// contains filtered or unexported fields
}

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

type CheckOpenConns struct {
	Ch chan bool
}

type ConnectionCreator interface {
	Conn() func() (net.Conn, error)
}

type ConnectionCreatorFunc func() (net.Conn, error)

type ConnectionLimiter interface {
	// The process answer is empty and should be ignored when it does allow the connection to happen
	// Returns true if the connection is allowed to happen
	Allow(req BackendRequest) (BackendAnswer, bool)
}

type HandshakeModifier interface {
	Modify(hs *mc.ServerBoundHandshake, addr string)
}

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

type ProxyAction int8

type ServerState byte

type StateAgent interface {
	State() ServerState
}

type StatusCache interface {
	Status() (BackendAnswer, error)
}

type UpdatableWorker interface {
	Update(data map[string]chan<- BackendRequest)
}

type WorkerManager interface {
	AddBackend(domains []string, ch chan<- BackendRequest)
	RemoveBackend(domains []string)
	KnowsDomain(domain string) bool
	Register(worker UpdatableWorker, update bool)
}