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  string `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"`
}

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"`
	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            `default:"unix:///var/run/docker.sock" usage:"Path to Docker socket to use"`
	DockerTimeout          int               `default:"0" usage:"Timeout configuration in seconds for the Docker integrations"`
	DockerRefreshInterval  int               `default:"15" usage:"Refresh interval in seconds for the Docker integrations"`
	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()
	Begin(backendEndpoint string)
	Cancel(backendEndpoint string)
}

type IRoutes interface {
	RoutesHandler

	Reset()
	RegisterAll(mappings map[string]string)
	// 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 an (optional) "waker" function which a caller must invoke to wake up serverAddress.
	// The 4th value returned is an (optional) "sleeper" function which a caller must invoke to shut down serverAddress.
	HasRoute(serverAddress string) bool
	FindBackendForServerAddress(ctx context.Context, serverAddress string) (string, string, WakerFunc, SleeperFunc)
	GetSleepers(backend string) []SleeperFunc
	GetMappings() map[string]string
	GetDefaultRoute() (string, WakerFunc, SleeperFunc)
	GetAsleepMOTD(serverAddress string) string
	SimplifySRV(srvEnabled bool)
}

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 RoutesConfigSchema struct {
	DefaultServer string            `json:"default-server"`
	Mappings      map[string]string `json:"mappings"`
}

type RoutesHandler interface {
	CreateMapping(serverAddress string, backend string, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string)
	SetDefaultRoute(backend string, waker WakerFunc, sleeper SleeperFunc, asleepMOTD string)
	// DeleteMapping requests that the serverAddress be removed from routes.
	// Returns true if the route existed.
	DeleteMapping(serverAddress string) 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 */
}

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

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