refactor(bootstrap): move booting logic to bootstrap package (#1773)

* refactor(bootstrap): move booting to bootstrap package

* chore(log): reduce level of some callings of `utils.Log.Fatal`

* fix(s3): no shutdown after SIGTERM received

* fix: add handle hook

Author: KirCute

cmd/admin.go

@@ -6,6 +6,7 @@ package cmd
 import (
 	"fmt"
 
+	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
 	"github.com/OpenListTeam/OpenList/v4/internal/conf"
 	"github.com/OpenListTeam/OpenList/v4/internal/op"
 	"github.com/OpenListTeam/OpenList/v4/internal/setting"
@@ -20,8 +21,8 @@ var AdminCmd = &cobra.Command{
 	Aliases: []string{"password"},
 	Short:   "Show admin user's info and some operations about admin user's password",
 	Run: func(cmd *cobra.Command, args []string) {
-		Init()
-		defer Release()
+		bootstrap.Init()
+		defer bootstrap.Release()
 		admin, err := op.GetAdmin()
 		if err != nil {
 			utils.Log.Errorf("failed get admin user: %+v", err)
@@ -61,17 +62,17 @@ var ShowTokenCmd = &cobra.Command{
 	Use:   "token",
 	Short: "Show admin token",
 	Run: func(cmd *cobra.Command, args []string) {
-		Init()
-		defer Release()
+		bootstrap.Init()
+		defer bootstrap.Release()
 		token := setting.GetStr(conf.Token)
 		utils.Log.Infof("show admin token from CLI")
 		fmt.Println("Admin token:", token)
 	},
 }
 
 func setAdminPassword(pwd string) {
-	Init()
-	defer Release()
+	bootstrap.Init()
+	defer bootstrap.Release()
 	admin, err := op.GetAdmin()
 	if err != nil {
 		utils.Log.Errorf("failed get admin user: %+v", err)

cmd/cancel2FA.go

@@ -6,6 +6,7 @@ package cmd
 import (
 	"fmt"
 
+	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
 	"github.com/OpenListTeam/OpenList/v4/internal/op"
 	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
 	"github.com/spf13/cobra"
@@ -16,8 +17,8 @@ var Cancel2FACmd = &cobra.Command{
 	Use:   "cancel2fa",
 	Short: "Delete 2FA of admin user",
 	Run: func(cmd *cobra.Command, args []string) {
-		Init()
-		defer Release()
+		bootstrap.Init()
+		defer bootstrap.Release()
 		admin, err := op.GetAdmin()
 		if err != nil {
 			utils.Log.Errorf("failed to get admin user: %+v", err)

cmd/common.go

@@ -5,27 +5,10 @@ import (
 	"path/filepath"
 	"strconv"
 
-	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
-	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap/data"
-	"github.com/OpenListTeam/OpenList/v4/internal/db"
 	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
 	log "github.com/sirupsen/logrus"
 )
 
-func Init() {
-	bootstrap.InitConfig()
-	bootstrap.Log()
-	bootstrap.InitDB()
-	data.InitData()
-	bootstrap.InitStreamLimit()
-	bootstrap.InitIndex()
-	bootstrap.InitUpgradePatch()
-}
-
-func Release() {
-	db.Close()
-}
-
 var pid = -1
 var pidFile string
 

cmd/crypt.go

@@ -1,19 +1,17 @@
 package cmd
 
 import (
-	log "github.com/sirupsen/logrus"
-
 	"io"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
-	"github.com/spf13/cobra"
-
 	rcCrypt "github.com/rclone/rclone/backend/crypt"
 	"github.com/rclone/rclone/fs/config/configmap"
 	"github.com/rclone/rclone/fs/config/obscure"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
 )
 
 // encryption and decryption command format for Crypt driver

cmd/server.go

@@ -1,34 +1,13 @@
 package cmd
 
 import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
 	"os"
 	"os/signal"
-	"strconv"
-	"sync"
 	"syscall"
 	"time"
 
-	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
 	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
-	"github.com/OpenListTeam/OpenList/v4/internal/conf"
-	"github.com/OpenListTeam/OpenList/v4/internal/fs"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/OpenListTeam/OpenList/v4/server"
-	"github.com/OpenListTeam/OpenList/v4/server/middlewares"
-	"github.com/OpenListTeam/sftpd-openlist"
-	ftpserver "github.com/fclairamb/ftpserverlib"
-	"github.com/gin-gonic/gin"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/h2c"
-
-	"github.com/quic-go/quic-go/http3"
 )
 
 // ServerCmd represents the server command
@@ -38,161 +17,9 @@ var ServerCmd = &cobra.Command{
 	Long: `Start the server at the specified address
 the address is defined in config file`,
 	Run: func(cmd *cobra.Command, args []string) {
-		Init()
-		if conf.Conf.DelayedStart != 0 {
-			utils.Log.Infof("delayed start for %d seconds", conf.Conf.DelayedStart)
-			time.Sleep(time.Duration(conf.Conf.DelayedStart) * time.Second)
-		}
-		bootstrap.InitOfflineDownloadTools()
-		bootstrap.LoadStorages()
-		bootstrap.InitTaskManager()
-		if !flags.Debug && !flags.Dev {
-			gin.SetMode(gin.ReleaseMode)
-		}
-		r := gin.New()
-
-		// gin log
-		if conf.Conf.Log.Filter.Enable {
-			r.Use(middlewares.FilteredLogger())
-		} else {
-			r.Use(gin.LoggerWithWriter(log.StandardLogger().Out))
-		}
-		r.Use(gin.RecoveryWithWriter(log.StandardLogger().Out))
-
-		server.Init(r)
-		var httpHandler http.Handler = r
-		if conf.Conf.Scheme.EnableH2c {
-			httpHandler = h2c.NewHandler(r, &http2.Server{})
-		}
-		var httpSrv, httpsSrv, unixSrv *http.Server
-		var quicSrv *http3.Server
-		if conf.Conf.Scheme.HttpPort != -1 {
-			httpBase := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.Scheme.HttpPort)
-			fmt.Printf("start HTTP server @ %s\n", httpBase)
-			utils.Log.Infof("start HTTP server @ %s", httpBase)
-			httpSrv = &http.Server{Addr: httpBase, Handler: httpHandler}
-			go func() {
-				err := httpSrv.ListenAndServe()
-				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					utils.Log.Fatalf("failed to start http: %s", err.Error())
-				}
-			}()
-		}
-		if conf.Conf.Scheme.HttpsPort != -1 {
-			httpsBase := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.Scheme.HttpsPort)
-			fmt.Printf("start HTTPS server @ %s\n", httpsBase)
-			utils.Log.Infof("start HTTPS server @ %s", httpsBase)
-			httpsSrv = &http.Server{Addr: httpsBase, Handler: r}
-			go func() {
-				err := httpsSrv.ListenAndServeTLS(conf.Conf.Scheme.CertFile, conf.Conf.Scheme.KeyFile)
-				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					utils.Log.Fatalf("failed to start https: %s", err.Error())
-				}
-			}()
-			if conf.Conf.Scheme.EnableH3 {
-				fmt.Printf("start HTTP3 (quic) server @ %s\n", httpsBase)
-				utils.Log.Infof("start HTTP3 (quic) server @ %s", httpsBase)
-				r.Use(func(c *gin.Context) {
-					if c.Request.TLS != nil {
-						port := conf.Conf.Scheme.HttpsPort
-						c.Header("Alt-Svc", fmt.Sprintf("h3=\":%d\"; ma=86400", port))
-					}
-					c.Next()
-				})
-				quicSrv = &http3.Server{Addr: httpsBase, Handler: r}
-				go func() {
-					err := quicSrv.ListenAndServeTLS(conf.Conf.Scheme.CertFile, conf.Conf.Scheme.KeyFile)
-					if err != nil && !errors.Is(err, http.ErrServerClosed) {
-						utils.Log.Fatalf("failed to start http3 (quic): %s", err.Error())
-					}
-				}()
-			}
-		}
-		if conf.Conf.Scheme.UnixFile != "" {
-			fmt.Printf("start unix server @ %s\n", conf.Conf.Scheme.UnixFile)
-			utils.Log.Infof("start unix server @ %s", conf.Conf.Scheme.UnixFile)
-			unixSrv = &http.Server{Handler: httpHandler}
-			go func() {
-				listener, err := net.Listen("unix", conf.Conf.Scheme.UnixFile)
-				if err != nil {
-					utils.Log.Fatalf("failed to listen unix: %+v", err)
-				}
-				// set socket file permission
-				mode, err := strconv.ParseUint(conf.Conf.Scheme.UnixFilePerm, 8, 32)
-				if err != nil {
-					utils.Log.Errorf("failed to parse socket file permission: %+v", err)
-				} else {
-					err = os.Chmod(conf.Conf.Scheme.UnixFile, os.FileMode(mode))
-					if err != nil {
-						utils.Log.Errorf("failed to chmod socket file: %+v", err)
-					}
-				}
-				err = unixSrv.Serve(listener)
-				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					utils.Log.Fatalf("failed to start unix: %s", err.Error())
-				}
-			}()
-		}
-		if conf.Conf.S3.Port != -1 && conf.Conf.S3.Enable {
-			s3r := gin.New()
-			s3r.Use(gin.LoggerWithWriter(log.StandardLogger().Out), gin.RecoveryWithWriter(log.StandardLogger().Out))
-			server.InitS3(s3r)
-			s3Base := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.S3.Port)
-			fmt.Printf("start S3 server @ %s\n", s3Base)
-			utils.Log.Infof("start S3 server @ %s", s3Base)
-			go func() {
-				var err error
-				if conf.Conf.S3.SSL {
-					httpsSrv = &http.Server{Addr: s3Base, Handler: s3r}
-					err = httpsSrv.ListenAndServeTLS(conf.Conf.Scheme.CertFile, conf.Conf.Scheme.KeyFile)
-				}
-				if !conf.Conf.S3.SSL {
-					httpSrv = &http.Server{Addr: s3Base, Handler: s3r}
-					err = httpSrv.ListenAndServe()
-				}
-				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					utils.Log.Fatalf("failed to start s3 server: %s", err.Error())
-				}
-			}()
-		}
-		var ftpDriver *server.FtpMainDriver
-		var ftpServer *ftpserver.FtpServer
-		if conf.Conf.FTP.Listen != "" && conf.Conf.FTP.Enable {
-			var err error
-			ftpDriver, err = server.NewMainDriver()
-			if err != nil {
-				utils.Log.Fatalf("failed to start ftp driver: %s", err.Error())
-			} else {
-				fmt.Printf("start ftp server on %s\n", conf.Conf.FTP.Listen)
-				utils.Log.Infof("start ftp server on %s", conf.Conf.FTP.Listen)
-				go func() {
-					ftpServer = ftpserver.NewFtpServer(ftpDriver)
-					err = ftpServer.ListenAndServe()
-					if err != nil {
-						utils.Log.Fatalf("problem ftp server listening: %s", err.Error())
-					}
-				}()
-			}
-		}
-		var sftpDriver *server.SftpDriver
-		var sftpServer *sftpd.SftpServer
-		if conf.Conf.SFTP.Listen != "" && conf.Conf.SFTP.Enable {
-			var err error
-			sftpDriver, err = server.NewSftpDriver()
-			if err != nil {
-				utils.Log.Fatalf("failed to start sftp driver: %s", err.Error())
-			} else {
-				fmt.Printf("start sftp server on %s", conf.Conf.SFTP.Listen)
-				utils.Log.Infof("start sftp server on %s", conf.Conf.SFTP.Listen)
-				go func() {
-					sftpServer = sftpd.NewSftpServer(sftpDriver)
-					err = sftpServer.RunServer()
-					if err != nil {
-						utils.Log.Fatalf("problem sftp server listening: %s", err.Error())
-					}
-				}()
-			}
-		}
+		bootstrap.Init()
+		defer bootstrap.Release()
+		bootstrap.Start()
 		// Wait for interrupt signal to gracefully shutdown the server with
 		// a timeout of 1 second.
 		quit := make(chan os.Signal, 1)
@@ -201,69 +28,7 @@ the address is defined in config file`,
 		// kill -9 is syscall. SIGKILL but can"t be catch, so don't need add it
 		signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 		<-quit
-		utils.Log.Println("Shutdown server...")
-		fs.ArchiveContentUploadTaskManager.RemoveAll()
-		Release()
-		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-		defer cancel()
-		var wg sync.WaitGroup
-		if conf.Conf.Scheme.HttpPort != -1 {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				if err := httpSrv.Shutdown(ctx); err != nil {
-					utils.Log.Fatal("HTTP server shutdown err: ", err)
-				}
-			}()
-		}
-		if conf.Conf.Scheme.HttpsPort != -1 {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				if err := httpsSrv.Shutdown(ctx); err != nil {
-					utils.Log.Fatal("HTTPS server shutdown err: ", err)
-				}
-			}()
-			if conf.Conf.Scheme.EnableH3 {
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					if err := quicSrv.Shutdown(ctx); err != nil {
-						utils.Log.Fatal("HTTP3 (quic) server shutdown err: ", err)
-					}
-				}()
-			}
-		}
-		if conf.Conf.Scheme.UnixFile != "" {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				if err := unixSrv.Shutdown(ctx); err != nil {
-					utils.Log.Fatal("Unix server shutdown err: ", err)
-				}
-			}()
-		}
-		if conf.Conf.FTP.Listen != "" && conf.Conf.FTP.Enable && ftpServer != nil && ftpDriver != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				ftpDriver.Stop()
-				if err := ftpServer.Stop(); err != nil {
-					utils.Log.Fatal("FTP server shutdown err: ", err)
-				}
-			}()
-		}
-		if conf.Conf.SFTP.Listen != "" && conf.Conf.SFTP.Enable && sftpServer != nil && sftpDriver != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				if err := sftpServer.Close(); err != nil {
-					utils.Log.Fatal("SFTP server shutdown err: ", err)
-				}
-			}()
-		}
-		wg.Wait()
-		utils.Log.Println("Server exit")
+		bootstrap.Shutdown(1 * time.Second)
 	},
 }