main.go

package main

import (
	"BBS/background"
	"BBS/configs"
	"BBS/configs/runtime_config"
	"BBS/models/gorm_serializers"
	"BBS/routes"
	"BBS/search"
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"go.uber.org/zap"
)

const kDefaultShutdownTimeout = 60 * time.Second

var server *http.Server
var loggerInitialized = false

func initServer() (err error) {
	if err = configs.InitConfig("data/config/environment.yaml", "data/config/static_config.yaml"); err != nil {
		fmt.Printf("Init configs failed, err: %v\n", err)
		return
	}

	if err = configs.InitLogger(); err != nil {
		fmt.Printf("Init logger failed, err: %v\n", err)
		return
	}
	loggerInitialized = true

	if err = runtime_config.Load(); err != nil {
		fmt.Printf("Failed to load runtime configuration, err: %v\n", err)
		return
	}
	if err = configs.InitMySQL(); err != nil {
		fmt.Printf("Init MySQL failed, err: %v\n", err)
		return
	}
	gorm_serializers.RegisterGormSerializers()

	if err = configs.InitRedis(); err != nil {
		fmt.Printf("Init Redis failed, err: %v\n", err)
		return
	}

	if err = configs.InitRistretto(); err != nil {
		fmt.Printf("Init Ristretto failed, err: %v\n", err)
		return
	}

	if err = search.Init(); err != nil {
		fmt.Printf("Init search failed, err: %v\n", err)
		return
	}

	if err = background.Init(); err != nil {
		fmt.Printf("Init background failed, err: %v\n", err)
		return
	}

	configs.InitGin()
	routes.Init(configs.Gin)
	server = &http.Server{
		Addr:    fmt.Sprintf(":%d", configs.Config.AppConfig.Port),
		Handler: configs.Gin,
	}

	return
}

func shutdown() {
	zap.L().Info("Shutdown started")
	background.Pool.Stop()
	ctx, cancel := context.WithTimeout(context.Background(), kDefaultShutdownTimeout)
	defer cancel()
	if err := server.Shutdown(ctx); err != nil {
		zap.L().Fatal("HTTP server shutdown failed", zap.Error(err))
	}
	zap.L().Info("Shutdown success")
}

func main() {
	err := initServer()
	defer zap.L().Sync()
	defer configs.CloseMySQL()
	defer configs.CloseRedis()

	if err != nil {
		if loggerInitialized {
			zap.L().Error("Init server failed. ", zap.Error(err))
		} else {
			fmt.Printf("Init server failed: %v\n", err)
		}
		return
	}
	zap.L().Info("Init server success. ")

	go func() {
		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			fmt.Printf("server.ListenAndServe() failed: %v\n", err)
			zap.L().Fatal("server.ListenAndServe() failed. ", zap.Any("error", err))
		}
	}()

	sigs := make(chan os.Signal, 3)
	exit := make(chan bool, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR1, syscall.SIGUSR2)

	go func() {
		for {
			sig := <-sigs
			switch sig {
			case syscall.SIGINT, syscall.SIGTERM:
				exit <- true
			case syscall.SIGUSR1:
				configs.ReloadEnvironmentConfig()
			case syscall.SIGUSR2:
				configs.ReloadStaticConfig()
			}
		}
	}()

	<-exit
	shutdown()
}