console quality of life

This commit is contained in:
wish
2022-07-26 23:49:36 +10:00
parent 1d71938ef4
commit 528c2bcb27

View File

@@ -1,199 +1,217 @@
package main package main
import ( import (
"fmt" "fmt"
"os" "math/rand"
"os/signal" "os"
"syscall" "os/signal"
"time" "syscall"
"math/rand" "time"
"erupe-ce/config" "erupe-ce/config"
"erupe-ce/server/channelserver" "erupe-ce/server/channelserver"
"erupe-ce/server/discordbot" "erupe-ce/server/discordbot"
"erupe-ce/server/entranceserver" "erupe-ce/server/entranceserver"
"erupe-ce/server/launcherserver" "erupe-ce/server/launcherserver"
"erupe-ce/server/signserver" "erupe-ce/server/signserver"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
_ "github.com/lib/pq" _ "github.com/lib/pq"
"go.uber.org/zap" "go.uber.org/zap"
) )
// Temporary DB auto clean on startup for quick development & testing. // Temporary DB auto clean on startup for quick development & testing.
func cleanDB(db *sqlx.DB) { func cleanDB(db *sqlx.DB) {
_ = db.MustExec("DELETE FROM guild_characters") _ = db.MustExec("DELETE FROM guild_characters")
_ = db.MustExec("DELETE FROM guilds") _ = db.MustExec("DELETE FROM guilds")
_ = db.MustExec("DELETE FROM characters") _ = db.MustExec("DELETE FROM characters")
_ = db.MustExec("DELETE FROM sign_sessions") _ = db.MustExec("DELETE FROM sign_sessions")
_ = db.MustExec("DELETE FROM users") _ = db.MustExec("DELETE FROM users")
} }
func main() { func main() {
zapLogger, _ := zap.NewDevelopment() zapLogger, _ := zap.NewDevelopment()
defer zapLogger.Sync() defer zapLogger.Sync()
logger := zapLogger.Named("main") logger := zapLogger.Named("main")
logger.Info("Starting Erupe") logger.Info("Starting Erupe")
// Load the configuration. // Load the configuration.
erupeConfig, err := config.LoadConfig() erupeConfig, err := config.LoadConfig()
if err != nil { if err != nil {
logger.Fatal("Failed to load config", zap.Error(err)) preventClose(fmt.Sprintf("Failed to load config: %s", err.Error()))
} }
// Discord bot if erupeConfig.Database.Password == "" {
var discordBot *discordbot.DiscordBot = nil preventClose("Database password is blank")
}
if erupeConfig.Discord.Enabled {
bot, err := discordbot.NewDiscordBot(discordbot.DiscordBotOptions{ // Discord bot
Logger: logger, var discordBot *discordbot.DiscordBot = nil
Config: erupeConfig,
}) if erupeConfig.Discord.Enabled {
bot, err := discordbot.NewDiscordBot(discordbot.DiscordBotOptions{
if err != nil { Logger: logger,
logger.Fatal("Failed to create discord bot", zap.Error(err)) Config: erupeConfig,
} })
// Discord bot if err != nil {
err = bot.Start() preventClose(fmt.Sprintf("Failed to create Discord bot: %s", err.Error()))
}
if err != nil {
logger.Fatal("Failed to starts discord bot", zap.Error(err)) // Discord bot
} err = bot.Start()
discordBot = bot if err != nil {
} else { preventClose(fmt.Sprintf("Failed to start Discord bot: %s", err.Error()))
logger.Info("Discord bot is disabled") }
}
discordBot = bot
// Create the postgres DB pool. } else {
connectString := fmt.Sprintf( logger.Info("Discord bot is disabled")
"host=%s port=%d user=%s password=%s dbname= %s sslmode=disable", }
erupeConfig.Database.Host,
erupeConfig.Database.Port, // Create the postgres DB pool.
erupeConfig.Database.User, connectString := fmt.Sprintf(
erupeConfig.Database.Password, "host=%s port=%d user=%s password=%s dbname= %s sslmode=disable",
erupeConfig.Database.Database, erupeConfig.Database.Host,
) erupeConfig.Database.Port,
erupeConfig.Database.User,
db, err := sqlx.Open("postgres", connectString) erupeConfig.Database.Password,
if err != nil { erupeConfig.Database.Database,
logger.Fatal("Failed to open sql database", zap.Error(err)) )
}
db, err := sqlx.Open("postgres", connectString)
// Test the DB connection. if err != nil {
err = db.Ping() preventClose(fmt.Sprintf("Failed to open SQL database: %s", err.Error()))
if err != nil { }
logger.Fatal("Failed to ping database", zap.Error(err))
} // Test the DB connection.
logger.Info("Connected to database") err = db.Ping()
if err != nil {
// Clear existing tokens preventClose(fmt.Sprintf("Failed to ping database: %s", err.Error()))
_ = db.MustExec("DELETE FROM sign_sessions") }
_ = db.MustExec("DELETE FROM servers") logger.Info("Connected to database")
// Clean the DB if the option is on. // Clear existing tokens
if erupeConfig.DevMode && erupeConfig.DevModeOptions.CleanDB { _ = db.MustExec("DELETE FROM sign_sessions")
logger.Info("Cleaning DB") _ = db.MustExec("DELETE FROM servers")
cleanDB(db)
logger.Info("Done cleaning DB") // Clean the DB if the option is on.
} if erupeConfig.DevMode && erupeConfig.DevModeOptions.CleanDB {
logger.Info("Cleaning DB")
// Now start our server(s). cleanDB(db)
logger.Info("Done cleaning DB")
// Launcher HTTP server. }
launcherServer := launcherserver.NewServer(
&launcherserver.Config{ // Now start our server(s).
Logger: logger.Named("launcher"),
ErupeConfig: erupeConfig, // Launcher HTTP server.
DB: db, launcherServer := launcherserver.NewServer(
UseOriginalLauncherFiles: erupeConfig.Launcher.UseOriginalLauncherFiles, &launcherserver.Config{
}) Logger: logger.Named("launcher"),
err = launcherServer.Start() ErupeConfig: erupeConfig,
if err != nil { DB: db,
logger.Fatal("Failed to start launcher server", zap.Error(err)) UseOriginalLauncherFiles: erupeConfig.Launcher.UseOriginalLauncherFiles,
} })
logger.Info("Started launcher server") err = launcherServer.Start()
if err != nil {
// Entrance server. preventClose(fmt.Sprintf("Failed to start launcher server: %s", err.Error()))
entranceServer := entranceserver.NewServer( }
&entranceserver.Config{ logger.Info("Started launcher server")
Logger: logger.Named("entrance"),
ErupeConfig: erupeConfig, // Entrance server.
DB: db, entranceServer := entranceserver.NewServer(
}) &entranceserver.Config{
err = entranceServer.Start() Logger: logger.Named("entrance"),
if err != nil { ErupeConfig: erupeConfig,
logger.Fatal("Failed to start entrance server", zap.Error(err)) DB: db,
} })
logger.Info("Started entrance server") err = entranceServer.Start()
if err != nil {
// Sign server. preventClose(fmt.Sprintf("Failed to start entrance server: %s", err.Error()))
signServer := signserver.NewServer( }
&signserver.Config{ logger.Info("Started entrance server")
Logger: logger.Named("sign"),
ErupeConfig: erupeConfig, // Sign server.
DB: db, signServer := signserver.NewServer(
}) &signserver.Config{
err = signServer.Start() Logger: logger.Named("sign"),
if err != nil { ErupeConfig: erupeConfig,
logger.Fatal("Failed to start sign server", zap.Error(err)) DB: db,
} })
logger.Info("Started sign server") err = signServer.Start()
if err != nil {
var channels []*channelserver.Server preventClose(fmt.Sprintf("Failed to start sign server: %s", err.Error()))
channelQuery := "" }
si := 0 logger.Info("Started sign server")
ci := 0
count := 1 var channels []*channelserver.Server
for _, ee := range erupeConfig.Entrance.Entries { channelQuery := ""
rand.Seed(time.Now().UnixNano()) si := 0
// Randomly generate a season for the World ci := 0
season := rand.Intn(3)+1 count := 1
for _, ce := range ee.Channels { for _, ee := range erupeConfig.Entrance.Entries {
sid := (4096 + si * 256) + (16 + ci) rand.Seed(time.Now().UnixNano())
c := *channelserver.NewServer(&channelserver.Config{ // Randomly generate a season for the World
ID: uint16(sid), season := rand.Intn(3) + 1
Logger: logger.Named("channel-"+fmt.Sprint(count)), for _, ce := range ee.Channels {
ErupeConfig: erupeConfig, sid := (4096 + si*256) + (16 + ci)
DB: db, c := *channelserver.NewServer(&channelserver.Config{
DiscordBot: discordBot, ID: uint16(sid),
}) Logger: logger.Named("channel-" + fmt.Sprint(count)),
err = c.Start(int(ce.Port)) ErupeConfig: erupeConfig,
if err != nil { DB: db,
logger.Fatal("Failed to start channel", zap.Error(err)) DiscordBot: discordBot,
} else { })
channelQuery += fmt.Sprintf("INSERT INTO servers (server_id, season, current_players) VALUES (%d, %d, 0);", sid, season) err = c.Start(int(ce.Port))
channels = append(channels, &c) if err != nil {
logger.Info(fmt.Sprintf("Started channel server %d on port %d", count, ce.Port)) preventClose(fmt.Sprintf("Failed to start channel server: %s", err.Error()))
ci++ } else {
count++ channelQuery += fmt.Sprintf("INSERT INTO servers (server_id, season, current_players) VALUES (%d, %d, 0);", sid, season)
} channels = append(channels, &c)
} logger.Info(fmt.Sprintf("Started channel server %d on port %d", count, ce.Port))
ci = 0 ci++
si++ count++
} }
}
// Register all servers in DB ci = 0
_ = db.MustExec(channelQuery) si++
}
for _, c := range channels {
c.Channels = channels // Register all servers in DB
} _ = db.MustExec(channelQuery)
// Wait for exit or interrupt with ctrl+C. for _, c := range channels {
c := make(chan os.Signal, 1) c.Channels = channels
signal.Notify(c, os.Interrupt, syscall.SIGTERM) }
<-c
// Wait for exit or interrupt with ctrl+C.
logger.Info("Trying to shutdown gracefully") c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
for _, c := range channels { <-c
c.Shutdown()
} logger.Info("Trying to shutdown gracefully")
signServer.Shutdown()
entranceServer.Shutdown() for _, c := range channels {
launcherServer.Shutdown() c.Shutdown()
}
time.Sleep(1 * time.Second) signServer.Shutdown()
} entranceServer.Shutdown()
launcherServer.Shutdown()
time.Sleep(1 * time.Second)
}
func wait() {
for {
time.Sleep(time.Millisecond * 100)
}
}
func preventClose(text string) {
fmt.Println("\nFailed to start Erupe:\n" + text)
go wait()
fmt.Println("\nPress Enter/Return to exit...")
fmt.Scanln()
os.Exit(0)
}