server

type ActiveConnections struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type AllowDenyConfig struct {
	Global  AllowDenyLists
	Servers map[string]AllowDenyLists
}

type AllowDenyLists struct {
	Allowlist []PlayerInfo
	Denylist  []PlayerInfo
}

type AutoScale struct {
	Up          bool          `` /* 153-byte string literal not displayed */
	Down        bool          `` /* 182-byte string literal not displayed */
	DownAfter   time.Duration `default:"10m" usage:"Server scale down delay after there are no connections"`
	AllowDeny   string        `` /* 273-byte string literal not displayed */
	AsleepMOTD  string        `usage:"MOTD to display when auto-scaled down servers are accessed; if empty, no status will be served"`
	LoadingMOTD string        `usage:"MOTD to display while auto-scaled Docker servers are waking up; if empty, asleep status will be served"`
	Webhook     AutoScaleWebhookConfig
}

type AutoScaleWebhookConfig struct {
	Url         string            `usage:"If set, statically-configured backends are scaled up on access and down after idle by POSTing to this URL"`
	Headers     map[string]string `usage:"Zero or more 'key=value' headers added to scaler webhook requests, e.g. for authentication tokens"`
	Timeout     time.Duration     `default:"30s" usage:"Timeout for each scaler webhook request"`
	WakeTimeout time.Duration     `default:"60s" usage:"Maximum time to wait for the backend to become reachable after a scale-up webhook"`
}

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

type ClientInfo struct {
	Host string `json:"host"`
	Port int    `json:"port"`
}

type Config struct {
	Port                   int               `default:"25565" usage:"The [port] bound to listen for Minecraft client connections"`
	Default                string            `usage:"host:port of a default Minecraft server to use when mapping not found"`
	Mapping                map[string]string `usage:"Comma or newline delimited or repeated mappings of externalHostname=host:port"`
	ApiBinding             string            `usage:"The [host:port] bound for servicing API requests"`
	CpuProfile             string            `usage:"Enables CPU profiling and writes to given path"`
	ConnectionRateLimit    int               `default:"1" usage:"Max number of connections to allow per second"`
	BackendDialTimeout     time.Duration     `` /* 307-byte string literal not displayed */
	InKubeCluster          bool              `usage:"Use in-cluster Kubernetes config"`
	KubeConfig             string            `usage:"The path to a Kubernetes configuration file"`
	KubeNamespace          string            `usage:"The namespace to watch or blank for all, which is the default"`
	InDocker               bool              `usage:"Use Docker service discovery"`
	InDockerSwarm          bool              `usage:"Use Docker Swarm service discovery"`
	DockerSocket           string            `usage:"Path to Docker socket to use"`
	DockerTimeout          time.Duration     `usage:"Timeout (as duration) for the Docker integrations"`
	DockerRefreshInterval  time.Duration     `usage:"Deprecated and ignored: Docker discovery is now event-driven"`
	DockerApiVersion       string            `usage:"Instead of auto-negotiating, use specific Docker API version"`
	MetricsBackend         string            `default:"discard" usage:"Backend to use for metrics exposure/publishing: discard,expvar,influxdb,prometheus"`
	MetricsBackendConfig   MetricsBackendConfig
	MetricsRateLimitPeriod time.Duration `default:"1s" usage:"The period at which the rate limit bucket's metrics are set: 0 to disable (default 1s)"`
	UseProxyProtocol       bool          `default:"false" usage:"Send PROXY protocol to backend servers"`
	ReceiveProxyProtocol   bool          `` /* 190-byte string literal not displayed */
	TrustedProxies         []string      `usage:"Comma delimited list of CIDR notation IP blocks to trust when receiving PROXY protocol"`
	RecordLogins           bool          `default:"false" usage:"Log and generate metrics on player logins. Metrics only supported with influxdb or prometheus backend"`
	Routes                 RoutesConfig
	Ngrok                  NgrokConfig
	AutoScale              AutoScale

	ClientsToAllow []string `usage:"Zero or more client IP addresses or CIDRs to allow. Takes precedence over deny."`
	ClientsToDeny  []string `usage:"Zero or more client IP addresses or CIDRs to deny. Ignored if any configured to allow"`

	SimplifySRV bool `default:"false" usage:"Simplify fully qualified SRV records for mapping"`

	Webhook WebhookConfig `usage:"Webhook configuration"`
}

type ConnectionNotifier interface {
	// NotifyMissingBackend is called when an inbound connection is received for a server that does not have a backend.
	NotifyMissingBackend(ctx context.Context, clientAddr net.Addr, server string, playerInfo *PlayerInfo) error

	// NotifyFailedBackendConnection is called when the backend connection failed.
	NotifyFailedBackendConnection(ctx context.Context,
		clientAddr net.Addr, serverAddress string, playerInfo *PlayerInfo, backendHostPort string, err error) error

	// NotifyConnected is called when the backend connection succeeded.
	NotifyConnected(ctx context.Context,
		clientAddr net.Addr, serverAddress string, playerInfo *PlayerInfo, backendHostPort string) error

	// NotifyDisconnected is called when the backend connection terminates.
	NotifyDisconnected(ctx context.Context,
		clientAddr net.Addr, serverAddress string, playerInfo *PlayerInfo, backendHostPort string) error
}

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

type ConnectorMetrics struct {
	Errors                  metrics.Counter
	BytesTransmitted        metrics.Counter
	ConnectionsFrontend     metrics.Counter
	ConnectionsBackend      metrics.Counter
	ActiveConnections       metrics.Gauge
	ServerActivePlayer      metrics.Gauge
	ServerLogins            metrics.Counter
	ServerActiveConnections metrics.Gauge
	RateLimitAvailable      metrics.Gauge
}

type IDockerWatcher interface {
	Start(ctx context.Context) error
}

type IDownScaler interface {
	Reset()
	Start(ctx context.Context, backendEndpoint string, routes IRoutes)
	Cancel(backendEndpoint string)
}

type IRoutes interface {
	RoutesHandler

	Reset()
	// FindBackendForServerAddress returns the host:port for the external server address, if registered.
	// Otherwise, an empty string is returned. Also returns the normalized version of the given serverAddress.
	// The 3rd value returned is the scalingTarget which indicates what endpoint to scale (may differ from backend when using proxy).
	// The 4th value returned is an (optional) "waker" function which a caller must invoke to wake up serverAddress.
	// The 5th value returned is an (optional) "sleeper" function which a caller must invoke to shut down serverAddress.
	FindBackendForServerAddress(ctx context.Context, serverAddress string) (string, string, string, WakerFunc, SleeperFunc)
	HasRoute(serverAddress string) bool
	GetSleepers(scalingTarget string) []SleeperFunc
	GetMappings() map[string]string
	GetDefaultRoute() (string, string, WakerFunc, SleeperFunc)
	GetAsleepMOTD(serverAddress string) string
	GetLoadingMOTD(serverAddress string) string
	SetCountdownDeadline(serverAddress string, deadline time.Time)
	SimplifySRV(srvEnabled bool)
	// BulkRegister registers a set of static mappings, attaching the scaler's waker/sleeper pair. nil-safe: a nil scaler registers without autoscaling.
	// Reset must be called separately and previous to this if you want to clear existing mappings.
	BulkRegister(scaler *WebhookScaler, mappings map[string]string)

	WithDownScaler(downScaler IDownScaler) IRoutes
	WithListener(listener RoutesListener) IRoutes
}

type K8sWatcher struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type MetricsBackendConfig struct {
	Influxdb struct {
		Interval        time.Duration     `default:"1m"`
		Tags            map[string]string `usage:"any extra tags to be included with all reported metrics"`
		Addr            string
		Username        string
		Password        string
		Database        string
		RetentionPolicy string
	}
}

type MetricsBuilder interface {
	BuildConnectorMetrics() *ConnectorMetrics
	Start(ctx context.Context) error
}

type NgrokConfig struct {
	Token      string `usage:"If set, an ngrok tunnel will be established. It is HIGHLY recommended to pass as an environment variable."`
	RemoteAddr string `usage:"If set, the TCP address to request for this edge"`
}

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

type PlayerInfo struct {
	Name string    `json:"name"`
	Uuid uuid.UUID `json:"uuid"`
}

type RouteFinder interface {
	Start(ctx context.Context, handler RoutesHandler) error
	String() string
}

type RoutesConfig struct {
	Config      string `usage:"Name or full [path] to routes config file"`
	ConfigWatch bool   `usage:"Watch for config file changes"`
}

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

type RoutesConfigSchema struct {
	DefaultServer string            `json:"default-server"`
	Mappings      map[string]string `json:"mappings"`
}

type RoutesHandler interface {
	CreateMapping(serverAddress string, backend string, scalingTarget string, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string, loadingMOTD string)
	SetDefaultRoute(backend string, scalingTarget string, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string, loadingMOTD string)
	// DeleteMapping requests that the serverAddress be removed from routes.
	// Returns true if the route existed.
	DeleteMapping(serverAddress string) bool
}

type RoutesListener interface {
	// OnRouteAdded is called when a new route is added.
	OnRouteAdded(serverAddress string, backend string)
	// OnDefaultRouteSet is called when a default route is set.
	OnDefaultRouteSet(backend string)
	// OnRouteRemoved is called when a route is removed.
	OnRouteRemoved(serverAddress string)
	// OnDefaultRouteRemoved is called when a default route is removed (or un-set).
	OnDefaultRouteRemoved()
}

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

type SleeperFunc func(ctx context.Context) error

type WakerFunc func(ctx context.Context) (string, error)

type WebhookConfig struct {
	Url         string         `usage:"If set, a POST request that contains connection status notifications will be sent to this HTTP address"`
	RequireUser bool           `` /* 126-byte string literal not displayed */
	Timeout     time.Duration  `default:"30s" usage:"Timeout for each connection status notification request"`
	Events      []WebhookEvent `` /* 198-byte string literal not displayed */
}

type WebhookEvent string

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

type WebhookNotifierPayload struct {
	Event           WebhookEvent  `json:"event"`
	Timestamp       time.Time     `json:"timestamp"`
	Status          WebhookStatus `json:"status"`
	Client          *ClientInfo   `json:"client,omitempty"`
	Server          string        `json:"server"`
	PlayerInfo      *PlayerInfo   `json:"player,omitempty"`
	BackendHostPort string        `json:"backend,omitempty"`
	Error           string        `json:"error,omitempty"`
}

type WebhookScalePayload struct {
	Action        string `json:"action"`
	ServerAddress string `json:"serverAddress"`
	Backend       string `json:"backend"`
}

type WebhookScaleResponse struct {
	Backend string `json:"backend"`
}

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

type WebhookStatus string