// Package api provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/deepmap/oapi-codegen/v2 version v2.1.0 DO NOT EDIT.
package api
import (
"context"
"fmt"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/oapi-codegen/runtime"
openapi_types "github.com/oapi-codegen/runtime/types"
)
const (
APIKeyAuthScopes = "APIKeyAuth.Scopes"
)
// Defines values for ServerPropertiesDifficulty.
const (
Easy ServerPropertiesDifficulty = "easy"
Hard ServerPropertiesDifficulty = "hard"
Medium ServerPropertiesDifficulty = "medium"
Peaceful ServerPropertiesDifficulty = "peaceful"
)
// Defines values for ServerPropertiesGamemode.
const (
Adventure ServerPropertiesGamemode = "adventure"
Creative ServerPropertiesGamemode = "creative"
Hardcore ServerPropertiesGamemode = "hardcore"
Spectator ServerPropertiesGamemode = "spectator"
Survival ServerPropertiesGamemode = "survival"
)
// Allowlist defines model for Allowlist.
type Allowlist = []PlayerInfo
// BannedIP defines model for BannedIP.
type BannedIP struct {
Created string `json:"created"`
Expires string `json:"expires"`
Ip string `json:"ip"`
Reason string `json:"reason"`
Source string `json:"source"`
}
// BannedIPList defines model for BannedIPList.
type BannedIPList = []BannedIP
// BannedPlayer defines model for BannedPlayer.
type BannedPlayer struct {
Created string `json:"created"`
Expires string `json:"expires"`
Name *string `json:"name,omitempty"`
Reason string `json:"reason"`
Source string `json:"source"`
Uuid openapi_types.UUID `json:"uuid"`
}
// BannedPlayerList defines model for BannedPlayerList.
type BannedPlayerList = []BannedPlayer
// Message defines model for Message.
type Message = string
// PlayerInfo defines model for PlayerInfo.
type PlayerInfo struct {
Name *string `json:"name,omitempty"`
Uuid *openapi_types.UUID `json:"uuid,omitempty"`
}
// ServerArguments defines model for ServerArguments.
type ServerArguments struct {
BonusChest *bool `json:"bonusChest,omitempty"`
Demo *bool `json:"demo,omitempty"`
EraseCache *bool `json:"eraseCache,omitempty"`
ForceUpgrade *bool `json:"forceUpgrade,omitempty"`
MemoryMaxGB *int `json:"memoryMaxGB,omitempty"`
MemoryStartGB *int `json:"memoryStartGB,omitempty"`
Port *int `json:"port,omitempty"`
SafeMode *bool `json:"safeMode,omitempty"`
ServerID *string `json:"serverID,omitempty"`
SinglePlayer *string `json:"singlePlayer,omitempty"`
Universe *string `json:"universe,omitempty"`
World *string `json:"world,omitempty"`
}
// ServerOperator defines model for ServerOperator.
type ServerOperator struct {
BypassesPlayerLimit bool `json:"bypassesPlayerLimit"`
Level int `json:"level"`
Name string `json:"name"`
Uuid openapi_types.UUID `json:"uuid"`
}
// ServerOperatorList defines model for ServerOperatorList.
type ServerOperatorList = []ServerOperator
// ServerProperties defines model for ServerProperties.
type ServerProperties struct {
MOTD *string `json:"MOTD,omitempty"`
PVP *bool `json:"PVP,omitempty"`
RCONPassword *string `json:"RCONPassword,omitempty"`
RCONPort *int `json:"RCONPort,omitempty"`
AcceptTransfers *bool `json:"acceptTransfers,omitempty"`
AllowFlight *bool `json:"allowFlight,omitempty"`
AllowNether *bool `json:"allowNether,omitempty"`
BroadcastConsoleToOps *bool `json:"broadcastConsoleToOps,omitempty"`
BroadcastRCONToOps *bool `json:"broadcastRCONToOps,omitempty"`
Difficulty *ServerPropertiesDifficulty `json:"difficulty,omitempty"`
EnableCommandBlock *bool `json:"enableCommandBlock,omitempty"`
EnableJMXMonitoring *bool `json:"enableJMXMonitoring,omitempty"`
EnableQuery *bool `json:"enableQuery,omitempty"`
EnableRCON *bool `json:"enableRCON,omitempty"`
EnableStatus *bool `json:"enableStatus,omitempty"`
EnforceSecureProfile *bool `json:"enforceSecureProfile,omitempty"`
EnforceWhitelist *bool `json:"enforceWhitelist,omitempty"`
EntityBroadcastRangePercentage *int `json:"entityBroadcastRangePercentage,omitempty"`
ForceGamemode *bool `json:"forceGamemode,omitempty"`
FunctionPermissionLevel *int `json:"functionPermissionLevel,omitempty"`
Gamemode *ServerPropertiesGamemode `json:"gamemode,omitempty"`
GenerateStructures *bool `json:"generateStructures,omitempty"`
GeneratorSettings *string `json:"generatorSettings,omitempty"`
Hardcore *bool `json:"hardcore,omitempty"`
HideOnlinePlayers *bool `json:"hideOnlinePlayers,omitempty"`
InitialDisabledPacks *string `json:"initialDisabledPacks,omitempty"`
InitialEnabledPacks *string `json:"initialEnabledPacks,omitempty"`
LevelName *string `json:"levelName,omitempty"`
LevelSeed *string `json:"levelSeed,omitempty"`
LevelType *string `json:"levelType,omitempty"`
LogIPs *bool `json:"logIPs,omitempty"`
MaxChainedNeighborUpdates *int `json:"maxChainedNeighborUpdates,omitempty"`
MaxPlayers *int `json:"maxPlayers,omitempty"`
MaxTickTime *int `json:"maxTickTime,omitempty"`
MaxWorldSize *int `json:"maxWorldSize,omitempty"`
NetworkCompressionThreshold *int `json:"networkCompressionThreshold,omitempty"`
OnlineMode *bool `json:"onlineMode,omitempty"`
OpPermissionLevel *int `json:"opPermissionLevel,omitempty"`
PlayerIdleTimeout *int `json:"playerIdleTimeout,omitempty"`
PreventProxyConnections *bool `json:"preventProxyConnections,omitempty"`
PreviewsChat *bool `json:"previewsChat,omitempty"`
QueryPort *int `json:"queryPort,omitempty"`
RateLimit *int `json:"rateLimit,omitempty"`
RegionFileCompression *string `json:"regionFileCompression,omitempty"`
RequireResourcePack *bool `json:"requireResourcePack,omitempty"`
ResourcePack *string `json:"resourcePack,omitempty"`
ResourcePackID *string `json:"resourcePackID,omitempty"`
ResourcePackPrompt *string `json:"resourcePackPrompt,omitempty"`
ResourcePackSHA1 *string `json:"resourcePackSHA1,omitempty"`
ServerIP *string `json:"serverIP,omitempty"`
ServerPort *int `json:"serverPort,omitempty"`
SimulationDistance *int `json:"simulationDistance,omitempty"`
SnooperEnabled *bool `json:"snooperEnabled,omitempty"`
SpawnAnimals *bool `json:"spawnAnimals,omitempty"`
SpawnMonsters *bool `json:"spawnMonsters,omitempty"`
SpawnNPCs *bool `json:"spawnNPCs,omitempty"`
SpawnProtection *int `json:"spawnProtection,omitempty"`
SyncChunkWrites *bool `json:"syncChunkWrites,omitempty"`
TextFilteringConfig *string `json:"textFilteringConfig,omitempty"`
UseNativeTransport *bool `json:"useNativeTransport,omitempty"`
ViewDistance *int `json:"viewDistance,omitempty"`
Whitelist *bool `json:"whitelist,omitempty"`
}
// ServerPropertiesDifficulty defines model for ServerProperties.Difficulty.
type ServerPropertiesDifficulty string
// ServerPropertiesGamemode defines model for ServerProperties.Gamemode.
type ServerPropertiesGamemode string
// AllowlistResponse defines model for AllowlistResponse.
type AllowlistResponse = Allowlist
// BannedIPListResponse defines model for BannedIPListResponse.
type BannedIPListResponse = BannedIPList
// BannedPlayerListResponse defines model for BannedPlayerListResponse.
type BannedPlayerListResponse = BannedPlayerList
// MessageResponse defines model for MessageResponse.
type MessageResponse = Message
// ServerOperatorListResponse defines model for ServerOperatorListResponse.
type ServerOperatorListResponse = ServerOperatorList
// AllowlistRequest defines model for AllowlistRequest.
type AllowlistRequest = Allowlist
// BannedIPListRequest defines model for BannedIPListRequest.
type BannedIPListRequest = BannedIPList
// BannedIPRequest defines model for BannedIPRequest.
type BannedIPRequest = BannedIP
// BannedPlayerListRequest defines model for BannedPlayerListRequest.
type BannedPlayerListRequest = BannedPlayerList
// BannedPlayerRequest defines model for BannedPlayerRequest.
type BannedPlayerRequest = BannedPlayer
// PlayerRequest defines model for PlayerRequest.
type PlayerRequest = PlayerInfo
// ServerOperatorListRequest defines model for ServerOperatorListRequest.
type ServerOperatorListRequest = ServerOperatorList
// ServerOperatorRequest defines model for ServerOperatorRequest.
type ServerOperatorRequest = ServerOperator
// UpdateArgsRequest defines model for UpdateArgsRequest.
type UpdateArgsRequest = ServerArguments
// UpdatePropertiesRequest defines model for UpdatePropertiesRequest.
type UpdatePropertiesRequest = ServerProperties
// PostPardonIpJSONBody defines parameters for PostPardonIp.
type PostPardonIpJSONBody struct {
Ip string `json:"ip"`
}
// PostSetVersionParams defines parameters for PostSetVersion.
type PostSetVersionParams struct {
Version *string `form:"version,omitempty" json:"version,omitempty"`
}
// PutAllowlistJSONRequestBody defines body for PutAllowlist for application/json ContentType.
type PutAllowlistJSONRequestBody = Allowlist
// PostAllowlistAddJSONRequestBody defines body for PostAllowlistAdd for application/json ContentType.
type PostAllowlistAddJSONRequestBody = PlayerInfo
// PostAllowlistRemoveJSONRequestBody defines body for PostAllowlistRemove for application/json ContentType.
type PostAllowlistRemoveJSONRequestBody = PlayerInfo
// PutArgsJSONRequestBody defines body for PutArgs for application/json ContentType.
type PutArgsJSONRequestBody = ServerArguments
// PostBanJSONRequestBody defines body for PostBan for application/json ContentType.
type PostBanJSONRequestBody = BannedPlayer
// PostBanIpJSONRequestBody defines body for PostBanIp for application/json ContentType.
type PostBanIpJSONRequestBody = BannedIP
// PutBannedIpsJSONRequestBody defines body for PutBannedIps for application/json ContentType.
type PutBannedIpsJSONRequestBody = BannedIPList
// PutBannedPlayersJSONRequestBody defines body for PutBannedPlayers for application/json ContentType.
type PutBannedPlayersJSONRequestBody = BannedPlayerList
// PostDeopJSONRequestBody defines body for PostDeop for application/json ContentType.
type PostDeopJSONRequestBody = PlayerInfo
// PostOpJSONRequestBody defines body for PostOp for application/json ContentType.
type PostOpJSONRequestBody = ServerOperator
// PutOpsJSONRequestBody defines body for PutOps for application/json ContentType.
type PutOpsJSONRequestBody = ServerOperatorList
// PostPardonJSONRequestBody defines body for PostPardon for application/json ContentType.
type PostPardonJSONRequestBody = PlayerInfo
// PostPardonIpJSONRequestBody defines body for PostPardonIp for application/json ContentType.
type PostPardonIpJSONRequestBody PostPardonIpJSONBody
// PutPropertiesJSONRequestBody defines body for PutProperties for application/json ContentType.
type PutPropertiesJSONRequestBody = ServerProperties
// ServerInterface represents all server handlers.
type ServerInterface interface {
// (GET /allowlist)
GetAllowlist(w http.ResponseWriter, r *http.Request)
// (PUT /allowlist)
PutAllowlist(w http.ResponseWriter, r *http.Request)
// (POST /allowlist/add)
PostAllowlistAdd(w http.ResponseWriter, r *http.Request)
// (POST /allowlist/remove)
PostAllowlistRemove(w http.ResponseWriter, r *http.Request)
// (PUT /args)
PutArgs(w http.ResponseWriter, r *http.Request)
// (GET /available-versions)
GetAvailableVersions(w http.ResponseWriter, r *http.Request)
// (POST /ban)
PostBan(w http.ResponseWriter, r *http.Request)
// (POST /ban-ip)
PostBanIp(w http.ResponseWriter, r *http.Request)
// (GET /banned-ips)
GetBannedIps(w http.ResponseWriter, r *http.Request)
// (PUT /banned-ips)
PutBannedIps(w http.ResponseWriter, r *http.Request)
// (GET /banned-players)
GetBannedPlayers(w http.ResponseWriter, r *http.Request)
// (PUT /banned-players)
PutBannedPlayers(w http.ResponseWriter, r *http.Request)
// (POST /deop)
PostDeop(w http.ResponseWriter, r *http.Request)
// (POST /op)
PostOp(w http.ResponseWriter, r *http.Request)
// (GET /ops)
GetOps(w http.ResponseWriter, r *http.Request)
// (PUT /ops)
PutOps(w http.ResponseWriter, r *http.Request)
// (POST /pardon)
PostPardon(w http.ResponseWriter, r *http.Request)
// (POST /pardon-ip)
PostPardonIp(w http.ResponseWriter, r *http.Request)
// (PUT /properties)
PutProperties(w http.ResponseWriter, r *http.Request)
// (POST /restart)
PostRestart(w http.ResponseWriter, r *http.Request)
// (POST /set-version)
PostSetVersion(w http.ResponseWriter, r *http.Request, params PostSetVersionParams)
// (POST /start)
PostStart(w http.ResponseWriter, r *http.Request)
// (POST /stop)
PostStop(w http.ResponseWriter, r *http.Request)
}
// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.
type Unimplemented struct{}
// (GET /allowlist)
func (_ Unimplemented) GetAllowlist(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /allowlist)
func (_ Unimplemented) PutAllowlist(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /allowlist/add)
func (_ Unimplemented) PostAllowlistAdd(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /allowlist/remove)
func (_ Unimplemented) PostAllowlistRemove(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /args)
func (_ Unimplemented) PutArgs(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (GET /available-versions)
func (_ Unimplemented) GetAvailableVersions(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /ban)
func (_ Unimplemented) PostBan(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /ban-ip)
func (_ Unimplemented) PostBanIp(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (GET /banned-ips)
func (_ Unimplemented) GetBannedIps(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /banned-ips)
func (_ Unimplemented) PutBannedIps(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (GET /banned-players)
func (_ Unimplemented) GetBannedPlayers(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /banned-players)
func (_ Unimplemented) PutBannedPlayers(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /deop)
func (_ Unimplemented) PostDeop(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /op)
func (_ Unimplemented) PostOp(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (GET /ops)
func (_ Unimplemented) GetOps(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /ops)
func (_ Unimplemented) PutOps(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /pardon)
func (_ Unimplemented) PostPardon(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /pardon-ip)
func (_ Unimplemented) PostPardonIp(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (PUT /properties)
func (_ Unimplemented) PutProperties(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /restart)
func (_ Unimplemented) PostRestart(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /set-version)
func (_ Unimplemented) PostSetVersion(w http.ResponseWriter, r *http.Request, params PostSetVersionParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /start)
func (_ Unimplemented) PostStart(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// (POST /stop)
func (_ Unimplemented) PostStop(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
Handler ServerInterface
HandlerMiddlewares []MiddlewareFunc
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}
type MiddlewareFunc func(http.Handler) http.Handler
// GetAllowlist operation middleware
func (siw *ServerInterfaceWrapper) GetAllowlist(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetAllowlist(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutAllowlist operation middleware
func (siw *ServerInterfaceWrapper) PutAllowlist(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutAllowlist(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostAllowlistAdd operation middleware
func (siw *ServerInterfaceWrapper) PostAllowlistAdd(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostAllowlistAdd(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostAllowlistRemove operation middleware
func (siw *ServerInterfaceWrapper) PostAllowlistRemove(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostAllowlistRemove(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutArgs operation middleware
func (siw *ServerInterfaceWrapper) PutArgs(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutArgs(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// GetAvailableVersions operation middleware
func (siw *ServerInterfaceWrapper) GetAvailableVersions(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetAvailableVersions(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostBan operation middleware
func (siw *ServerInterfaceWrapper) PostBan(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostBan(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostBanIp operation middleware
func (siw *ServerInterfaceWrapper) PostBanIp(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostBanIp(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// GetBannedIps operation middleware
func (siw *ServerInterfaceWrapper) GetBannedIps(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetBannedIps(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutBannedIps operation middleware
func (siw *ServerInterfaceWrapper) PutBannedIps(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutBannedIps(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// GetBannedPlayers operation middleware
func (siw *ServerInterfaceWrapper) GetBannedPlayers(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetBannedPlayers(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutBannedPlayers operation middleware
func (siw *ServerInterfaceWrapper) PutBannedPlayers(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutBannedPlayers(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostDeop operation middleware
func (siw *ServerInterfaceWrapper) PostDeop(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostDeop(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostOp operation middleware
func (siw *ServerInterfaceWrapper) PostOp(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostOp(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// GetOps operation middleware
func (siw *ServerInterfaceWrapper) GetOps(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetOps(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutOps operation middleware
func (siw *ServerInterfaceWrapper) PutOps(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutOps(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostPardon operation middleware
func (siw *ServerInterfaceWrapper) PostPardon(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostPardon(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostPardonIp operation middleware
func (siw *ServerInterfaceWrapper) PostPardonIp(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostPardonIp(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PutProperties operation middleware
func (siw *ServerInterfaceWrapper) PutProperties(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PutProperties(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostRestart operation middleware
func (siw *ServerInterfaceWrapper) PostRestart(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostRestart(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostSetVersion operation middleware
func (siw *ServerInterfaceWrapper) PostSetVersion(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
var err error
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
// Parameter object where we will unmarshal all parameters from the context
var params PostSetVersionParams
// ------------- Optional query parameter "version" -------------
err = runtime.BindQueryParameter("form", true, false, "version", r.URL.Query(), ¶ms.Version)
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostSetVersion(w, r, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostStart operation middleware
func (siw *ServerInterfaceWrapper) PostStart(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostStart(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
// PostStop operation middleware
func (siw *ServerInterfaceWrapper) PostStop(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = context.WithValue(ctx, APIKeyAuthScopes, []string{})
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.PostStop(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
type UnescapedCookieParamError struct {
ParamName string
Err error
}
func (e *UnescapedCookieParamError) Error() string {
return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}
func (e *UnescapedCookieParamError) Unwrap() error {
return e.Err
}
type UnmarshalingParamError struct {
ParamName string
Err error
}
func (e *UnmarshalingParamError) Error() string {
return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}
func (e *UnmarshalingParamError) Unwrap() error {
return e.Err
}
type RequiredParamError struct {
ParamName string
}
func (e *RequiredParamError) Error() string {
return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}
type RequiredHeaderError struct {
ParamName string
Err error
}
func (e *RequiredHeaderError) Error() string {
return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}
func (e *RequiredHeaderError) Unwrap() error {
return e.Err
}
type InvalidParamFormatError struct {
ParamName string
Err error
}
func (e *InvalidParamFormatError) Error() string {
return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}
func (e *InvalidParamFormatError) Unwrap() error {
return e.Err
}
type TooManyValuesForParamError struct {
ParamName string
Count int
}
func (e *TooManyValuesForParamError) Error() string {
return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}
// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{})
}
type ChiServerOptions struct {
BaseURL string
BaseRouter chi.Router
Middlewares []MiddlewareFunc
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}
// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{
BaseRouter: r,
})
}
func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{
BaseURL: baseURL,
BaseRouter: r,
})
}
// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler {
r := options.BaseRouter
if r == nil {
r = chi.NewRouter()
}
if options.ErrorHandlerFunc == nil {
options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
wrapper := ServerInterfaceWrapper{
Handler: si,
HandlerMiddlewares: options.Middlewares,
ErrorHandlerFunc: options.ErrorHandlerFunc,
}
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/allowlist", wrapper.GetAllowlist)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/allowlist", wrapper.PutAllowlist)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/allowlist/add", wrapper.PostAllowlistAdd)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/allowlist/remove", wrapper.PostAllowlistRemove)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/args", wrapper.PutArgs)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/available-versions", wrapper.GetAvailableVersions)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/ban", wrapper.PostBan)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/ban-ip", wrapper.PostBanIp)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/banned-ips", wrapper.GetBannedIps)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/banned-ips", wrapper.PutBannedIps)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/banned-players", wrapper.GetBannedPlayers)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/banned-players", wrapper.PutBannedPlayers)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/deop", wrapper.PostDeop)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/op", wrapper.PostOp)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/ops", wrapper.GetOps)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/ops", wrapper.PutOps)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/pardon", wrapper.PostPardon)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/pardon-ip", wrapper.PostPardonIp)
})
r.Group(func(r chi.Router) {
r.Put(options.BaseURL+"/properties", wrapper.PutProperties)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/restart", wrapper.PostRestart)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/set-version", wrapper.PostSetVersion)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/start", wrapper.PostStart)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/stop", wrapper.PostStop)
})
return r
}
package api
import (
"encoding/json"
"io"
"net/http"
)
type ServerController struct {
msi MinecraftServerInterface
}
// GetAllowlist implements ServerInterface.
func (s *ServerController) GetAllowlist(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// GetAvailableVersions implements ServerInterface.
func (s *ServerController) GetAvailableVersions(w http.ResponseWriter, r *http.Request) {
versions := s.msi.Versions()
if versions == nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Add("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(versions); err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
}
// GetBannedIps implements ServerInterface.
func (s *ServerController) GetBannedIps(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// GetBannedPlayers implements ServerInterface.
func (s *ServerController) GetBannedPlayers(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// GetOps implements ServerInterface.
func (s *ServerController) GetOps(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostAllowlistAdd implements ServerInterface.
func (s *ServerController) PostAllowlistAdd(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostAllowlistRemove implements ServerInterface.
func (s *ServerController) PostAllowlistRemove(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostBan implements ServerInterface.
func (s *ServerController) PostBan(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostBanIp implements ServerInterface.
func (s *ServerController) PostBanIp(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostDeop implements ServerInterface.
func (s *ServerController) PostDeop(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostOp implements ServerInterface.
func (s *ServerController) PostOp(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostPardon implements ServerInterface.
func (s *ServerController) PostPardon(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostPardonIp implements ServerInterface.
func (s *ServerController) PostPardonIp(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostRestart implements ServerInterface.
func (s *ServerController) PostRestart(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostSetVersion implements ServerInterface.
func (s *ServerController) PostSetVersion(w http.ResponseWriter, r *http.Request, params PostSetVersionParams) {
panic("unimplemented")
}
// PostStart implements ServerInterface.
func (s *ServerController) PostStart(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PostStop implements ServerInterface.
func (s *ServerController) PostStop(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutAllowlist implements ServerInterface.
func (s *ServerController) PutAllowlist(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutArgs implements ServerInterface.
func (s *ServerController) PutArgs(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutBannedIps implements ServerInterface.
func (s *ServerController) PutBannedIps(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutBannedPlayers implements ServerInterface.
func (s *ServerController) PutBannedPlayers(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutOps implements ServerInterface.
func (s *ServerController) PutOps(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
// PutProperties implements ServerInterface.
func (s *ServerController) PutProperties(w http.ResponseWriter, r *http.Request) {
panic("unimplemented")
}
type MinecraftServerConfig struct {
Version string `json:"version,omitempty"`
}
type MinecraftServerInterface interface {
// allowlist methods
Allowlist() *Allowlist
AllowPlayer(p *PlayerInfo) error
DisallowPlayer(p *PlayerInfo) error
// ban and unban methods
BannedIPs() *BannedIPList
BannedPlayers() *BannedPlayerList
BanIP(ip *BannedIP) error
BanPlayer(p *BannedPlayer) error
PardonIP(ip string) error
PardonPlayer(p *PlayerInfo) error
// config files initialization methods
CreateAllowlist()
CreateArgs()
CreateBannedIPs()
CreateBannedPlayers()
CreateConfig()
CreateProperties()
CreateOperators()
CreateVersions()
// server operator methods
Deop(p *PlayerInfo) error
Op(op *ServerOperator) error
Ops() *ServerOperatorList
// config files loading methods
LoadAllowlist(file io.Reader) error
LoadArgs(file io.Reader) error
LoadBannedIPs(file io.Reader) error
LoadBannedPlayers(file io.Reader) error
LoadConfig(file io.Reader) error
LoadConfigs() error
LoadOperators(file io.Reader) error
LoadProperties(file io.Reader) error
LoadVersions(file io.Reader) error
// miscellaneous get config methods:
Args() *ServerArguments
Config() *MinecraftServerConfig
Properties() *ServerProperties
Versions() *[]string
// save config files methods
SaveAllowlist(file io.Writer) error
SaveArgs(file io.Writer) error
SaveBannedIPs(file io.Writer) error
SaveBannedPlayers(file io.Writer) error
SaveConfig(file io.Writer) error
SaveOperators(file io.Writer) error
SaveProperties(file io.Writer) error
// update server configs methods (doesn't save to disk)
SetAllowlist(a *Allowlist)
SetArgs(args *ServerArguments)
SetBannedPlayers(bp *BannedPlayerList)
SetVersion(version string) error
SetBannedIPs(bp *BannedIPList)
SetOperators(ops *ServerOperatorList)
SetProperties(props *ServerProperties)
// mc server process management methods
Start() error
Stop() error
Restart() error
}
var _ ServerInterface = (*ServerController)(nil)
func NewServerController(msi MinecraftServerInterface) ServerInterface {
return &ServerController{msi}
}
package minecraft
import (
"encoding/json"
"errors"
"fmt"
"io"
"log"
"github.com/raian621/go-mcsc/api"
)
var (
ErrPlayerNotInAllowlist = errors.New("player is not in server allowlist")
)
// Adds a player to the Minecraft server's allowlist.
//
// If the Minecraft server process is not currently running, the player is only
// added to the in-memory allowlist and will not be added to the Minecraft
// server's allowlist file until the JavaMinecraftServer's SaveAllowList method
// is called.
//
// If the Minecraft server process is currently running, the command `/whitelist
// <playername>` is sent to the Minecraft server console and the player will be
// added to the Minecraft server's allowlist and the in-memory allowlist upon
// success.
func (m *JavaMinecraftServer) AllowPlayer(p *api.PlayerInfo) error {
m.Lock()
defer m.Unlock()
if m.allowlist == nil {
return ErrNilConfig
}
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/whitelist add %s", *p.Name)); err != nil {
return err
}
}
*m.allowlist = append(*m.allowlist, *p)
return nil
}
// Allowlist implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Allowlist() *api.Allowlist {
m.Lock()
defer m.Unlock()
if m.allowlist == nil {
return nil
}
allowlistCpy := *m.allowlist
return &allowlistCpy
}
// Removes a player from the Minecraft server's allowlist.
//
// If the Minecraft server process is not currently running, the player is only
// removed from the in-memory allowlist and will not be removed from the
// Minecraft server's allowlist file until the JavaMinecraftServer's
// SaveAllowList method is called.
//
// If the Minecraft server process is currently running, the command `/whitelist
// remove <playername>` is sent to the Minecraft server console and the player will be
// added to the Minecraft server's allowlist and the in-memory allowlist upon
// success.func (m *JavaMinecraftServer) DisallowPlayer(p api.PlayerInfo) error {
func (m *JavaMinecraftServer) DisallowPlayer(p *api.PlayerInfo) error {
m.Lock()
defer m.Unlock()
if m.allowlist == nil {
return ErrNilConfig
}
if len(*m.allowlist) == 0 {
return ErrPlayerNotInAllowlist
}
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/whitelist remove %s", *p.Name)); err != nil {
return err
}
}
idx := -1
for i, player := range *m.allowlist {
if *player.Name == *p.Name && *player.Uuid == *p.Uuid {
idx = i
break
}
}
if idx == -1 {
return ErrPlayerNotInAllowlist
}
*m.allowlist = append((*m.allowlist)[:idx], (*m.allowlist)[idx+1:]...)
return nil
}
func (m *JavaMinecraftServer) CreateAllowlist() {
m.Lock()
defer m.Unlock()
m.allowlist = ref(make(api.Allowlist, 0))
}
func (m *JavaMinecraftServer) LoadAllowlist(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.allowlist == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.allowlist)
}
func (m *JavaMinecraftServer) SaveAllowlist(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.allowlist == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.allowlist)
}
func (m *JavaMinecraftServer) SetAllowlist(a *api.Allowlist) {
m.Lock()
defer m.Unlock()
if m.console != nil {
playerlist := make(map[string]bool, 0)
for _, player := range *m.allowlist {
playerlist[*player.Name] = false
}
for _, player := range *a {
playerlist[*player.Name] = true
}
for name, allowed := range playerlist {
if allowed {
if err := m.console.SendCommand(fmt.Sprintf("/whitelist add %s", name)); err != nil {
log.Println(err)
return
}
} else {
if err := m.console.SendCommand(fmt.Sprintf("/whitelist remove %s", name)); err != nil {
log.Println(err)
return
}
}
}
}
m.allowlist = a
}
package minecraft
import (
"encoding/json"
"fmt"
"io"
"strconv"
"github.com/raian621/go-mcsc/api"
)
func NewServerArgs() *api.ServerArguments {
return &api.ServerArguments{
MemoryStartGB: ref(1),
MemoryMaxGB: ref(2),
}
}
func BuildStringArgs(version string, args *api.ServerArguments) []string {
strArgs := []string{"java"}
strArgs = append(
strArgs,
fmt.Sprintf("-Xms%dG", *args.MemoryStartGB),
fmt.Sprintf("-Xmx%dG", *args.MemoryMaxGB),
"-jar",
fmt.Sprintf("server-%s.jar", version),
"--nogui",
)
if args.BonusChest != nil && *args.BonusChest {
strArgs = append(strArgs, "--bonusChest")
}
if args.Demo != nil && *args.Demo {
strArgs = append(strArgs, "--demo")
}
if args.EraseCache != nil && *args.EraseCache {
strArgs = append(strArgs, "--eraseCache")
}
if args.ForceUpgrade != nil && *args.ForceUpgrade {
strArgs = append(strArgs, "--forceUpgrade")
}
if args.SafeMode != nil && *args.SafeMode {
strArgs = append(strArgs, "--safeMode")
}
if args.ServerID != nil && len(*args.ServerID) > 0 {
strArgs = append(strArgs, "--serverId", *args.ServerID)
}
if args.SinglePlayer != nil && len(*args.SinglePlayer) > 0 {
strArgs = append(strArgs, "--singleplayer", *args.SinglePlayer)
}
if args.Universe != nil && len(*args.Universe) > 0 {
strArgs = append(strArgs, "--universe", *args.Universe)
}
if args.World != nil && len(*args.World) > 0 {
strArgs = append(strArgs, "--world", *args.World)
}
if args.Port != nil && *args.Port > 0 {
strArgs = append(strArgs, "--port", strconv.FormatInt(int64(*args.Port), 10))
}
return strArgs
}
func (m *JavaMinecraftServer) Args() *api.ServerArguments {
m.Lock()
defer m.Unlock()
if m.args == nil {
return nil
}
argsCpy := *m.args
return &argsCpy
}
func (m *JavaMinecraftServer) CreateArgs() {
m.Lock()
defer m.Unlock()
m.args = NewServerArgs()
}
func (m *JavaMinecraftServer) LoadArgs(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.args == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.args)
}
func (m *JavaMinecraftServer) SaveArgs(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.args == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.args)
}
func (m *JavaMinecraftServer) SetArgs(args *api.ServerArguments) {
m.Lock()
defer m.Unlock()
m.args = args
}
package minecraft
import (
"encoding/json"
"errors"
"fmt"
"io"
"log"
"github.com/raian621/go-mcsc/api"
)
var ErrNotInBannedIPs = errors.New("IP was not in ban list")
// BanIP implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) BanIP(ip *api.BannedIP) error {
m.Lock()
defer m.Unlock()
if m.bannedIPs == nil {
return ErrNilConfig
}
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/ban-ip %s", ip.Ip)); err != nil {
return nil
}
}
*m.bannedIPs = append(*m.bannedIPs, *ip)
return nil
}
// BannedIPs implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) BannedIPs() *api.BannedIPList {
m.Lock()
defer m.Unlock()
if m.bannedIPs == nil {
return nil
}
bannedIPsCpy := make(api.BannedIPList, len(*m.bannedIPs))
copy(*m.bannedIPs, bannedIPsCpy)
return &bannedIPsCpy
}
// PardonIP implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) PardonIP(ip string) error {
m.Lock()
defer m.Unlock()
if m.bannedIPs == nil {
return ErrNilConfig
}
idx := -1
for i, b := range *m.bannedIPs {
if b.Ip == ip {
idx = i
break
}
}
if idx == -1 {
return ErrNotInBannedIPs
}
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/pardon-ip %s", ip)); err != nil {
return err
}
} else {
*m.bannedIPs = append((*m.bannedIPs)[:idx], (*m.bannedIPs)[:idx+1]...)
}
return nil
}
func (m *JavaMinecraftServer) CreateBannedIPs() {
m.Lock()
defer m.Unlock()
m.bannedIPs = ref(make(api.BannedIPList, 0))
}
func (m *JavaMinecraftServer) LoadBannedIPs(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.bannedIPs == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.bannedIPs)
}
func (m *JavaMinecraftServer) SaveBannedIPs(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.bannedIPs == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.bannedIPs)
}
func (m *JavaMinecraftServer) SetBannedIPs(b *api.BannedIPList) {
m.Lock()
defer m.Unlock()
if m.console != nil {
bannedIPs := make(map[api.BannedIP]bool, 0)
for i := range *m.bannedIPs {
bannedIPs[(*m.bannedIPs)[i]] = false
}
for i := range *b {
bannedIPs[(*b)[i]] = true
}
for bannedIP, banned := range bannedIPs {
if banned {
if err := m.console.SendCommand(fmt.Sprintf("/ban-ip %s", bannedIP.Ip)); err != nil {
log.Println(err)
return
}
} else {
if err := m.console.SendCommand(fmt.Sprintf("/pardon-ip %s", bannedIP.Ip)); err != nil {
log.Println(err)
return
}
}
}
}
m.bannedIPs = b
}
package minecraft
import (
"encoding/json"
"errors"
"fmt"
"io"
"github.com/raian621/go-mcsc/api"
)
var ErrNotInBannedPlayers = errors.New("player not in banned players list")
// BanPlayer implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) BanPlayer(p *api.BannedPlayer) error {
m.Lock()
defer m.Unlock()
if m.bannedPlayers == nil {
return ErrNilConfig
}
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/ban %s", *p.Name)); err != nil {
return err
}
}
*m.bannedPlayers = append(*m.bannedPlayers, *p)
return nil
}
// PardonPlayer implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) PardonPlayer(p *api.PlayerInfo) error {
m.Lock()
defer m.Unlock()
if m.bannedPlayers == nil {
return ErrNilConfig
}
idx := -1
for i, b := range *m.bannedPlayers {
if *b.Name == *p.Name && b.Uuid == *p.Uuid {
idx = i
break
}
}
if idx == -1 {
return ErrNotInBannedPlayers
}
*m.bannedPlayers = append((*m.bannedPlayers)[:idx], (*m.bannedPlayers)[idx+1:]...)
if m.console != nil {
if err := m.console.SendCommand(fmt.Sprintf("/pardon %s", *p.Name)); err != nil {
return err
}
}
return nil
}
func (m *JavaMinecraftServer) BannedPlayers() *api.BannedPlayerList {
m.Lock()
defer m.Unlock()
if m.bannedPlayers == nil {
return nil
}
bannedPlayersCpy := make(api.BannedPlayerList, len(*m.bannedPlayers))
copy(*m.bannedPlayers, bannedPlayersCpy)
return &bannedPlayersCpy
}
func (m *JavaMinecraftServer) CreateBannedPlayers() {
m.bannedPlayers = ref(make(api.BannedPlayerList, 0))
}
func (m *JavaMinecraftServer) LoadBannedPlayers(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.bannedPlayers == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.bannedPlayers)
}
func (m *JavaMinecraftServer) SaveBannedPlayers(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.bannedPlayers == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.bannedPlayers)
}
func (m *JavaMinecraftServer) SetBannedPlayers(b *api.BannedPlayerList) {
m.Lock()
defer m.Unlock()
m.bannedPlayers = b
}
package minecraft
import (
"encoding/json"
"io"
"github.com/raian621/go-mcsc/api"
)
type ServerConfig struct {
Version string `json:"version"`
}
func NewServerConfig() *api.MinecraftServerConfig {
return &api.MinecraftServerConfig{
Version: "1.20.6",
}
}
func (m *JavaMinecraftServer) Config() *api.MinecraftServerConfig {
m.Lock()
defer m.Unlock()
if m.config == nil {
return nil
}
configCpy := *m.config
return &configCpy
}
func (m *JavaMinecraftServer) CreateConfig() {
m.config = NewServerConfig()
}
func (m *JavaMinecraftServer) LoadConfig(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.config == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.config)
}
func (m *JavaMinecraftServer) SaveConfig(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.config == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.config)
}
func (m *JavaMinecraftServer) SetConfig(c *api.MinecraftServerConfig) {
m.Lock()
defer m.Unlock()
m.config = c
}
package minecraft
import (
"bufio"
"fmt"
"io"
"os/exec"
)
type Console struct {
stdin *bufio.Writer
stdout *bufio.Reader
stderr *bufio.Reader
}
func NewConsole(cmd *exec.Cmd) (*Console, error) {
var (
stdin io.WriteCloser
stdout io.ReadCloser
stderr io.ReadCloser
err error
)
if stdin, err = cmd.StdinPipe(); err != nil {
return nil, err
}
if stdout, err = cmd.StdoutPipe(); err != nil {
return nil, err
}
if stderr, err = cmd.StdoutPipe(); err != nil {
return nil, err
}
return &Console{
stdin: bufio.NewWriter(stdin),
stdout: bufio.NewReader(stdout),
stderr: bufio.NewReader(stderr),
}, nil
}
func (c Console) SendCommand(cmd string) error {
_, err := c.stdin.WriteString(
fmt.Sprintf("%s\r\n", cmd),
)
if err != nil {
return err
}
return c.stdin.Flush()
}
func (c Console) ReadLine() (string, error) {
return c.stdout.ReadString('\n')
}
func (c Console) ReadError() (string, error) {
return c.stderr.ReadString('\n')
}
package minecraft
import (
"encoding/json"
"errors"
"io"
"github.com/raian621/go-mcsc/api"
)
var ErrNotInOps = errors.New("player not in server operator list")
// Deop implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Deop(p *api.PlayerInfo) error {
m.Lock()
defer m.Unlock()
if m.ops == nil {
return ErrNilConfig
}
idx := -1
for i, op := range *m.ops {
if op.Name == *p.Name && op.Uuid == *p.Uuid {
idx = i
break
}
}
if idx == -1 {
return ErrNotInOps
}
*m.ops = append((*m.ops)[:idx], (*m.ops)[idx+1:]...)
return nil
}
// Op implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Op(op *api.ServerOperator) error {
m.Lock()
defer m.Unlock()
if m.ops == nil {
return ErrNilConfig
}
*m.ops = append(*m.ops, *op)
return nil
}
// Ops implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Ops() *api.ServerOperatorList {
m.Lock()
defer m.Unlock()
if m.ops == nil {
return nil
}
serverOperatorsCpy := make(api.ServerOperatorList, len(*m.ops))
copy(*m.ops, serverOperatorsCpy)
return &serverOperatorsCpy
}
func (m *JavaMinecraftServer) CreateOperators() {
m.Lock()
defer m.Unlock()
m.ops = ref(make(api.ServerOperatorList, 0))
}
func (m *JavaMinecraftServer) LoadOperators(file io.Reader) error {
m.Lock()
defer m.Unlock()
if m.ops == nil {
return ErrNilConfig
}
return json.NewDecoder(file).Decode(m.ops)
}
func (m *JavaMinecraftServer) SaveOperators(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.ops == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.ops)
}
func (m *JavaMinecraftServer) SetOperators(ops *api.ServerOperatorList) {
m.Lock()
defer m.Unlock()
m.ops = ops
}
package minecraft
import (
"encoding/json"
"io"
"github.com/raian621/go-mcsc/api"
)
func NewServerProperties() *api.ServerProperties {
return &api.ServerProperties{
AcceptTransfers: ref(false),
AllowFlight: ref(false),
AllowNether: ref(true),
BroadcastConsoleToOps: ref(true),
BroadcastRCONToOps: ref(true),
Difficulty: ref[api.ServerPropertiesDifficulty]("easy"),
EnableCommandBlock: ref(false),
EnableJMXMonitoring: ref(false),
EnableQuery: ref(false),
EnableRCON: ref(false),
EnableStatus: ref(true),
EnforceSecureProfile: ref(true),
EnforceWhitelist: ref(false),
EntityBroadcastRangePercentage: ref(100),
ForceGamemode: ref(false),
FunctionPermissionLevel: ref(2),
Gamemode: ref[api.ServerPropertiesGamemode]("survival"),
GenerateStructures: ref(true),
GeneratorSettings: ref("{}"),
Hardcore: ref(false),
HideOnlinePlayers: ref(false),
InitialDisabledPacks: ref(""),
InitialEnabledPacks: ref("vanilla"),
LevelName: ref("world"),
LevelSeed: ref(""),
LevelType: ref("minecraft\\:normal"),
LogIPs: ref(true),
MaxChainedNeighborUpdates: ref(1000000),
MaxPlayers: ref(20),
MaxTickTime: ref(60000),
MaxWorldSize: ref(29999984),
MOTD: ref("A Minecraft Server"),
NetworkCompressionThreshold: ref(256),
OnlineMode: ref(true),
OpPermissionLevel: ref(4),
PlayerIdleTimeout: ref(0),
PreventProxyConnections: ref(false),
PreviewsChat: ref(false),
PVP: ref(true),
QueryPort: ref(25565),
RateLimit: ref(0),
RCONPassword: ref(""),
RCONPort: ref(25575),
RegionFileCompression: ref("deflate"),
ResourcePack: ref(""),
RequireResourcePack: ref(false),
ResourcePackID: ref(""),
ResourcePackPrompt: ref(""),
ResourcePackSHA1: ref(""),
ServerIP: ref(""),
ServerPort: ref(25565),
SimulationDistance: ref(10),
SnooperEnabled: ref(true),
SpawnAnimals: ref(true),
SpawnMonsters: ref(true),
SpawnNPCs: ref(true),
SpawnProtection: ref(16),
SyncChunkWrites: ref(true),
TextFilteringConfig: ref(""),
UseNativeTransport: ref(true),
ViewDistance: ref(10),
Whitelist: ref(false),
}
}
func (m *JavaMinecraftServer) Properties() *api.ServerProperties {
m.Lock()
defer m.Unlock()
if m.properties == nil {
return nil
}
propsCpy := *m.properties
return &propsCpy
}
// UpdateProperties implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) UpdateProperties(props api.ServerProperties) error {
panic("unimplemented")
}
func (m *JavaMinecraftServer) CreateProperties() {
m.Lock()
defer m.Unlock()
m.properties = NewServerProperties()
}
func (m *JavaMinecraftServer) LoadProperties(file io.Reader) error {
m.Lock()
defer m.Unlock()
return json.NewDecoder(file).Decode(m.properties)
}
func (m *JavaMinecraftServer) SaveProperties(file io.Writer) error {
m.Lock()
defer m.Unlock()
if m.properties == nil {
return ErrNilConfig
}
return json.NewEncoder(file).Encode(m.properties)
}
func (m *JavaMinecraftServer) SetProperties(properties *api.ServerProperties) {
m.Lock()
defer m.Unlock()
m.properties = properties
}
package minecraft
import (
"errors"
"io"
"os"
"path"
"sync"
"github.com/raian621/go-mcsc/api"
)
var (
ErrFilepathsNotProvided error = errors.New("filepaths for configuration files not provided")
ErrNilConfig error = errors.New("config object was not initialized")
)
type MinecraftServer struct {
allowlist *api.Allowlist
args *api.ServerArguments
bannedIPs *api.BannedIPList
bannedPlayers *api.BannedPlayerList
config *api.MinecraftServerConfig
filepaths *MinecraftServerConfigFilepaths
ops *api.ServerOperatorList
properties *api.ServerProperties
console *Console
// process *exec.Cmd
versions *[]string
mutex sync.Mutex
}
type MinecraftServerConfigFilepaths struct {
Allowlist string
Args string
BannedPlayers string
BannedIPs string
Config string
Ops string
Properties string
PropertiesTemplate string
Versions string
}
type JavaMinecraftServer MinecraftServer
func (m *JavaMinecraftServer) Lock() { m.mutex.Lock() }
func (m *JavaMinecraftServer) Unlock() { m.mutex.Unlock() }
func (m *JavaMinecraftServer) TryLock() { m.mutex.TryLock() }
func (m *JavaMinecraftServer) LoadConfigs() error {
if m.filepaths == nil {
return ErrFilepathsNotProvided
}
loadData := []struct {
LoadFn func(file io.Reader) error
SaveFn func(file io.Writer) error
CreateFn func()
Filepath string
}{
{
LoadFn: m.LoadAllowlist,
CreateFn: m.CreateAllowlist,
SaveFn: m.SaveAllowlist,
Filepath: m.filepaths.Allowlist,
},
{
LoadFn: m.LoadArgs,
CreateFn: m.CreateArgs,
SaveFn: m.SaveArgs,
Filepath: m.filepaths.Args,
},
{
LoadFn: m.LoadBannedIPs,
CreateFn: m.CreateBannedIPs,
SaveFn: m.SaveBannedIPs,
Filepath: m.filepaths.Allowlist,
},
{
LoadFn: m.LoadBannedPlayers,
CreateFn: m.CreateBannedPlayers,
SaveFn: m.SaveBannedPlayers,
Filepath: m.filepaths.BannedPlayers,
},
{
LoadFn: m.LoadConfig,
CreateFn: m.CreateConfig,
SaveFn: m.SaveConfig,
Filepath: m.filepaths.Config,
},
{
LoadFn: m.LoadOperators,
CreateFn: m.CreateOperators,
SaveFn: m.SaveOperators,
Filepath: m.filepaths.Ops,
},
{
LoadFn: m.LoadProperties,
CreateFn: m.CreateProperties,
SaveFn: m.SaveProperties,
Filepath: m.filepaths.Properties,
},
{
LoadFn: m.LoadVersions,
CreateFn: m.CreateVersions,
SaveFn: func(file io.Writer) error { return nil },
Filepath: m.filepaths.Versions,
},
}
for _, ld := range loadData {
if err := loadJSON(ld.LoadFn, ld.SaveFn, ld.CreateFn, ld.Filepath); err != nil {
return err
}
}
return saveServerPropertiesTemplate(
m.properties,
m.filepaths.PropertiesTemplate,
path.Join(path.Dir(m.filepaths.Properties), "server.properties"),
)
}
// Restart implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Restart() error {
panic("unimplemented")
}
// Start implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Start() error {
m.Lock()
defer m.Unlock()
return nil
// version := serverConfig.LockAndGetData().(*ServerConfig).Version
// serverConfig.Unlock()
// if err := downloadServerVersion("server-data", version); err != nil {
// return err
// }
// if serverCmd != nil && serverCmd.Process.Signal(syscall.Signal(0)) == nil {
// return nil
// }
// if err := stopExistingMinecraftServers(); err != nil {
// return err
// }
// args := serverArgs.LockAndGetData().(*ServerArgs)
// argsStr := BuildStringArgs(args)
// log.Println("args", argsStr)
// serverArgs.Unlock()
// serverCmd = exec.Command(argsStr[0], argsStr[1:]...)
// go func() {
// log.Println("starting minecraft server process...")
// oldDir, err := os.Getwd()
// if err != nil {
// log.Println(err)
// return
// }
// if err := os.Chdir("server-data"); err != nil {
// log.Println(err)
// return
// }
// ServerConsole = new(ConsoleMonitor)
// ServerConsole.Stdin, err = serverCmd.StdinPipe()
// if err != nil {
// log.Fatalln("error creating stdin pipe for minecraft server:", err)
// }
// ServerConsole.Stdout, err = serverCmd.StdoutPipe()
// if err != nil {
// log.Fatalln("error creating stdout pipe for minecraft server:", err)
// }
// ServerConsole.Stderr, err = serverCmd.StderrPipe()
// if err != nil {
// log.Fatalln("error creating stderr pipe for minecraft server:", err)
// }
// if err := serverCmd.Start(); err != nil {
// log.Println("error starting server:", err)
// serverCmd = nil
// return
// }
// if err := os.Chdir(oldDir); err != nil {
// log.Println(err)
// return
// }
// log.Println("minecraft server process started")
// }()
// return nil
}
// Start implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Stop() error {
panic("unimplemented")
}
func NewJavaMinecraftServer(filepaths *MinecraftServerConfigFilepaths) api.MinecraftServerInterface {
jms := JavaMinecraftServer{filepaths: filepaths}
return &jms
}
var _ api.MinecraftServerInterface = (*JavaMinecraftServer)(nil)
// func StartMinecraftServer() error {
// version := serverConfig.LockAndGetData().(*ServerConfig).Version
// serverConfig.Unlock()
// if err := downloadServerVersion("server-data", version); err != nil {
// return err
// }
// if serverCmd != nil && serverCmd.Process.Signal(syscall.Signal(0)) == nil {
// return nil
// }
// if err := stopExistingMinecraftServers(); err != nil {
// return err
// }
// args := serverArgs.LockAndGetData().(*ServerArgs)
// argsStr := BuildStringArgs(args)
// log.Println("args", argsStr)
// serverArgs.Unlock()
// serverCmd = exec.Command(argsStr[0], argsStr[1:]...)
// go func() {
// log.Println("starting minecraft server process...")
// oldDir, err := os.Getwd()
// if err != nil {
// log.Println(err)
// return
// }
// if err := os.Chdir("server-data"); err != nil {
// log.Println(err)
// return
// }
// ServerConsole = new(ConsoleMonitor)
// ServerConsole.Stdin, err = serverCmd.StdinPipe()
// if err != nil {
// log.Fatalln("error creating stdin pipe for minecraft server:", err)
// }
// ServerConsole.Stdout, err = serverCmd.StdoutPipe()
// if err != nil {
// log.Fatalln("error creating stdout pipe for minecraft server:", err)
// }
// ServerConsole.Stderr, err = serverCmd.StderrPipe()
// if err != nil {
// log.Fatalln("error creating stderr pipe for minecraft server:", err)
// }
// if err := serverCmd.Start(); err != nil {
// log.Println("error starting server:", err)
// serverCmd = nil
// return
// }
// if err := os.Chdir(oldDir); err != nil {
// log.Println(err)
// return
// }
// log.Println("minecraft server process started")
// }()
// return nil
// }
// func StopMinecraftServer() {
// if serverCmd != nil && serverCmd.Process.Signal(syscall.Signal(0)) == nil {
// if ServerConsole != nil {
// if !ServerConsole.TryLock() {
// return
// }
// if _, err := fmt.Fprintln(ServerConsole.Stdin, "/stop"); err != nil {
// log.Println("error sending stop command to server:", err)
// }
// ServerConsole.Stdin.Close()
// ServerConsole.Stdout.Close()
// ServerConsole.Stderr.Close()
// ServerConsole.Unlock()
// ServerConsole = nil
// }
// serverCmd = nil
// }
// }
// func stopExistingMinecraftServers() error {
// cmd := exec.Command("ps", "-ao", "args,pid")
// outBytes, err := cmd.Output()
// if err != nil {
// return err
// }
// // if there's no output
// if len(outBytes) == 0 {
// return nil
// }
// outStr := string(outBytes)
// commandData := strings.Split(outStr, "\n")[1:]
// pattern, err := regexp.Compile(`^java .*-jar server.jar.*`)
// if err != nil {
// log.Fatalln(err)
// }
// for _, cd := range commandData {
// if pattern.MatchString(cd) {
// split := strings.Split(cd, " ")
// pidStr := split[len(split)-1]
// pid, err := strconv.ParseInt(pidStr, 10, 64)
// if err != nil {
// log.Println(err)
// continue
// }
// log.Println("killing minecraft server process with PID", pid)
// process, err := os.FindProcess(int(pid))
// if err != nil {
// log.Println(err)
// continue
// }
// if err := process.Kill(); err != nil {
// log.Println(err)
// }
// }
// }
// return nil
// }
func CreateServerFolder(filepath string) error {
if err := os.Mkdir(filepath, os.ModePerm); !errors.Is(err, os.ErrExist) && err != nil {
return err
} else if errors.Is(err, os.ErrExist) {
return nil
}
if err := os.WriteFile(path.Join(filepath, "eula.txt"), []byte("eula=TRUE\n"), os.ModePerm); err != nil {
return err
}
return nil
}
package minecraft
import (
"io"
"log"
"os"
"text/template"
"github.com/raian621/go-mcsc/api"
)
// func downloadServerVersion(filepath, version string) error {
// file, err := os.Open("minecraft/data/server-download-links.json")
// defer func() {
// if err := file.Close(); err != nil {
// log.Println(err)
// }
// }()
// var versionsMap VersionMap
// if err != nil {
// return err
// }
// if err := versionsMap.Load(file); err != nil {
// return err
// }
// var (
// info VersionInfo
// ok bool
// )
// if info, ok = versionsMap[version]; !ok {
// return errors.New("unsupported version")
// }
// serverJarPath := path.Join(filepath, fmt.Sprintf("server-%s.jar", version))
// serverJarBytes, err := os.ReadFile(serverJarPath)
// if err != nil {
// if err := exec.Command("wget", info.Link, "-O", serverJarPath).Run(); err != nil {
// return err
// }
// serverJarBytes, err = os.ReadFile(serverJarPath)
// if err != nil {
// return err
// }
// }
// // verify downloaded file using checksum
// md5Bytes := md5.Sum(serverJarBytes)
// if info.Sum == string(md5Bytes[:]) {
// return nil
// }
// return nil
// }
func closeFile(file *os.File) {
if err := file.Close(); err != nil {
log.Println("unexpected error closing file:", err)
}
}
func saveServerPropertiesTemplate(props *api.ServerProperties, tmplFilepath, propertiesFilepath string) error {
tmpl, err := template.New("server.properties.tmpl").Parse(tmplFilepath)
if err != nil {
return err
}
file, err := os.Create(propertiesFilepath)
if err != nil {
return err
}
defer closeFile(file)
if err := tmpl.Execute(file, *props); err != nil {
return err
}
return nil
}
func loadJSON(
loadFn func(file io.Reader) error,
saveFn func(file io.Writer) error,
createFn func(),
filepath string,
) error {
file, err := os.Open(filepath)
if os.IsNotExist(err) {
file, err := os.Create(filepath)
if err != nil {
return err
}
defer closeFile(file)
createFn()
err = saveFn(file)
if err != nil {
return err
}
return nil
}
defer closeFile(file)
return loadFn(file)
}
func ref[T any](v T) *T { return &v }
package minecraft
import (
"encoding/json"
"errors"
"io"
"slices"
)
var ErrVersionUnsupported = errors.New("unsupported server version passed")
type VersionInfo struct {
Link string `json:"link"`
Sum string `json:"sum"` // md5 sum
}
type VersionMap map[string]VersionInfo
func (v VersionMap) Versions() []string {
versions := make([]string, 0, len(v))
for version := range v {
versions = append(versions, version)
}
slices.Sort(versions)
return versions
}
func (v *VersionMap) Load(file io.Reader) error {
return json.NewDecoder(file).Decode(v)
}
// SetVersion implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) SetVersion(version string) error {
if m.versions == nil {
return ErrNilConfig
}
supported := false
for _, supportedVersion := range *m.versions {
if version == supportedVersion {
supported = true
break
}
}
if !supported {
return ErrVersionUnsupported
}
m.config.Version = version
return nil
}
// Versions implements api.MinecraftServerInterface.
func (m *JavaMinecraftServer) Versions() *[]string {
m.Lock()
defer m.Unlock()
if m.versions == nil {
return nil
}
versionsCpy := make([]string, len(*m.versions))
copy(versionsCpy, *m.versions)
return &versionsCpy
}
func (m *JavaMinecraftServer) CreateVersions() {
m.Lock()
defer m.Unlock()
m.versions = ref(make([]string, 0))
}
func (m *JavaMinecraftServer) LoadVersions(file io.Reader) error {
m.Lock()
defer m.Unlock()
m.versions = new([]string)
versionsMap := make(VersionMap, 0)
if err := versionsMap.Load(file); err != nil {
return err
}
// TODO: do this in place
*m.versions = versionsMap.Versions()
return nil
}