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 ApiServer struct {
	// contains filtered or unexported fields
}

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 */
	DynamicProxyProtocol   bool          `` /* 220-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 interface {
	IncrementErrors(errorType string)
	AddBytesTransmitted(amount int64)
	IncrementConnectionsFrontend()
	IncrementConnectionsBackend(host string)
	SetActiveConnections(count int32)
	SetServerActivePlayerCounts(playerName string, playerUuid string, serverAddress string, count int)
	IncrementServerLogins(playerName string, playerUuid string, serverAddress string)
	SetServerActiveConnections(serverAddress string, value int)
	SetRateLimitAvailable(value int64)
}

type DockerScalingTarget struct {
	ScalingIndicator
	// contains filtered or unexported fields
}

type DockerSwarmScalingTarget struct {
	ScalingIndicator
	// contains filtered or unexported fields
}

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

type IDownScaler interface {
	Reset()
	Start(ctx context.Context, scalingTarget ScalingTarget, routes IRoutes)
	Cancel(scalingTarget ScalingTarget)
	HandleContextDone(ctx context.Context)
}

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, ScalingTarget, WakerFunc, SleeperFunc)
	HasRoute(serverAddress string) bool
	GetSleeper(scalingTarget ScalingTarget) SleeperFunc
	GetMappings() map[string]string
	GetDefaultRoute() (string, ScalingTarget, 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 K8sScalingTarget struct {
	ScalingIndicator
	// contains filtered or unexported fields
}

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 ScalingTarget, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string, loadingMOTD string)
	// UpdateMapping atomically replaces the backend for an existing route without touching the
	// scale-down timer. Use this instead of RemoveMapping+CreateMapping when the server address
	// itself has not changed, so the timer bounce (cancel-on-remove, start-on-create) is avoided.
	// If backend is empty the timer is cancelled (container stopped externally).
	UpdateMapping(serverAddress string, backend string, scalingTarget ScalingTarget, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string, loadingMOTD string)
	SetDefaultRoute(backend string, scalingTarget ScalingTarget, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string, loadingMOTD string)
	RemoveDefaultRoute()
	// RemoveMapping requests that the serverAddress be removed from routes.
	// Returns true if the route existed.
	RemoveMapping(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 ScalingIndicator struct {
	// contains filtered or unexported fields
}

type ScalingTarget interface {
	// StartScaling and EndScaling are called when the target scales up (via WakerFunc) and scales down (via SleeperFunc).
	// Returns true if this is the first state change, which is intended to be used in a guarded conditional such as
	//
	// 	if scalingTarget.StartScaling() {
	//    defer scalingTarget.EndScaling()
	//    // invoke sleeper/waker
	// 	}
	StartScaling() bool
	EndScaling() bool
	// ScalingKey returns a unique identifier for the target suitable for use as a map key.
	ScalingKey() string
	IsScaling() bool
}

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 WebhookScalingTarget struct {
	ScalingIndicator
	// contains filtered or unexported fields
}

type WebhookStatus string