add(interface): driver&mamage

- Added driver initialization for gRPC plugins in internal/bootstrap/driver.go.
- Introduced configuration structures and protobuf definitions for driver plugins in proto/driver/config.proto and proto/driver/driver.proto.
- Implemented gRPC server and client interfaces for driver plugins in shared/driver/grpc.go.
- Created common response handling utilities in server/common/common.go and server/common/resp.go.
- Developed plugin registration endpoint in server/handles/plugin.go.
- Added test cases for plugin functionality in shared/driver/plugin_test.go.
- Defined plugin reattachment configuration model in shared/model/plugin.go.

.github/workflows/sync_repo.yml

@@ -1,38 +0,0 @@
-name: Sync to Gitee
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-jobs:
-  sync:
-    runs-on: ubuntu-latest
-    name: Sync GitHub to Gitee
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup SSH
-        run: |
-          mkdir -p ~/.ssh
-          echo "${{ secrets.GITEE_SSH_PRIVATE_KEY }}" > ~/.ssh/id_rsa
-          chmod 600 ~/.ssh/id_rsa
-          ssh-keyscan gitee.com >> ~/.ssh/known_hosts
-
-      - name: Create single commit and push
-        run: |
-          git config user.name "GitHub Actions"
-          git config user.email "actions@github.com"
-          
-          # Create a new branch
-          git checkout --orphan new-main
-          git add .
-          git commit -m "Sync from GitHub: $(date)"
-
-          # Add Gitee remote and force push
-          git remote add gitee ${{ vars.GITEE_REPO_URL }}
-          git push --force gitee new-main:main

Dockerfile.ci

@@ -1,23 +0,0 @@
-ARG BASE_IMAGE_TAG=base
-FROM ghcr.io/openlistteam/openlist-base-image:${BASE_IMAGE_TAG}
-LABEL MAINTAINER="OpenList"
-ARG TARGETPLATFORM
-ARG INSTALL_FFMPEG=false
-ARG INSTALL_ARIA2=false
-
-WORKDIR /opt/openlist/
-
-RUN addgroup -g 1001 openlist && \
-    adduser -D -u 1001 -G openlist openlist && \
-    mkdir -p /opt/openlist/data
-
-COPY --chmod=755 --chown=1001:1001 /build/${TARGETPLATFORM}/openlist ./
-COPY --chmod=755 --chown=1001:1001 entrypoint.sh /entrypoint.sh
-
-USER openlist
-RUN /entrypoint.sh version
-
-ENV UMASK=022 RUN_ARIA2=${INSTALL_ARIA2}
-VOLUME /opt/openlist/data/
-EXPOSE 5244 5245
-CMD [ "/entrypoint.sh" ]

buf.gen.yaml

@@ -0,0 +1,11 @@
+version: v1
+plugins:
+  - plugin: buf.build/protocolbuffers/go:v1.36.7
+    out: .
+    opt:
+      - paths=source_relative
+  - plugin: buf.build/grpc/go:v1.5.1
+    out: .
+    opt:
+      - paths=source_relative
+      - require_unimplemented_servers=false

buf.yaml

@@ -0,0 +1 @@
+version: v1

cmd/common.go

@@ -1,51 +1,42 @@
 package cmd
 
 import (
-	"os"
-	"path/filepath"
-	"strconv"
+	"context"
 
-	"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"
+	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v5/internal/bootstrap"
+	"github.com/sirupsen/logrus"
 )
 
-func Init() {
+func Init(ctx context.Context) {
+	if flags.Dev {
+		flags.Debug = true
+	}
+	initLogrus()
 	bootstrap.InitConfig()
-	bootstrap.Log()
-	bootstrap.InitDB()
-	data.InitData()
-	bootstrap.InitStreamLimit()
-	bootstrap.InitIndex()
-	bootstrap.InitUpgradePatch()
+	bootstrap.InitDriverPlugins()
 }
 
 func Release() {
-	db.Close()
+
 }
 
-var pid = -1
-var pidFile string
-
-func initDaemon() {
-	ex, err := os.Executable()
-	if err != nil {
-		log.Fatal(err)
-	}
-	exPath := filepath.Dir(ex)
-	_ = os.MkdirAll(filepath.Join(exPath, "daemon"), 0700)
-	pidFile = filepath.Join(exPath, "daemon/pid")
-	if utils.Exists(pidFile) {
-		bytes, err := os.ReadFile(pidFile)
-		if err != nil {
-			log.Fatal("failed to read pid file", err)
-		}
-		id, err := strconv.Atoi(string(bytes))
-		if err != nil {
-			log.Fatal("failed to parse pid data", err)
-		}
-		pid = id
+func initLog(l *logrus.Logger) {
+	if flags.Debug {
+		l.SetLevel(logrus.DebugLevel)
+		l.SetReportCaller(true)
+	} else {
+		l.SetLevel(logrus.InfoLevel)
+		l.SetReportCaller(false)
 	}
 }
+func initLogrus() {
+	formatter := logrus.TextFormatter{
+		ForceColors:               true,
+		EnvironmentOverrideColors: true,
+		TimestampFormat:           "2006-01-02 15:04:05",
+		FullTimestamp:             true,
+	}
+	logrus.SetFormatter(&formatter)
+	initLog(logrus.StandardLogger())
+}

cmd/flags/config.go

@@ -1,10 +1,40 @@
 package flags
 
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/sirupsen/logrus"
+)
+
 var (
-	DataDir     string
+	ConfigFile  string
 	Debug       bool
 	NoPrefix    bool
 	Dev         bool
 	ForceBinDir bool
 	LogStd      bool
+
+	pwd string
 )
+
+// Program working directory
+func PWD() string {
+	if pwd != "" {
+		return pwd
+	}
+	if ForceBinDir {
+		ex, err := os.Executable()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+		pwd = filepath.Dir(ex)
+		return pwd
+	}
+	d, err := os.Getwd()
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	pwd = d
+	return d
+}

cmd/root.go

@@ -4,10 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
-	_ "github.com/OpenListTeam/OpenList/v4/drivers"
-	_ "github.com/OpenListTeam/OpenList/v4/internal/archive"
-	_ "github.com/OpenListTeam/OpenList/v4/internal/offline_download"
+	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
 	"github.com/spf13/cobra"
 )
 
@@ -27,10 +24,10 @@ func Execute() {
 }
 
 func init() {
-	RootCmd.PersistentFlags().StringVar(&flags.DataDir, "data", "data", "data folder")
+	RootCmd.PersistentFlags().StringVarP(&flags.ConfigFile, "config", "c", "data/config.json", "config file")
 	RootCmd.PersistentFlags().BoolVar(&flags.Debug, "debug", false, "start with debug mode")
 	RootCmd.PersistentFlags().BoolVar(&flags.NoPrefix, "no-prefix", false, "disable env prefix")
 	RootCmd.PersistentFlags().BoolVar(&flags.Dev, "dev", false, "start with dev mode")
-	RootCmd.PersistentFlags().BoolVar(&flags.ForceBinDir, "force-bin-dir", false, "Force to use the directory where the binary file is located as data directory")
-	RootCmd.PersistentFlags().BoolVar(&flags.LogStd, "log-std", false, "Force to log to std")
+	RootCmd.PersistentFlags().BoolVarP(&flags.ForceBinDir, "force-bin-dir", "f", false, "force to use the directory where the binary file is located as data directory")
+	RootCmd.PersistentFlags().BoolVar(&flags.LogStd, "log-std", false, "force to log to std")
 }

cmd/server.go

@@ -13,15 +13,9 @@ import (
 	"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/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v5/internal/conf"
+	"github.com/OpenListTeam/OpenList/v5/server"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -35,220 +29,127 @@ var ServerCmd = &cobra.Command{
 	Short: "Start the server at the specified address",
 	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 {
+	Run: func(_ *cobra.Command, args []string) {
+		serverCtx, serverCancel := context.WithCancel(context.Background())
+		defer serverCancel()
+		Init(serverCtx)
+
+		if !flags.Debug {
 			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
-		if conf.Conf.Scheme.HttpPort != -1 {
+		if conf.Conf.Scheme.HttpPort > 0 {
 			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)
+			log.Infoln("start HTTP server", "@", 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())
+					log.Errorln("start HTTP server", ":", err)
+					serverCancel()
 				}
 			}()
 		}
-		if conf.Conf.Scheme.HttpsPort != -1 {
+		if conf.Conf.Scheme.HttpsPort > 0 {
 			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)
+			log.Infoln("start HTTPS server", "@", 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())
+					log.Errorln("start HTTPS server", ":", err)
+					serverCancel()
 				}
 			}()
 		}
 		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)
+			log.Infoln("start Unix server", "@", 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)
+					log.Errorln("start Unix server", ":", err)
+					serverCancel()
+					return
 				}
-				// 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)
+					log.Errorln("parse unix_file_perm", ":", 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)
+						log.Errorln("chmod socket file", ":", err)
 					}
 				}
+
 				err = unixSrv.Serve(listener)
 				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					utils.Log.Fatalf("failed to start unix: %s", err.Error())
+					log.Errorln("start Unix server", ":", err)
+					serverCancel()
 				}
 			}()
 		}
-		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())
-					}
-				}()
-			}
-		}
-		// Wait for interrupt signal to gracefully shutdown the server with
-		// a timeout of 1 second.
+
 		quit := make(chan os.Signal, 1)
 		// kill (no param) default send syscanll.SIGTERM
 		// kill -2 is syscall.SIGINT
 		// 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()
+		select {
+		case <-quit:
+		case <-serverCtx.Done():
+		}
+
+		log.Println("shutdown server...")
 		Release()
-		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-		defer cancel()
+
+		quitCtx, quitCancel := context.WithTimeout(context.Background(), time.Second)
+		defer quitCancel()
 		var wg sync.WaitGroup
-		if conf.Conf.Scheme.HttpPort != -1 {
+		if httpSrv != nil {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				if err := httpSrv.Shutdown(ctx); err != nil {
-					utils.Log.Fatal("HTTP server shutdown err: ", err)
+				if err := httpSrv.Shutdown(quitCtx); err != nil {
+					log.Errorln("shutdown HTTP server", ":", err)
 				}
 			}()
 		}
-		if conf.Conf.Scheme.HttpsPort != -1 {
+		if httpsSrv != nil {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				if err := httpsSrv.Shutdown(ctx); err != nil {
-					utils.Log.Fatal("HTTPS server shutdown err: ", err)
+				if err := httpsSrv.Shutdown(quitCtx); err != nil {
+					log.Errorln("shutdown HTTPS server", ":", err)
 				}
 			}()
 		}
-		if conf.Conf.Scheme.UnixFile != "" {
+		if unixSrv != nil {
 			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)
+				if err := unixSrv.Shutdown(quitCtx); err != nil {
+					log.Errorln("shutdown Unix server", ":", err)
 				}
 			}()
 		}
 		wg.Wait()
-		utils.Log.Println("Server exit")
+		log.Println("server exit")
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(ServerCmd)
-
-	// Here you will define your flags and configuration settings.
-
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// serverCmd.PersistentFlags().String("foo", "", "A help for foo")
-
-	// Cobra supports local flags which will only run when this command
-	// is called directly, e.g.:
-	// serverCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 }
 
 // OutOpenListInit 暴露用于外部启动server的函数

drivers/openlist_share/driver.go

@@ -1,181 +0,0 @@
-package openlist_share
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/url"
-	stdpath "path"
-	"strings"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/driver"
-	"github.com/OpenListTeam/OpenList/v4/internal/errs"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/OpenListTeam/OpenList/v4/server/common"
-	"github.com/go-resty/resty/v2"
-)
-
-type OpenListShare struct {
-	model.Storage
-	Addition
-	serverArchivePreview bool
-}
-
-func (d *OpenListShare) Config() driver.Config {
-	return config
-}
-
-func (d *OpenListShare) GetAddition() driver.Additional {
-	return &d.Addition
-}
-
-func (d *OpenListShare) Init(ctx context.Context) error {
-	d.Addition.Address = strings.TrimSuffix(d.Addition.Address, "/")
-	var settings common.Resp[map[string]string]
-	_, _, err := d.request("/public/settings", http.MethodGet, func(req *resty.Request) {
-		req.SetResult(&settings)
-	})
-	if err != nil {
-		return err
-	}
-	d.serverArchivePreview = settings.Data["share_archive_preview"] == "true"
-	return nil
-}
-
-func (d *OpenListShare) Drop(ctx context.Context) error {
-	return nil
-}
-
-func (d *OpenListShare) List(ctx context.Context, dir model.Obj, args model.ListArgs) ([]model.Obj, error) {
-	var resp common.Resp[FsListResp]
-	_, _, err := d.request("/fs/list", http.MethodPost, func(req *resty.Request) {
-		req.SetResult(&resp).SetBody(ListReq{
-			PageReq: model.PageReq{
-				Page:    1,
-				PerPage: 0,
-			},
-			Path:     stdpath.Join(fmt.Sprintf("/@s/%s", d.ShareId), dir.GetPath()),
-			Password: d.Pwd,
-			Refresh:  false,
-		})
-	})
-	if err != nil {
-		return nil, err
-	}
-	var files []model.Obj
-	for _, f := range resp.Data.Content {
-		file := model.ObjThumb{
-			Object: model.Object{
-				Name:     f.Name,
-				Modified: f.Modified,
-				Ctime:    f.Created,
-				Size:     f.Size,
-				IsFolder: f.IsDir,
-				HashInfo: utils.FromString(f.HashInfo),
-			},
-			Thumbnail: model.Thumbnail{Thumbnail: f.Thumb},
-		}
-		files = append(files, &file)
-	}
-	return files, nil
-}
-
-func (d *OpenListShare) Link(ctx context.Context, file model.Obj, args model.LinkArgs) (*model.Link, error) {
-	path := utils.FixAndCleanPath(stdpath.Join(d.ShareId, file.GetPath()))
-	u := fmt.Sprintf("%s/sd%s?pwd=%s", d.Address, path, d.Pwd)
-	return &model.Link{URL: u}, nil
-}
-
-func (d *OpenListShare) GetArchiveMeta(ctx context.Context, obj model.Obj, args model.ArchiveArgs) (model.ArchiveMeta, error) {
-	if !d.serverArchivePreview || !d.ForwardArchiveReq {
-		return nil, errs.NotImplement
-	}
-	var resp common.Resp[ArchiveMetaResp]
-	_, code, err := d.request("/fs/archive/meta", http.MethodPost, func(req *resty.Request) {
-		req.SetResult(&resp).SetBody(ArchiveMetaReq{
-			ArchivePass: args.Password,
-			Path:        stdpath.Join(fmt.Sprintf("/@s/%s", d.ShareId), obj.GetPath()),
-			Password:    d.Pwd,
-			Refresh:     false,
-		})
-	})
-	if code == 202 {
-		return nil, errs.WrongArchivePassword
-	}
-	if err != nil {
-		return nil, err
-	}
-	var tree []model.ObjTree
-	if resp.Data.Content != nil {
-		tree = make([]model.ObjTree, 0, len(resp.Data.Content))
-		for _, content := range resp.Data.Content {
-			tree = append(tree, &content)
-		}
-	}
-	return &model.ArchiveMetaInfo{
-		Comment:   resp.Data.Comment,
-		Encrypted: resp.Data.Encrypted,
-		Tree:      tree,
-	}, nil
-}
-
-func (d *OpenListShare) ListArchive(ctx context.Context, obj model.Obj, args model.ArchiveInnerArgs) ([]model.Obj, error) {
-	if !d.serverArchivePreview || !d.ForwardArchiveReq {
-		return nil, errs.NotImplement
-	}
-	var resp common.Resp[ArchiveListResp]
-	_, code, err := d.request("/fs/archive/list", http.MethodPost, func(req *resty.Request) {
-		req.SetResult(&resp).SetBody(ArchiveListReq{
-			ArchiveMetaReq: ArchiveMetaReq{
-				ArchivePass: args.Password,
-				Path:        stdpath.Join(fmt.Sprintf("/@s/%s", d.ShareId), obj.GetPath()),
-				Password:    d.Pwd,
-				Refresh:     false,
-			},
-			PageReq: model.PageReq{
-				Page:    1,
-				PerPage: 0,
-			},
-			InnerPath: args.InnerPath,
-		})
-	})
-	if code == 202 {
-		return nil, errs.WrongArchivePassword
-	}
-	if err != nil {
-		return nil, err
-	}
-	var files []model.Obj
-	for _, f := range resp.Data.Content {
-		file := model.ObjThumb{
-			Object: model.Object{
-				Name:     f.Name,
-				Modified: f.Modified,
-				Ctime:    f.Created,
-				Size:     f.Size,
-				IsFolder: f.IsDir,
-				HashInfo: utils.FromString(f.HashInfo),
-			},
-			Thumbnail: model.Thumbnail{Thumbnail: f.Thumb},
-		}
-		files = append(files, &file)
-	}
-	return files, nil
-}
-
-func (d *OpenListShare) Extract(ctx context.Context, obj model.Obj, args model.ArchiveInnerArgs) (*model.Link, error) {
-	if !d.serverArchivePreview || !d.ForwardArchiveReq {
-		return nil, errs.NotSupport
-	}
-	path := utils.FixAndCleanPath(stdpath.Join(d.ShareId, obj.GetPath()))
-	u := fmt.Sprintf("%s/sad%s?pwd=%s&inner=%s&pass=%s",
-		d.Address,
-		path,
-		d.Pwd,
-		utils.EncodePath(args.InnerPath, true),
-		url.QueryEscape(args.Password))
-	return &model.Link{URL: u}, nil
-}
-
-var _ driver.Driver = (*OpenListShare)(nil)

drivers/openlist_share/meta.go

@@ -1,27 +0,0 @@
-package openlist_share
-
-import (
-	"github.com/OpenListTeam/OpenList/v4/internal/driver"
-	"github.com/OpenListTeam/OpenList/v4/internal/op"
-)
-
-type Addition struct {
-	driver.RootPath
-	Address           string `json:"url" required:"true"`
-	ShareId           string `json:"sid" required:"true"`
-	Pwd               string `json:"pwd"`
-	ForwardArchiveReq bool   `json:"forward_archive_requests" default:"true"`
-}
-
-var config = driver.Config{
-	Name:        "OpenListShare",
-	LocalSort:   true,
-	NoUpload:    true,
-	DefaultRoot: "/",
-}
-
-func init() {
-	op.RegisterDriver(func() driver.Driver {
-		return &OpenListShare{}
-	})
-}

drivers/openlist_share/types.go

@@ -1,111 +0,0 @@
-package openlist_share
-
-import (
-	"time"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-)
-
-type ListReq struct {
-	model.PageReq
-	Path     string `json:"path" form:"path"`
-	Password string `json:"password" form:"password"`
-	Refresh  bool   `json:"refresh"`
-}
-
-type ObjResp struct {
-	Name     string    `json:"name"`
-	Size     int64     `json:"size"`
-	IsDir    bool      `json:"is_dir"`
-	Modified time.Time `json:"modified"`
-	Created  time.Time `json:"created"`
-	Sign     string    `json:"sign"`
-	Thumb    string    `json:"thumb"`
-	Type     int       `json:"type"`
-	HashInfo string    `json:"hashinfo"`
-}
-
-type FsListResp struct {
-	Content  []ObjResp `json:"content"`
-	Total    int64     `json:"total"`
-	Readme   string    `json:"readme"`
-	Write    bool      `json:"write"`
-	Provider string    `json:"provider"`
-}
-
-type ArchiveMetaReq struct {
-	ArchivePass string `json:"archive_pass"`
-	Password    string `json:"password"`
-	Path        string `json:"path"`
-	Refresh     bool   `json:"refresh"`
-}
-
-type TreeResp struct {
-	ObjResp
-	Children  []TreeResp `json:"children"`
-	hashCache *utils.HashInfo
-}
-
-func (t *TreeResp) GetSize() int64 {
-	return t.Size
-}
-
-func (t *TreeResp) GetName() string {
-	return t.Name
-}
-
-func (t *TreeResp) ModTime() time.Time {
-	return t.Modified
-}
-
-func (t *TreeResp) CreateTime() time.Time {
-	return t.Created
-}
-
-func (t *TreeResp) IsDir() bool {
-	return t.ObjResp.IsDir
-}
-
-func (t *TreeResp) GetHash() utils.HashInfo {
-	return utils.FromString(t.HashInfo)
-}
-
-func (t *TreeResp) GetID() string {
-	return ""
-}
-
-func (t *TreeResp) GetPath() string {
-	return ""
-}
-
-func (t *TreeResp) GetChildren() []model.ObjTree {
-	ret := make([]model.ObjTree, 0, len(t.Children))
-	for _, child := range t.Children {
-		ret = append(ret, &child)
-	}
-	return ret
-}
-
-func (t *TreeResp) Thumb() string {
-	return t.ObjResp.Thumb
-}
-
-type ArchiveMetaResp struct {
-	Comment   string     `json:"comment"`
-	Encrypted bool       `json:"encrypted"`
-	Content   []TreeResp `json:"content"`
-	RawURL    string     `json:"raw_url"`
-	Sign      string     `json:"sign"`
-}
-
-type ArchiveListReq struct {
-	model.PageReq
-	ArchiveMetaReq
-	InnerPath string `json:"inner_path"`
-}
-
-type ArchiveListResp struct {
-	Content []ObjResp `json:"content"`
-	Total   int64     `json:"total"`
-}

drivers/openlist_share/util.go

@@ -1,32 +0,0 @@
-package openlist_share
-
-import (
-	"fmt"
-
-	"github.com/OpenListTeam/OpenList/v4/drivers/base"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-)
-
-func (d *OpenListShare) request(api, method string, callback base.ReqCallback) ([]byte, int, error) {
-	url := d.Address + "/api" + api
-	req := base.RestyClient.R()
-	if callback != nil {
-		callback(req)
-	}
-	res, err := req.Execute(method, url)
-	if err != nil {
-		code := 0
-		if res != nil {
-			code = res.StatusCode()
-		}
-		return nil, code, err
-	}
-	if res.StatusCode() >= 400 {
-		return nil, res.StatusCode(), fmt.Errorf("request failed, status: %s", res.Status())
-	}
-	code := utils.Json.Get(res.Body(), "code").ToInt()
-	if code != 200 {
-		return nil, code, fmt.Errorf("request failed, code: %d, message: %s", code, utils.Json.Get(res.Body(), "message").ToString())
-	}
-	return res.Body(), 200, nil
-}

go.mod

@@ -1,271 +1,50 @@
-module github.com/OpenListTeam/OpenList/v4
+module github.com/OpenListTeam/OpenList/v5
 
-go 1.23.4
+go 1.24
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.1
-	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2
-	github.com/OpenListTeam/go-cache v0.1.0
-	github.com/OpenListTeam/sftpd-openlist v1.0.1
-	github.com/OpenListTeam/tache v0.2.0
-	github.com/OpenListTeam/times v0.1.0
-	github.com/OpenListTeam/wopan-sdk-go v0.1.5
-	github.com/ProtonMail/go-crypto v1.3.0
-	github.com/SheltonZhu/115driver v1.1.0
-	github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible
-	github.com/avast/retry-go v3.0.0+incompatible
-	github.com/aws/aws-sdk-go v1.55.7
-	github.com/blevesearch/bleve/v2 v2.5.2
-	github.com/caarlos0/env/v9 v9.0.0
-	github.com/charmbracelet/bubbles v0.21.0
-	github.com/charmbracelet/bubbletea v1.3.6
-	github.com/charmbracelet/lipgloss v1.1.0
-	github.com/city404/v6-public-rpc-proto/go v0.0.0-20240817070657-90f8e24b653e
-	github.com/coreos/go-oidc v2.3.0+incompatible
-	github.com/deckarep/golang-set/v2 v2.8.0
-	github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8
-	github.com/disintegration/imaging v1.6.2
-	github.com/dlclark/regexp2 v1.11.5
-	github.com/dustinxie/ecc v0.0.0-20210511000915-959544187564
-	github.com/fclairamb/ftpserverlib v0.26.1-0.20250709223522-4a925d79caf6
-	github.com/foxxorcat/mopan-sdk-go v0.1.6
-	github.com/foxxorcat/weiyun-sdk-go v0.1.3
 	github.com/gin-contrib/cors v1.7.6
 	github.com/gin-gonic/gin v1.10.1
-	github.com/go-resty/resty/v2 v2.16.5
-	github.com/go-webauthn/webauthn v0.13.4
-	github.com/golang-jwt/jwt/v4 v4.5.2
-	github.com/google/uuid v1.6.0
-	github.com/gorilla/websocket v1.5.3
-	github.com/hekmon/transmissionrpc/v3 v3.0.0
-	github.com/hirochachacha/go-smb2 v1.1.0
-	github.com/ipfs/go-ipfs-api v0.7.0
-	github.com/itsHenry35/gofakes3 v0.0.8
-	github.com/jlaffaye/ftp v0.2.1-0.20240918233326-1b970516f5d3
+	github.com/hashicorp/go-plugin v1.7.0
 	github.com/json-iterator/go v1.1.12
-	github.com/kdomanski/iso9660 v0.4.0
-	github.com/maruel/natural v1.1.1
-	github.com/meilisearch/meilisearch-go v0.32.0
-	github.com/mholt/archives v0.1.3
-	github.com/natefinch/lumberjack v2.0.0+incompatible
-	github.com/ncw/swift/v2 v2.0.4
-	github.com/pkg/errors v0.9.1
-	github.com/pkg/sftp v1.13.9
-	github.com/pquerna/otp v1.5.0
-	github.com/rclone/rclone v1.70.3
-	github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d
-	github.com/shirou/gopsutil/v4 v4.25.5
 	github.com/sirupsen/logrus v1.9.3
-	github.com/spf13/afero v1.14.0
 	github.com/spf13/cobra v1.9.1
-	github.com/stretchr/testify v1.10.0
-	github.com/t3rm1n4l/go-mega v0.0.0-20241213151442-a19cff0ec7b5
-	github.com/u2takey/ffmpeg-go v0.5.0
-	github.com/upyun/go-sdk/v3 v3.0.4
-	github.com/winfsp/cgofuse v1.6.0
-	github.com/yeka/zip v0.0.0-20231116150916-03d6312748a9
-	github.com/zzzhr1990/go-common-entity v0.0.0-20250202070650-1a200048f0d3
-	golang.org/x/crypto v0.40.0
-	golang.org/x/image v0.29.0
-	golang.org/x/net v0.42.0
-	golang.org/x/oauth2 v0.30.0
-	golang.org/x/time v0.12.0
-	google.golang.org/appengine v1.6.8
-	gopkg.in/ldap.v3 v3.1.0
-	gorm.io/driver/mysql v1.5.7
-	gorm.io/driver/postgres v1.5.9
-	gorm.io/driver/sqlite v1.5.6
-	gorm.io/gorm v1.25.11
+	golang.org/x/net v0.43.0
+	google.golang.org/grpc v1.74.2
+	google.golang.org/protobuf v1.36.7
 )
 
 require (
-	cloud.google.com/go/compute/metadata v0.7.0 // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 // indirect
-	github.com/RoaringBitmap/roaring/v2 v2.4.5 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
-	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
-	github.com/ebitengine/purego v0.8.4 // indirect
-	github.com/lanrat/extsort v1.0.2 // indirect
-	github.com/mikelolasagasti/xz v1.0.1 // indirect
-	github.com/minio/minlz v1.0.0 // indirect
-	github.com/minio/xxml v0.0.3 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/otiai10/mint v1.6.3 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	gopkg.in/go-jose/go-jose.v2 v2.6.3 // indirect
-)
-
-require (
-	github.com/OpenListTeam/115-sdk-go v0.2.2
-	github.com/STARRY-S/zip v0.2.1 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
-	github.com/blevesearch/go-faiss v1.0.25 // indirect
-	github.com/blevesearch/zapx/v16 v16.2.4 // indirect
-	github.com/bodgit/plumbing v1.3.0 // indirect
-	github.com/bodgit/sevenzip v1.6.1
-	github.com/bodgit/windows v1.0.1 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
-	github.com/charmbracelet/x/ansi v0.9.3 // indirect
-	github.com/charmbracelet/x/term v0.2.1 // indirect
-	github.com/cloudflare/circl v1.6.1 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
-	github.com/dsnet/compress v0.0.2-0.20230904184137-39efe44ab707 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/fclairamb/go-log v0.6.0 // indirect
-	github.com/gorilla/css v1.0.1 // indirect
-	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
-	github.com/hekmon/cunits/v2 v2.1.0 // indirect
-	github.com/ipfs/boxo v0.12.0 // indirect
-	github.com/jackc/puddle/v2 v2.2.1 // indirect
-	github.com/klauspost/pgzip v1.2.6 // indirect
-	github.com/matoous/go-nanoid/v2 v2.1.0 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.27
-	github.com/nwaples/rardecode/v2 v2.1.1
-	github.com/sorairolake/lzip-go v0.3.5 // indirect
-	github.com/taruti/bytepool v0.0.0-20160310082835-5e3a9ea56543 // indirect
-	github.com/ulikunitz/xz v0.5.12 // indirect
-	github.com/yuin/goldmark v1.7.13
-	go4.org v0.0.0-20230225012048-214862532bf5
-	resty.dev/v3 v3.0.0-beta.2 // indirect
-)
-
-require (
-	github.com/Max-Sum/base32768 v0.0.0-20230304063302-18e6ce5945fd // indirect
-	github.com/OpenListTeam/gsync v0.1.0 // indirect
-	github.com/abbot/go-http-auth v0.4.0 // indirect
-	github.com/aead/ecdh v0.2.0 // indirect
-	github.com/andreburgaud/crypt2go v1.8.0 // indirect
-	github.com/andybalholm/brotli v1.1.2-0.20250424173009-453214e765f3 // indirect
-	github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/benbjohnson/clock v1.3.0 // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/bits-and-blooms/bitset v1.22.0 // indirect
-	github.com/blang/semver/v4 v4.0.0 // indirect
-	github.com/blevesearch/bleve_index_api v1.2.8 // indirect
-	github.com/blevesearch/geo v0.2.3 // indirect
-	github.com/blevesearch/go-porterstemmer v1.0.3 // indirect
-	github.com/blevesearch/gtreap v0.1.1 // indirect
-	github.com/blevesearch/mmap-go v1.0.4 // indirect
-	github.com/blevesearch/scorch_segment_api/v2 v2.3.10 // indirect
-	github.com/blevesearch/segment v0.9.1 // indirect
-	github.com/blevesearch/snowballstem v0.9.0 // indirect
-	github.com/blevesearch/upsidedown_store_api v1.0.2 // indirect
-	github.com/blevesearch/vellum v1.1.0 // indirect
-	github.com/blevesearch/zapx/v11 v11.4.2 // indirect
-	github.com/blevesearch/zapx/v12 v12.4.2 // indirect
-	github.com/blevesearch/zapx/v13 v13.4.2 // indirect
-	github.com/blevesearch/zapx/v14 v14.4.2 // indirect
-	github.com/blevesearch/zapx/v15 v15.4.2 // indirect
-	github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc // indirect
-	github.com/bytedance/sonic v1.13.3 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/coreos/go-semver v0.3.1 // indirect
-	github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
-	github.com/fxamacker/cbor/v2 v2.9.0 // indirect
+	github.com/bytedance/sonic v1.14.0 // indirect
+	github.com/bytedance/sonic/loader v0.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.6 // indirect
+	github.com/fatih/color v1.18.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
-	github.com/geoffgarside/ber v1.2.0 // indirect
 	github.com/gin-contrib/sse v1.1.0 // indirect
-	github.com/go-chi/chi/v5 v5.2.2 // indirect
-	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.26.0 // indirect
-	github.com/go-sql-driver/mysql v1.7.0 // indirect
-	github.com/go-webauthn/x v0.1.23 // indirect
+	github.com/go-playground/validator/v10 v10.27.0 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
-	github.com/golang-jwt/jwt/v5 v5.2.3 // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/go-tpm v0.9.5 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/hashicorp/go-version v1.6.0 // indirect
+	github.com/hashicorp/go-hclog v1.6.3 // indirect
+	github.com/hashicorp/yamux v0.1.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/ipfs/go-cid v0.5.0
-	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.5.5 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/josharian/intern v1.0.0 // indirect
-	github.com/jzelinskie/whirlpool v0.0.0-20201016144138-0675e54bb004 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/kr/fs v0.1.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
-	github.com/libp2p/go-flow-metrics v0.1.0 // indirect
-	github.com/libp2p/go-libp2p v0.27.8 // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect
-	github.com/mailru/easyjson v0.9.0 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/mattn/go-sqlite3 v1.14.22 // indirect
-	github.com/minio/sha256-simd v1.0.1 // indirect
-	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/mr-tron/base58 v1.2.0 // indirect
-	github.com/mschoch/smat v0.2.0 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
-	github.com/multiformats/go-base32 v0.1.0 // indirect
-	github.com/multiformats/go-base36 v0.2.0 // indirect
-	github.com/multiformats/go-multiaddr v0.9.0 // indirect
-	github.com/multiformats/go-multibase v0.2.0 // indirect
-	github.com/multiformats/go-multicodec v0.9.0 // indirect
-	github.com/multiformats/go-multihash v0.2.3 // indirect
-	github.com/multiformats/go-multistream v0.4.1 // indirect
-	github.com/multiformats/go-varint v0.0.7 // indirect
-	github.com/otiai10/copy v1.14.1
+	github.com/oklog/run v1.2.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
-	github.com/pierrec/lz4/v4 v4.1.22 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
-	github.com/pquerna/cachecontrol v0.1.0 // indirect
-	github.com/prometheus/client_golang v1.22.0 // indirect
-	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.64.0 // indirect
-	github.com/prometheus/procfs v0.16.1 // indirect
-	github.com/rfjakob/eme v1.1.2 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46 // indirect
-	github.com/shabbyrobe/gocovmerge v0.0.0-20230507112040-c3350d9342df // indirect
-	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
-	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.6 // indirect
-	github.com/tklauser/go-sysconf v0.3.15 // indirect
-	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/spf13/pflag v1.0.7 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/u2takey/go-utils v0.3.1 // indirect
 	github.com/ugorji/go/codec v1.3.0 // indirect
-	github.com/x448/float16 v0.8.4 // indirect
-	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.etcd.io/bbolt v1.4.0 // indirect
-	golang.org/x/arch v0.18.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
-	golang.org/x/sys v0.34.0 // indirect
-	golang.org/x/term v0.33.0 // indirect
-	golang.org/x/text v0.27.0
-	golang.org/x/tools v0.34.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect
-	google.golang.org/grpc v1.73.0
-	google.golang.org/protobuf v1.36.6 // indirect
-	gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
+	golang.org/x/arch v0.20.0 // indirect
+	golang.org/x/crypto v0.41.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	lukechampine.com/blake3 v1.1.7 // indirect
 )
-
-// replace github.com/OpenListTeam/115-sdk-go => ../../OpenListTeam/115-sdk-go

internal/bootstrap/config.go

@@ -6,162 +6,68 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
-	"github.com/OpenListTeam/OpenList/v4/drivers/base"
-	"github.com/OpenListTeam/OpenList/v4/internal/conf"
-	"github.com/OpenListTeam/OpenList/v4/internal/net"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/caarlos0/env/v9"
-	"github.com/shirou/gopsutil/v4/mem"
+	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v5/internal/conf"
+	"github.com/OpenListTeam/OpenList/v5/pkg/utils"
 	log "github.com/sirupsen/logrus"
 )
 
-// Program working directory
-func PWD() string {
-	if flags.ForceBinDir {
-		ex, err := os.Executable()
-		if err != nil {
-			log.Fatal(err)
-		}
-		pwd := filepath.Dir(ex)
-		return pwd
-	}
-	d, err := os.Getwd()
-	if err != nil {
-		d = "."
-	}
-	return d
-}
-
 func InitConfig() {
-	pwd := PWD()
-	dataDir := flags.DataDir
-	if !filepath.IsAbs(dataDir) {
-		flags.DataDir = filepath.Join(pwd, flags.DataDir)
+	if !filepath.IsAbs(flags.ConfigFile) {
+		flags.ConfigFile = filepath.Join(flags.PWD(), flags.ConfigFile)
 	}
-	configPath := filepath.Join(flags.DataDir, "config.json")
-	log.Infof("reading config file: %s", configPath)
-	if !utils.Exists(configPath) {
-		log.Infof("config file not exists, creating default config file")
-		_, err := utils.CreateNestedFile(configPath)
+	log.Infoln("reading config file", "@", flags.ConfigFile)
+
+	if !utils.Exists(flags.ConfigFile) {
+		log.Infoln("config file not exists, creating default config file")
+		_, err := utils.CreateNestedFile(flags.ConfigFile)
 		if err != nil {
-			log.Fatalf("failed to create config file: %+v", err)
+			log.Fatalln("create config file", ":", err)
 		}
-		conf.Conf = conf.DefaultConfig(dataDir)
-		LastLaunchedVersion = conf.Version
-		conf.Conf.LastLaunchedVersion = conf.Version
-		if !utils.WriteJsonToFile(configPath, conf.Conf) {
-			log.Fatalf("failed to create default config file")
+		conf.Conf = conf.DefaultConfig()
+		err = utils.WriteJsonToFile(flags.ConfigFile, conf.Conf)
+		if err != nil {
+			log.Fatalln("save default config file", ":", err)
 		}
 	} else {
-		configBytes, err := os.ReadFile(configPath)
+		configBytes, err := os.ReadFile(flags.ConfigFile)
 		if err != nil {
-			log.Fatalf("reading config file error: %+v", err)
+			log.Fatalln("reading config file", ":", err)
 		}
-		conf.Conf = conf.DefaultConfig(dataDir)
+		conf.Conf = conf.DefaultConfig()
 		err = utils.Json.Unmarshal(configBytes, conf.Conf)
 		if err != nil {
-			log.Fatalf("load config error: %+v", err)
+			log.Fatalln("unmarshal config", ":", err)
 		}
-		LastLaunchedVersion = conf.Conf.LastLaunchedVersion
-		if strings.HasPrefix(conf.Version, "v") || LastLaunchedVersion == "" {
-			conf.Conf.LastLaunchedVersion = conf.Version
-		}
-		// update config.json struct
-		confBody, err := utils.Json.MarshalIndent(conf.Conf, "", "  ")
+		err = utils.WriteJsonToFile(flags.ConfigFile, conf.Conf)
 		if err != nil {
-			log.Fatalf("marshal config error: %+v", err)
+			log.Fatalln("update config file", ":", err)
 		}
-		err = os.WriteFile(configPath, confBody, 0o777)
-		if err != nil {
-			log.Fatalf("update config struct error: %+v", err)
-		}
-	}
-	if !conf.Conf.Force {
-		confFromEnv()
 	}
 
-	if conf.Conf.MaxConcurrency > 0 {
-		net.DefaultConcurrencyLimit = &net.ConcurrencyLimit{Limit: conf.Conf.MaxConcurrency}
-	}
-	if conf.Conf.MaxBufferLimit < 0 {
-		m, _ := mem.VirtualMemory()
-		if m != nil {
-			conf.MaxBufferLimit = max(int(float64(m.Total)*0.05), 4*utils.MB)
-			conf.MaxBufferLimit -= conf.MaxBufferLimit % utils.MB
-		} else {
-			conf.MaxBufferLimit = 16 * utils.MB
-		}
-	} else {
-		conf.MaxBufferLimit = conf.Conf.MaxBufferLimit * utils.MB
-	}
-	log.Infof("max buffer limit: %dMB", conf.MaxBufferLimit/utils.MB)
-	if conf.Conf.MmapThreshold > 0 {
-		conf.MmapThreshold = conf.Conf.MmapThreshold * utils.MB
-	} else {
-		conf.MmapThreshold = 0
-	}
-	log.Infof("mmap threshold: %dMB", conf.Conf.MmapThreshold)
-
-	if len(conf.Conf.Log.Filter.Filters) == 0 {
-		conf.Conf.Log.Filter.Enable = false
-	}
 	// convert abs path
+	configDir := filepath.Dir(flags.ConfigFile)
 	convertAbsPath := func(path *string) {
 		if *path != "" && !filepath.IsAbs(*path) {
-			*path = filepath.Join(pwd, *path)
+			*path = filepath.Join(configDir, *path)
 		}
 	}
-	convertAbsPath(&conf.Conf.Database.DBFile)
+	convertAbsPath(&conf.Conf.TempDir)
 	convertAbsPath(&conf.Conf.Scheme.CertFile)
 	convertAbsPath(&conf.Conf.Scheme.KeyFile)
 	convertAbsPath(&conf.Conf.Scheme.UnixFile)
-	convertAbsPath(&conf.Conf.Log.Name)
-	convertAbsPath(&conf.Conf.TempDir)
-	convertAbsPath(&conf.Conf.BleveDir)
-	convertAbsPath(&conf.Conf.DistDir)
-
-	err := os.MkdirAll(conf.Conf.TempDir, 0o777)
-	if err != nil {
-		log.Fatalf("create temp dir error: %+v", err)
-	}
 	log.Debugf("config: %+v", conf.Conf)
-	base.InitClient()
-	initURL()
+
+	initSitePath()
 }
 
-func confFromEnv() {
-	prefix := "OPENLIST_"
-	if flags.NoPrefix {
-		prefix = ""
-	}
-	log.Infof("load config from env with prefix: %s", prefix)
-	if err := env.ParseWithOptions(conf.Conf, env.Options{
-		Prefix: prefix,
-	}); err != nil {
-		log.Fatalf("load config from env error: %+v", err)
-	}
-}
-
-func initURL() {
+func initSitePath() {
 	if !strings.Contains(conf.Conf.SiteURL, "://") {
 		conf.Conf.SiteURL = utils.FixAndCleanPath(conf.Conf.SiteURL)
 	}
 	u, err := url.Parse(conf.Conf.SiteURL)
 	if err != nil {
-		utils.Log.Fatalf("can't parse site_url: %+v", err)
-	}
-	conf.URL = u
-}
-
-func CleanTempDir() {
-	files, err := os.ReadDir(conf.Conf.TempDir)
-	if err != nil {
-		log.Errorln("failed list temp file: ", err)
-	}
-	for _, file := range files {
-		if err := os.RemoveAll(filepath.Join(conf.Conf.TempDir, file.Name())); err != nil {
-			log.Errorln("failed delete temp file: ", err)
-		}
+		log.Fatalln("parse site_url", ":", err)
 	}
+	conf.SitePath = u.Path
 }

internal/bootstrap/driver.go

@@ -0,0 +1,13 @@
+package bootstrap
+
+import (
+	"github.com/OpenListTeam/OpenList/v5/internal/driver"
+	driverS "github.com/OpenListTeam/OpenList/v5/shared/driver"
+	"github.com/hashicorp/go-plugin"
+)
+
+func InitDriverPlugins() {
+	driver.PluginMap = map[string]plugin.Plugin{
+		"grpc": &driverS.Plugin{},
+	}
+}

internal/conf/config.go

@@ -1,34 +1,9 @@
 package conf
 
-import (
-	"path/filepath"
-
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils/random"
-)
-
-type Database struct {
-	Type        string `json:"type" env:"TYPE"`
-	Host        string `json:"host" env:"HOST"`
-	Port        int    `json:"port" env:"PORT"`
-	User        string `json:"user" env:"USER"`
-	Password    string `json:"password" env:"PASS"`
-	Name        string `json:"name" env:"NAME"`
-	DBFile      string `json:"db_file" env:"FILE"`
-	TablePrefix string `json:"table_prefix" env:"TABLE_PREFIX"`
-	SSLMode     string `json:"ssl_mode" env:"SSL_MODE"`
-	DSN         string `json:"dsn" env:"DSN"`
-}
-
-type Meilisearch struct {
-	Host   string `json:"host" env:"HOST"`
-	APIKey string `json:"api_key" env:"API_KEY"`
-	Index  string `json:"index" env:"INDEX"`
-}
-
 type Scheme struct {
 	Address      string `json:"address" env:"ADDR"`
-	HttpPort     int    `json:"http_port" env:"HTTP_PORT"`
-	HttpsPort    int    `json:"https_port" env:"HTTPS_PORT"`
+	HttpPort     uint16 `json:"http_port" env:"HTTP_PORT"`
+	HttpsPort    uint16 `json:"https_port" env:"HTTPS_PORT"`
 	ForceHttps   bool   `json:"force_https" env:"FORCE_HTTPS"`
 	CertFile     string `json:"cert_file" env:"CERT_FILE"`
 	KeyFile      string `json:"key_file" env:"KEY_FILE"`
@@ -36,212 +11,30 @@ type Scheme struct {
 	UnixFilePerm string `json:"unix_file_perm" env:"UNIX_FILE_PERM"`
 	EnableH2c    bool   `json:"enable_h2c" env:"ENABLE_H2C"`
 }
-
-type LogConfig struct {
-	Enable     bool            `json:"enable" env:"ENABLE"`
-	Name       string          `json:"name" env:"NAME"`
-	MaxSize    int             `json:"max_size" env:"MAX_SIZE"`
-	MaxBackups int             `json:"max_backups" env:"MAX_BACKUPS"`
-	MaxAge     int             `json:"max_age" env:"MAX_AGE"`
-	Compress   bool            `json:"compress" env:"COMPRESS"`
-	Filter     LogFilterConfig `json:"filter" envPrefix:"FILTER_"`
-}
-
-type LogFilterConfig struct {
-	Enable  bool     `json:"enable" env:"ENABLE"`
-	Filters []Filter `json:"filters"`
-}
-
-type Filter struct {
-	CIDR   string `json:"cidr"`
-	Path   string `json:"path"`
-	Method string `json:"method"`
-}
-
-type TaskConfig struct {
-	Workers        int  `json:"workers" env:"WORKERS"`
-	MaxRetry       int  `json:"max_retry" env:"MAX_RETRY"`
-	TaskPersistant bool `json:"task_persistant" env:"TASK_PERSISTANT"`
-}
-
-type TasksConfig struct {
-	Download           TaskConfig `json:"download" envPrefix:"DOWNLOAD_"`
-	Transfer           TaskConfig `json:"transfer" envPrefix:"TRANSFER_"`
-	Upload             TaskConfig `json:"upload" envPrefix:"UPLOAD_"`
-	Copy               TaskConfig `json:"copy" envPrefix:"COPY_"`
-	Move               TaskConfig `json:"move" envPrefix:"MOVE_"`
-	Decompress         TaskConfig `json:"decompress" envPrefix:"DECOMPRESS_"`
-	DecompressUpload   TaskConfig `json:"decompress_upload" envPrefix:"DECOMPRESS_UPLOAD_"`
-	AllowRetryCanceled bool       `json:"allow_retry_canceled" env:"ALLOW_RETRY_CANCELED"`
-}
-
 type Cors struct {
 	AllowOrigins []string `json:"allow_origins" env:"ALLOW_ORIGINS"`
 	AllowMethods []string `json:"allow_methods" env:"ALLOW_METHODS"`
 	AllowHeaders []string `json:"allow_headers" env:"ALLOW_HEADERS"`
 }
 
-type S3 struct {
-	Enable bool `json:"enable" env:"ENABLE"`
-	Port   int  `json:"port" env:"PORT"`
-	SSL    bool `json:"ssl" env:"SSL"`
-}
-
-type FTP struct {
-	Enable                  bool   `json:"enable" env:"ENABLE"`
-	Listen                  string `json:"listen" env:"LISTEN"`
-	FindPasvPortAttempts    int    `json:"find_pasv_port_attempts" env:"FIND_PASV_PORT_ATTEMPTS"`
-	ActiveTransferPortNon20 bool   `json:"active_transfer_port_non_20" env:"ACTIVE_TRANSFER_PORT_NON_20"`
-	IdleTimeout             int    `json:"idle_timeout" env:"IDLE_TIMEOUT"`
-	ConnectionTimeout       int    `json:"connection_timeout" env:"CONNECTION_TIMEOUT"`
-	DisableActiveMode       bool   `json:"disable_active_mode" env:"DISABLE_ACTIVE_MODE"`
-	DefaultTransferBinary   bool   `json:"default_transfer_binary" env:"DEFAULT_TRANSFER_BINARY"`
-	EnableActiveConnIPCheck bool   `json:"enable_active_conn_ip_check" env:"ENABLE_ACTIVE_CONN_IP_CHECK"`
-	EnablePasvConnIPCheck   bool   `json:"enable_pasv_conn_ip_check" env:"ENABLE_PASV_CONN_IP_CHECK"`
-}
-
-type SFTP struct {
-	Enable bool   `json:"enable" env:"ENABLE"`
-	Listen string `json:"listen" env:"LISTEN"`
-}
-
 type Config struct {
-	Force                 bool        `json:"force" env:"FORCE"`
-	SiteURL               string      `json:"site_url" env:"SITE_URL"`
-	Cdn                   string      `json:"cdn" env:"CDN"`
-	JwtSecret             string      `json:"jwt_secret" env:"JWT_SECRET"`
-	TokenExpiresIn        int         `json:"token_expires_in" env:"TOKEN_EXPIRES_IN"`
-	Database              Database    `json:"database" envPrefix:"DB_"`
-	Meilisearch           Meilisearch `json:"meilisearch" envPrefix:"MEILISEARCH_"`
-	Scheme                Scheme      `json:"scheme"`
 	TempDir string `json:"temp_dir" env:"TEMP_DIR"`
-	BleveDir              string      `json:"bleve_dir" env:"BLEVE_DIR"`
-	DistDir               string      `json:"dist_dir"`
-	Log                   LogConfig   `json:"log" envPrefix:"LOG_"`
-	DelayedStart          int         `json:"delayed_start" env:"DELAYED_START"`
-	MaxBufferLimit        int         `json:"max_buffer_limitMB" env:"MAX_BUFFER_LIMIT_MB"`
-	MmapThreshold         int         `json:"mmap_thresholdMB" env:"MMAP_THRESHOLD_MB"`
-	MaxConnections        int         `json:"max_connections" env:"MAX_CONNECTIONS"`
-	MaxConcurrency        int         `json:"max_concurrency" env:"MAX_CONCURRENCY"`
-	TlsInsecureSkipVerify bool        `json:"tls_insecure_skip_verify" env:"TLS_INSECURE_SKIP_VERIFY"`
-	Tasks                 TasksConfig `json:"tasks" envPrefix:"TASKS_"`
+	SiteURL string `json:"site_url" env:"SITE_URL"`
+	Scheme  Scheme `json:"scheme"`
 	Cors    Cors   `json:"cors" envPrefix:"CORS_"`
-	S3                    S3          `json:"s3" envPrefix:"S3_"`
-	FTP                   FTP         `json:"ftp" envPrefix:"FTP_"`
-	SFTP                  SFTP        `json:"sftp" envPrefix:"SFTP_"`
-	LastLaunchedVersion   string      `json:"last_launched_version"`
 }
 
-func DefaultConfig(dataDir string) *Config {
-	tempDir := filepath.Join(dataDir, "temp")
-	indexDir := filepath.Join(dataDir, "bleve")
-	logPath := filepath.Join(dataDir, "log/log.log")
-	dbPath := filepath.Join(dataDir, "data.db")
+func DefaultConfig() *Config {
 	return &Config{
+		TempDir: "temp",
 		Scheme: Scheme{
 			Address:  "0.0.0.0",
-			UnixFile:   "",
 			HttpPort: 5244,
-			HttpsPort:  -1,
-			ForceHttps: false,
-			CertFile:   "",
-			KeyFile:    "",
-		},
-		JwtSecret:      random.String(16),
-		TokenExpiresIn: 48,
-		TempDir:        tempDir,
-		Database: Database{
-			Type:        "sqlite3",
-			Port:        0,
-			TablePrefix: "x_",
-			DBFile:      dbPath,
-		},
-		Meilisearch: Meilisearch{
-			Host:  "http://localhost:7700",
-			Index: "openlist",
-		},
-		BleveDir: indexDir,
-		Log: LogConfig{
-			Enable:     true,
-			Name:       logPath,
-			MaxSize:    50,
-			MaxBackups: 30,
-			MaxAge:     28,
-			Filter: LogFilterConfig{
-				Enable: false,
-				Filters: []Filter{
-					{Path: "/ping"},
-					{Method: "HEAD"},
-					{Path: "/dav/", Method: "PROPFIND"},
-				},
-			},
-		},
-		MaxBufferLimit:        -1,
-		MmapThreshold:         4,
-		MaxConnections:        0,
-		MaxConcurrency:        64,
-		TlsInsecureSkipVerify: true,
-		Tasks: TasksConfig{
-			Download: TaskConfig{
-				Workers:  5,
-				MaxRetry: 1,
-				// TaskPersistant: true,
-			},
-			Transfer: TaskConfig{
-				Workers:  5,
-				MaxRetry: 2,
-				// TaskPersistant: true,
-			},
-			Upload: TaskConfig{
-				Workers: 5,
-			},
-			Copy: TaskConfig{
-				Workers:  5,
-				MaxRetry: 2,
-				// TaskPersistant: true,
-			},
-			Move: TaskConfig{
-				Workers:  5,
-				MaxRetry: 2,
-				// TaskPersistant: true,
-			},
-			Decompress: TaskConfig{
-				Workers:  5,
-				MaxRetry: 2,
-				// TaskPersistant: true,
-			},
-			DecompressUpload: TaskConfig{
-				Workers:  5,
-				MaxRetry: 2,
-			},
-			AllowRetryCanceled: false,
 		},
 		Cors: Cors{
 			AllowOrigins: []string{"*"},
 			AllowMethods: []string{"*"},
 			AllowHeaders: []string{"*"},
 		},
-		S3: S3{
-			Enable: false,
-			Port:   5246,
-			SSL:    false,
-		},
-		FTP: FTP{
-			Enable:                  false,
-			Listen:                  ":5221",
-			FindPasvPortAttempts:    50,
-			ActiveTransferPortNon20: false,
-			IdleTimeout:             900,
-			ConnectionTimeout:       30,
-			DisableActiveMode:       false,
-			DefaultTransferBinary:   false,
-			EnableActiveConnIPCheck: true,
-			EnablePasvConnIPCheck:   true,
-		},
-		SFTP: SFTP{
-			Enable: false,
-			Listen: ":5222",
-		},
-		LastLaunchedVersion: "",
 	}
 }

internal/conf/var.go

@@ -1,37 +1,10 @@
 package conf
 
-import (
-	"net/url"
-	"regexp"
-)
-
-var (
-	BuiltAt    string = "unknown"
-	GitAuthor  string = "unknown"
-	GitCommit  string = "unknown"
-	Version    string = "dev"
-	WebVersion string = "rolling"
-)
+import "regexp"
 
 var (
 	Conf     *Config
-	URL  *url.URL
+	SitePath string
 )
 
-var SlicesMap = make(map[string][]string)
-var FilenameCharMap = make(map[string]string)
 var PrivacyReg []*regexp.Regexp
-
-var (
-	// StoragesLoaded loaded success if empty
-	StoragesLoaded = false
-	// 单个Buffer最大限制
-	MaxBufferLimit = 16 * 1024 * 1024
-	// 超过该阈值的Buffer将使用 mmap 分配，可主动释放内存
-	MmapThreshold = 4 * 1024 * 1024
-)
-var (
-	RawIndexHtml string
-	ManageHtml   string
-	IndexHtml    string
-)

internal/db/sharing.go

@@ -1,62 +0,0 @@
-package db
-
-import (
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils/random"
-	"github.com/pkg/errors"
-)
-
-func GetSharingById(id string) (*model.SharingDB, error) {
-	s := model.SharingDB{ID: id}
-	if err := db.Where(s).First(&s).Error; err != nil {
-		return nil, errors.Wrapf(err, "failed get sharing")
-	}
-	return &s, nil
-}
-
-func GetSharings(pageIndex, pageSize int) (sharings []model.SharingDB, count int64, err error) {
-	sharingDB := db.Model(&model.SharingDB{})
-	if err := sharingDB.Count(&count).Error; err != nil {
-		return nil, 0, errors.Wrapf(err, "failed get sharings count")
-	}
-	if err := sharingDB.Order(columnName("id")).Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&sharings).Error; err != nil {
-		return nil, 0, errors.Wrapf(err, "failed get find sharings")
-	}
-	return sharings, count, nil
-}
-
-func GetSharingsByCreatorId(creator uint, pageIndex, pageSize int) (sharings []model.SharingDB, count int64, err error) {
-	sharingDB := db.Model(&model.SharingDB{})
-	cond := model.SharingDB{CreatorId: creator}
-	if err := sharingDB.Where(cond).Count(&count).Error; err != nil {
-		return nil, 0, errors.Wrapf(err, "failed get sharings count")
-	}
-	if err := sharingDB.Where(cond).Order(columnName("id")).Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&sharings).Error; err != nil {
-		return nil, 0, errors.Wrapf(err, "failed get find sharings")
-	}
-	return sharings, count, nil
-}
-
-func CreateSharing(s *model.SharingDB) (string, error) {
-	id := random.String(8)
-	for len(id) < 12 {
-		old := model.SharingDB{
-			ID: id,
-		}
-		if err := db.Where(old).First(&old).Error; err != nil {
-			s.ID = id
-			return id, errors.WithStack(db.Create(s).Error)
-		}
-		id += random.String(1)
-	}
-	return "", errors.New("failed find valid id")
-}
-
-func UpdateSharing(s *model.SharingDB) error {
-	return errors.WithStack(db.Save(s).Error)
-}
-
-func DeleteSharingById(id string) error {
-	s := model.SharingDB{ID: id}
-	return errors.WithStack(db.Where(s).Delete(&s).Error)
-}

internal/driver/var.go

@@ -0,0 +1,9 @@
+package driver
+
+import (
+	"github.com/hashicorp/go-plugin"
+)
+
+var (
+	PluginMap map[string]plugin.Plugin
+)

internal/model/sharing.go

@@ -1,47 +0,0 @@
-package model
-
-import "time"
-
-type SharingDB struct {
-	ID          string     `json:"id" gorm:"type:char(12);primaryKey"`
-	FilesRaw    string     `json:"-" gorm:"type:text"`
-	Expires     *time.Time `json:"expires"`
-	Pwd         string     `json:"pwd"`
-	Accessed    int        `json:"accessed"`
-	MaxAccessed int        `json:"max_accessed"`
-	CreatorId   uint       `json:"-"`
-	Disabled    bool       `json:"disabled"`
-	Remark      string     `json:"remark"`
-	Readme      string     `json:"readme" gorm:"type:text"`
-	Header      string     `json:"header" gorm:"type:text"`
-	Sort
-}
-
-type Sharing struct {
-	*SharingDB
-	Files   []string `json:"files"`
-	Creator *User    `json:"-"`
-}
-
-func (s *Sharing) Valid() bool {
-	if s.Disabled {
-		return false
-	}
-	if s.MaxAccessed > 0 && s.Accessed >= s.MaxAccessed {
-		return false
-	}
-	if len(s.Files) == 0 {
-		return false
-	}
-	if !s.Creator.CanShare() {
-		return false
-	}
-	if s.Expires != nil && !s.Expires.IsZero() && s.Expires.Before(time.Now()) {
-		return false
-	}
-	return true
-}
-
-func (s *Sharing) Verify(pwd string) bool {
-	return s.Pwd == "" || s.Pwd == pwd
-}

internal/op/sharing.go

@@ -1,139 +0,0 @@
-package op
-
-import (
-	"fmt"
-	stdpath "path"
-	"strings"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/db"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/pkg/singleflight"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/OpenListTeam/go-cache"
-	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
-)
-
-func makeJoined(sdb []model.SharingDB) []model.Sharing {
-	creator := make(map[uint]*model.User)
-	return utils.MustSliceConvert(sdb, func(s model.SharingDB) model.Sharing {
-		var c *model.User
-		var ok bool
-		if c, ok = creator[s.CreatorId]; !ok {
-			var err error
-			if c, err = GetUserById(s.CreatorId); err != nil {
-				c = nil
-			} else {
-				creator[s.CreatorId] = c
-			}
-		}
-		var files []string
-		if err := utils.Json.UnmarshalFromString(s.FilesRaw, &files); err != nil {
-			files = make([]string, 0)
-		}
-		return model.Sharing{
-			SharingDB: &s,
-			Files:     files,
-			Creator:   c,
-		}
-	})
-}
-
-var sharingCache = cache.NewMemCache(cache.WithShards[*model.Sharing](8))
-var sharingG singleflight.Group[*model.Sharing]
-
-func GetSharingById(id string, refresh ...bool) (*model.Sharing, error) {
-	if !utils.IsBool(refresh...) {
-		if sharing, ok := sharingCache.Get(id); ok {
-			log.Debugf("use cache when get sharing %s", id)
-			return sharing, nil
-		}
-	}
-	sharing, err, _ := sharingG.Do(id, func() (*model.Sharing, error) {
-		s, err := db.GetSharingById(id)
-		if err != nil {
-			return nil, errors.WithMessagef(err, "failed get sharing [%s]", id)
-		}
-		creator, err := GetUserById(s.CreatorId)
-		if err != nil {
-			return nil, errors.WithMessagef(err, "failed get sharing creator [%s]", id)
-		}
-		var files []string
-		if err = utils.Json.UnmarshalFromString(s.FilesRaw, &files); err != nil {
-			files = make([]string, 0)
-		}
-		return &model.Sharing{
-			SharingDB: s,
-			Files:     files,
-			Creator:   creator,
-		}, nil
-	})
-	return sharing, err
-}
-
-func GetSharings(pageIndex, pageSize int) ([]model.Sharing, int64, error) {
-	s, cnt, err := db.GetSharings(pageIndex, pageSize)
-	if err != nil {
-		return nil, 0, errors.WithStack(err)
-	}
-	return makeJoined(s), cnt, nil
-}
-
-func GetSharingsByCreatorId(userId uint, pageIndex, pageSize int) ([]model.Sharing, int64, error) {
-	s, cnt, err := db.GetSharingsByCreatorId(userId, pageIndex, pageSize)
-	if err != nil {
-		return nil, 0, errors.WithStack(err)
-	}
-	return makeJoined(s), cnt, nil
-}
-
-func GetSharingUnwrapPath(sharing *model.Sharing, path string) (unwrapPath string, err error) {
-	if len(sharing.Files) == 0 {
-		return "", errors.New("cannot get actual path of an invalid sharing")
-	}
-	if len(sharing.Files) == 1 {
-		return stdpath.Join(sharing.Files[0], path), nil
-	}
-	path = utils.FixAndCleanPath(path)[1:]
-	if len(path) == 0 {
-		return "", errors.New("cannot get actual path of a sharing root path")
-	}
-	mapPath := ""
-	child, rest, _ := strings.Cut(path, "/")
-	for _, c := range sharing.Files {
-		if child == stdpath.Base(c) {
-			mapPath = c
-			break
-		}
-	}
-	if mapPath == "" {
-		return "", fmt.Errorf("failed find child [%s] of sharing [%s]", child, sharing.ID)
-	}
-	return stdpath.Join(mapPath, rest), nil
-}
-
-func CreateSharing(sharing *model.Sharing) (id string, err error) {
-	sharing.CreatorId = sharing.Creator.ID
-	sharing.FilesRaw, err = utils.Json.MarshalToString(utils.MustSliceConvert(sharing.Files, utils.FixAndCleanPath))
-	if err != nil {
-		return "", errors.WithStack(err)
-	}
-	return db.CreateSharing(sharing.SharingDB)
-}
-
-func UpdateSharing(sharing *model.Sharing, skipMarshal ...bool) (err error) {
-	if !utils.IsBool(skipMarshal...) {
-		sharing.CreatorId = sharing.Creator.ID
-		sharing.FilesRaw, err = utils.Json.MarshalToString(utils.MustSliceConvert(sharing.Files, utils.FixAndCleanPath))
-		if err != nil {
-			return errors.WithStack(err)
-		}
-	}
-	sharingCache.Del(sharing.ID)
-	return db.UpdateSharing(sharing.SharingDB)
-}
-
-func DeleteSharing(sid string) error {
-	sharingCache.Del(sid)
-	return db.DeleteSharingById(sid)
-}

internal/sharing/archive.go

@@ -1,65 +0,0 @@
-package sharing
-
-import (
-	"context"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/errs"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/internal/op"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/pkg/errors"
-)
-
-func archiveMeta(ctx context.Context, sid, path string, args model.SharingArchiveMetaArgs) (*model.Sharing, *model.ArchiveMetaProvider, error) {
-	sharing, err := op.GetSharingById(sid, args.Refresh)
-	if err != nil {
-		return nil, nil, errors.WithStack(errs.SharingNotFound)
-	}
-	if !sharing.Valid() {
-		return sharing, nil, errors.WithStack(errs.InvalidSharing)
-	}
-	if !sharing.Verify(args.Pwd) {
-		return sharing, nil, errors.WithStack(errs.WrongShareCode)
-	}
-	path = utils.FixAndCleanPath(path)
-	if len(sharing.Files) == 1 || path != "/" {
-		unwrapPath, err := op.GetSharingUnwrapPath(sharing, path)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing unwrap path")
-		}
-		storage, actualPath, err := op.GetStorageAndActualPath(unwrapPath)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing file")
-		}
-		obj, err := op.GetArchiveMeta(ctx, storage, actualPath, args.ArchiveMetaArgs)
-		return sharing, obj, err
-	}
-	return nil, nil, errors.New("cannot get sharing root archive meta")
-}
-
-func archiveList(ctx context.Context, sid, path string, args model.SharingArchiveListArgs) (*model.Sharing, []model.Obj, error) {
-	sharing, err := op.GetSharingById(sid, args.Refresh)
-	if err != nil {
-		return nil, nil, errors.WithStack(errs.SharingNotFound)
-	}
-	if !sharing.Valid() {
-		return sharing, nil, errors.WithStack(errs.InvalidSharing)
-	}
-	if !sharing.Verify(args.Pwd) {
-		return sharing, nil, errors.WithStack(errs.WrongShareCode)
-	}
-	path = utils.FixAndCleanPath(path)
-	if len(sharing.Files) == 1 || path != "/" {
-		unwrapPath, err := op.GetSharingUnwrapPath(sharing, path)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing unwrap path")
-		}
-		storage, actualPath, err := op.GetStorageAndActualPath(unwrapPath)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing file")
-		}
-		obj, err := op.ListArchive(ctx, storage, actualPath, args.ArchiveListArgs)
-		return sharing, obj, err
-	}
-	return nil, nil, errors.New("cannot get sharing root archive list")
-}

internal/sharing/get.go

@@ -1,60 +0,0 @@
-package sharing
-
-import (
-	"context"
-	stdpath "path"
-	"time"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/errs"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/internal/op"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/pkg/errors"
-)
-
-func get(ctx context.Context, sid, path string, args model.SharingListArgs) (*model.Sharing, model.Obj, error) {
-	sharing, err := op.GetSharingById(sid, args.Refresh)
-	if err != nil {
-		return nil, nil, errors.WithStack(errs.SharingNotFound)
-	}
-	if !sharing.Valid() {
-		return sharing, nil, errors.WithStack(errs.InvalidSharing)
-	}
-	if !sharing.Verify(args.Pwd) {
-		return sharing, nil, errors.WithStack(errs.WrongShareCode)
-	}
-	path = utils.FixAndCleanPath(path)
-	if len(sharing.Files) == 1 || path != "/" {
-		unwrapPath, err := op.GetSharingUnwrapPath(sharing, path)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing unwrap path")
-		}
-		if unwrapPath != "/" {
-			virtualFiles := op.GetStorageVirtualFilesByPath(stdpath.Dir(unwrapPath))
-			for _, f := range virtualFiles {
-				if f.GetName() == stdpath.Base(unwrapPath) {
-					return sharing, f, nil
-				}
-			}
-		} else {
-			return sharing, &model.Object{
-				Name:     sid,
-				Size:     0,
-				Modified: time.Time{},
-				IsFolder: true,
-			}, nil
-		}
-		storage, actualPath, err := op.GetStorageAndActualPath(unwrapPath)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing file")
-		}
-		obj, err := op.Get(ctx, storage, actualPath)
-		return sharing, obj, err
-	}
-	return sharing, &model.Object{
-		Name:     sid,
-		Size:     0,
-		Modified: time.Time{},
-		IsFolder: true,
-	}, nil
-}

internal/sharing/link.go

@@ -1,46 +0,0 @@
-package sharing
-
-import (
-	"context"
-	"strings"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/errs"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/internal/op"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/OpenListTeam/OpenList/v4/server/common"
-	"github.com/pkg/errors"
-)
-
-func link(ctx context.Context, sid, path string, args *LinkArgs) (*model.Sharing, *model.Link, model.Obj, error) {
-	sharing, err := op.GetSharingById(sid, args.SharingListArgs.Refresh)
-	if err != nil {
-		return nil, nil, nil, errors.WithStack(errs.SharingNotFound)
-	}
-	if !sharing.Valid() {
-		return sharing, nil, nil, errors.WithStack(errs.InvalidSharing)
-	}
-	if !sharing.Verify(args.Pwd) {
-		return sharing, nil, nil, errors.WithStack(errs.WrongShareCode)
-	}
-	path = utils.FixAndCleanPath(path)
-	if len(sharing.Files) == 1 || path != "/" {
-		unwrapPath, err := op.GetSharingUnwrapPath(sharing, path)
-		if err != nil {
-			return nil, nil, nil, errors.WithMessage(err, "failed get sharing unwrap path")
-		}
-		storage, actualPath, err := op.GetStorageAndActualPath(unwrapPath)
-		if err != nil {
-			return nil, nil, nil, errors.WithMessage(err, "failed get sharing link")
-		}
-		l, obj, err := op.Link(ctx, storage, actualPath, args.LinkArgs)
-		if err != nil {
-			return nil, nil, nil, errors.WithMessage(err, "failed get sharing link")
-		}
-		if l.URL != "" && !strings.HasPrefix(l.URL, "http://") && !strings.HasPrefix(l.URL, "https://") {
-			l.URL = common.GetApiUrl(ctx) + l.URL
-		}
-		return sharing, l, obj, nil
-	}
-	return nil, nil, nil, errors.New("cannot get sharing root link")
-}

internal/sharing/list.go

@@ -1,83 +0,0 @@
-package sharing
-
-import (
-	"context"
-	stdpath "path"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/errs"
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	"github.com/OpenListTeam/OpenList/v4/internal/op"
-	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
-	"github.com/pkg/errors"
-)
-
-func list(ctx context.Context, sid, path string, args model.SharingListArgs) (*model.Sharing, []model.Obj, error) {
-	sharing, err := op.GetSharingById(sid, args.Refresh)
-	if err != nil {
-		return nil, nil, errors.WithStack(errs.SharingNotFound)
-	}
-	if !sharing.Valid() {
-		return sharing, nil, errors.WithStack(errs.InvalidSharing)
-	}
-	if !sharing.Verify(args.Pwd) {
-		return sharing, nil, errors.WithStack(errs.WrongShareCode)
-	}
-	path = utils.FixAndCleanPath(path)
-	if len(sharing.Files) == 1 || path != "/" {
-		unwrapPath, err := op.GetSharingUnwrapPath(sharing, path)
-		if err != nil {
-			return nil, nil, errors.WithMessage(err, "failed get sharing unwrap path")
-		}
-		virtualFiles := op.GetStorageVirtualFilesByPath(unwrapPath)
-		storage, actualPath, err := op.GetStorageAndActualPath(unwrapPath)
-		if err != nil && len(virtualFiles) == 0 {
-			return nil, nil, errors.WithMessage(err, "failed list sharing")
-		}
-		var objs []model.Obj
-		if storage != nil {
-			objs, err = op.List(ctx, storage, actualPath, model.ListArgs{
-				Refresh: args.Refresh,
-				ReqPath: stdpath.Join(sid, path),
-			})
-			if err != nil && len(virtualFiles) == 0 {
-				return nil, nil, errors.WithMessage(err, "failed list sharing")
-			}
-		}
-		om := model.NewObjMerge()
-		objs = om.Merge(objs, virtualFiles...)
-		model.SortFiles(objs, sharing.OrderBy, sharing.OrderDirection)
-		model.ExtractFolder(objs, sharing.ExtractFolder)
-		return sharing, objs, nil
-	}
-	objs := make([]model.Obj, 0, len(sharing.Files))
-	for _, f := range sharing.Files {
-		if f != "/" {
-			isVf := false
-			virtualFiles := op.GetStorageVirtualFilesByPath(stdpath.Dir(f))
-			for _, vf := range virtualFiles {
-				if vf.GetName() == stdpath.Base(f) {
-					objs = append(objs, vf)
-					isVf = true
-					break
-				}
-			}
-			if isVf {
-				continue
-			}
-		} else {
-			continue
-		}
-		storage, actualPath, err := op.GetStorageAndActualPath(f)
-		if err != nil {
-			continue
-		}
-		obj, err := op.Get(ctx, storage, actualPath)
-		if err != nil {
-			continue
-		}
-		objs = append(objs, obj)
-	}
-	model.SortFiles(objs, sharing.OrderBy, sharing.OrderDirection)
-	model.ExtractFolder(objs, sharing.ExtractFolder)
-	return sharing, objs, nil
-}

internal/sharing/sharing.go

@@ -1,58 +0,0 @@
-package sharing
-
-import (
-	"context"
-
-	"github.com/OpenListTeam/OpenList/v4/internal/model"
-	log "github.com/sirupsen/logrus"
-)
-
-func List(ctx context.Context, sid, path string, args model.SharingListArgs) (*model.Sharing, []model.Obj, error) {
-	sharing, res, err := list(ctx, sid, path, args)
-	if err != nil {
-		log.Errorf("failed list sharing %s/%s: %+v", sid, path, err)
-		return nil, nil, err
-	}
-	return sharing, res, nil
-}
-
-func Get(ctx context.Context, sid, path string, args model.SharingListArgs) (*model.Sharing, model.Obj, error) {
-	sharing, res, err := get(ctx, sid, path, args)
-	if err != nil {
-		log.Warnf("failed get sharing %s/%s: %s", sid, path, err)
-		return nil, nil, err
-	}
-	return sharing, res, nil
-}
-
-func ArchiveMeta(ctx context.Context, sid, path string, args model.SharingArchiveMetaArgs) (*model.Sharing, *model.ArchiveMetaProvider, error) {
-	sharing, res, err := archiveMeta(ctx, sid, path, args)
-	if err != nil {
-		log.Warnf("failed get sharing archive meta %s/%s: %s", sid, path, err)
-		return nil, nil, err
-	}
-	return sharing, res, nil
-}
-
-func ArchiveList(ctx context.Context, sid, path string, args model.SharingArchiveListArgs) (*model.Sharing, []model.Obj, error) {
-	sharing, res, err := archiveList(ctx, sid, path, args)
-	if err != nil {
-		log.Warnf("failed list sharing archive %s/%s: %s", sid, path, err)
-		return nil, nil, err
-	}
-	return sharing, res, nil
-}
-
-type LinkArgs struct {
-	model.SharingListArgs
-	model.LinkArgs
-}
-
-func Link(ctx context.Context, sid, path string, args *LinkArgs) (*model.Sharing, *model.Link, model.Obj, error) {
-	sharing, res, file, err := link(ctx, sid, path, args)
-	if err != nil {
-		log.Errorf("failed get sharing link %s/%s: %+v", sid, path, err)
-		return nil, nil, nil, err
-	}
-	return sharing, res, file, nil
-}

layers/file/driver.go

@@ -0,0 +1,27 @@
+package file
+
+import "context"
+
+// HostFileServer 驱动文件接口 #################################################################
+type HostFileServer interface {
+	// CopyFile 复制文件 =======================================================================
+	CopyFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// MoveFile 移动文件 =======================================================================
+	MoveFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// NameFile 移动文件 =======================================================================
+	NameFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// ListFile 列举文件 =======================================================================
+	ListFile(ctx context.Context, path []string, opt *ListFileOption) ([]*HostFileObject, error)
+	// FindFile 搜索文件 =======================================================================
+	FindFile(ctx context.Context, path []string, opt *FindFileOption) ([]*HostFileObject, error)
+	// Download 获取文件 =======================================================================
+	Download(ctx context.Context, path []string, opt *DownloadOption) ([]*LinkFileObject, error)
+	// Uploader 上传文件 =======================================================================
+	Uploader(ctx context.Context, path []string, opt *UploaderOption) ([]*BackFileAction, error)
+	// KillFile 删除文件 =======================================================================
+	KillFile(ctx context.Context, path []string, opt *KillFileOption) ([]*BackFileAction, error)
+	// MakeFile 搜索文件 =======================================================================
+	MakeFile(ctx context.Context, path []string, opt *MakeFileOption) ([]*BackFileAction, error)
+	// MakePath 搜索文件 =======================================================================
+	MakePath(ctx context.Context, path []string, opt *MakeFileOption) ([]*BackFileAction, error)
+}

layers/file/manage.go

@@ -0,0 +1,71 @@
+package file
+
+import (
+	"context"
+)
+
+// UserFileServer 文件服务接口 #################################################################
+type UserFileServer interface {
+	// CopyFile 复制文件 =======================================================================
+	CopyFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// MoveFile 移动文件 =======================================================================
+	MoveFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// NameFile 移动文件 =======================================================================
+	NameFile(ctx context.Context, sources []string, targets []string) ([]*BackFileAction, error)
+	// ListFile 列举文件 =======================================================================
+	ListFile(ctx context.Context, path []string, opt *ListFileOption) ([]*UserFileObject, error)
+	// FindFile 搜索文件 =======================================================================
+	FindFile(ctx context.Context, path []string, opt *FindFileOption) ([]*UserFileObject, error)
+	// Download 获取文件 =======================================================================
+	Download(ctx context.Context, path []string, opt *DownloadOption) ([]*LinkFileObject, error)
+	// Uploader 上传文件 =======================================================================
+	Uploader(ctx context.Context, path []string, opt *UploaderOption) ([]*BackFileAction, error)
+	// KillFile 删除文件 =======================================================================
+	KillFile(ctx context.Context, path []string, opt *KillFileOption) ([]*BackFileAction, error)
+	// MakeFile 搜索文件 =======================================================================
+	MakeFile(ctx context.Context, path []string, opt *MakeFileOption) ([]*BackFileAction, error)
+	// MakePath 搜索文件 =======================================================================
+	MakePath(ctx context.Context, path []string, opt *MakeFileOption) ([]*BackFileAction, error)
+	// PermFile 设置权限 =======================================================================
+	PermFile(ctx context.Context, path []string, opt *PermissionFile) ([]*BackFileAction, error)
+	//// NewShare 创建分享 =======================================================================
+	//NewShare(ctx context.Context, path []string, opt *NewShareAction) ([]*BackFileAction, error)
+	//// GetShare 获取分享 =======================================================================
+	//GetShare(ctx context.Context, path []string, opt *NewShareAction) ([]*UserFileObject, error)
+	//// DelShare 删除分享 =======================================================================
+	//DelShare(ctx context.Context, path []string, opt *NewShareAction) ([]*BackFileAction, error)
+}
+
+type UserFileUpload interface {
+	fullPost(ctx context.Context, path []string)
+	pfCreate(ctx context.Context, path []string)
+	pfUpload(ctx context.Context, path []string)
+	pfUpdate(ctx context.Context, path []string)
+}
+
+func ListFile(ctx context.Context, path []string, opt *ListFileOption) ([]*UserFileObject, error) {
+	return ListDeal([]*HostFileObject{})
+}
+
+func FindFile(ctx context.Context, path []string, opt *ListFileOption) ([]*UserFileObject, error) {
+	return ListDeal([]*HostFileObject{})
+}
+
+func ListDeal(originList []*HostFileObject) ([]*UserFileObject, error) {
+	serverList := make([]*UserFileObject, 0)
+	for _, fileItem := range originList {
+		serverList = append(serverList, &UserFileObject{
+			HostFileObject: *fileItem,
+			// ... 用户层逻辑
+		})
+	}
+	return serverList, nil
+}
+
+func Download(ctx context.Context, path []string, opt *ListFileOption) ([]*LinkFileObject, error) {
+
+}
+
+func Uploader(ctx context.Context, path []string, opt *ListFileOption) ([]*BackFileAction, error) {
+
+}

layers/file/object.go

@@ -0,0 +1,79 @@
+package file
+
+import "time"
+
+// HostFileObject 驱动层获取获取的文件信息
+type HostFileObject struct {
+	realName []string  // 真实名称
+	previews []string  // 文件预览
+	fileSize int64     // 文件大小
+	lastTime time.Time // 修改时间
+	makeTime time.Time // 创建时间
+	fileType bool      // 文件类型
+	fileHash string    // 文件哈希
+	hashType int16     // 哈希类型
+}
+
+// UserFileObject 由用户层转换后的文件信息
+type UserFileObject struct {
+	HostFileObject
+	showPath []string // 文件路径
+	showName []string // 文件名称
+	realPath []string // 真实路径
+	checksum int32    // 密码校验
+	fileMask int16    // 文件权限
+	encrypts int16    // 文件状态
+
+	// 下列信息用于前端展示文件用
+	enc_type string // 加解密类型
+	enc_from string // 文件密码源
+	enc_pass string // 加解密密码
+	com_type string // 压缩的类型
+	sub_nums int16  // 子文件数量
+
+	// 下列信息用于后端内部处理用
+	// fileMask =================
+	// 占用：000000 0 000 000 000
+	// 含义：ABCDEF 1 421 421 421
+	// A-加密 B-前端解密 C-自解密
+	// D-is分卷 E-is压缩 F-is隐藏
+	// encrypts =================
+	// 占用位：0000000000 00 0000
+	// 含义为：分卷数量 压缩 加密
+}
+
+type PermissionFile struct {
+}
+
+type LinkFileObject struct {
+	download []string // 下载链接
+	usrAgent []string // 用户代理
+}
+
+type ListFileOption struct {
+}
+
+type FindFileOption struct {
+}
+
+type KillFileOption struct {
+}
+type MakeFileOption struct {
+}
+type DownloadOption struct {
+	downType int8 // 下载类型
+
+}
+type UploaderOption struct {
+}
+type BackFileAction struct {
+	success bool   // 是否成功
+	message string // 错误信息
+}
+type NewShareAction struct {
+	BackFileAction
+	shareID string    // 分享编码
+	pubUrls string    // 公开链接
+	passkey string    // 分析密码
+	expired time.Time // 过期时间
+}

layers/perm/fsmask.go

@@ -0,0 +1,16 @@
+package perm
+
+type FileMask struct {
+	uuid     string // 密钥UUID
+	user     string // 所属用户
+	path     string // 匹配路径
+	name     string // 友好名称
+	idKeyset string // 密钥集ID
+	encrypts string // 加密组ID
+	password string // 独立密码
+	fileUser string // 所有用户
+	filePart int64  // 分卷大小
+	fileMask int16  // 文件权限
+	compress int16  // 是否压缩
+	isEnable bool   // 是否启用
+}

layers/perm/keyset.go

@@ -0,0 +1,22 @@
+package perm
+
+type UserKeys struct {
+	uuid    string   // 密钥UUID
+	user    string   // 所属用户
+	main    string   // 核心密钥（用户密钥SHA2）
+	name    string   // 友好名称
+	algo    int8     // 密钥算法
+	enabled bool     // 是否启用
+	encFile bool     // 加密文件
+	encName bool     // 加密名称
+	keyAuto bool     // 自动更新
+	keyRand bool     // 随机密钥
+	keyAuth UserAuth // 密钥认证
+}
+
+type UserAuth struct {
+	uuid   string // 密钥UUID
+	user   string // 所属用户
+	plugin string // 认证插件
+	config string // 认证配置
+}

layers/perm/shared.go

@@ -0,0 +1,10 @@
+package perm
+
+type ShareUrl struct {
+	uuid string // 密钥UUID
+	user string // 所属用户
+	path string // 分享路径
+	pass string // 分享密码
+	date string // 过期时间
+	flag bool   // 是否有效
+}

layers/user/object.go

@@ -0,0 +1,14 @@
+package user
+
+type UserInfo struct {
+	uuid string   // 用户UUID
+	name string   // 用户名称
+	flag bool     // 是否有效
+	perm PermInfo // 权限信息
+}
+
+type PermInfo struct {
+	isAdmin bool // 是否管理员
+	davRead bool // 是否允许读
+	// ...
+}

main.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/OpenListTeam/OpenList/v4/cmd"
+import "github.com/OpenListTeam/OpenList/v5/cmd"
 
 func main() {
 	cmd.Execute()

origin/.gitignore

@@ -0,0 +1,34 @@
+.idea/
+.DS_Store
+output/
+/dist/
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.db
+*.bin
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+/bin/*
+*.json
+/build
+/data/
+/tmp/
+/log/
+/lang/
+/daemon/
+/public/dist/*
+/!public/dist/README.md
+
+.VSCodeCounter

origin/Dockerfile

@@ -14,17 +14,19 @@ FROM openlistteam/openlist-base-image:${BASE_IMAGE_TAG}
 LABEL MAINTAINER="OpenList"
 ARG INSTALL_FFMPEG=false
 ARG INSTALL_ARIA2=false
+ARG USER=openlist
+ARG UID=1001
+ARG GID=1001
 
 WORKDIR /opt/openlist/
 
-RUN addgroup -g 1001 openlist && \
-    adduser -D -u 1001 -G openlist openlist && \
-    mkdir -p /opt/openlist/data
+COPY --chmod=755 --from=builder /app/bin/openlist ./
+COPY --chmod=755 entrypoint.sh /entrypoint.sh
+RUN adduser -u ${UID} -g ${GID} -h /opt/openlist/data -D -s /bin/sh ${USER} \
+    && chown -R ${UID}:${GID} /opt \
+    && chown -R ${UID}:${GID} /entrypoint.sh
 
-COPY --from=builder --chmod=755 --chown=1001:1001 /app/bin/openlist ./
-COPY --chmod=755 --chown=1001:1001 entrypoint.sh /entrypoint.sh
-
-USER openlist
+USER ${USER}
 RUN /entrypoint.sh version
 
 ENV UMASK=022 RUN_ARIA2=${INSTALL_ARIA2}

origin/Dockerfile.ci

@@ -0,0 +1,26 @@
+ARG BASE_IMAGE_TAG=base
+FROM ghcr.io/openlistteam/openlist-base-image:${BASE_IMAGE_TAG}
+LABEL MAINTAINER="OpenList"
+ARG TARGETPLATFORM
+ARG INSTALL_FFMPEG=false
+ARG INSTALL_ARIA2=false
+ARG USER=openlist
+ARG UID=1001
+ARG GID=1001
+
+WORKDIR /opt/openlist/
+
+COPY --chmod=755 /build/${TARGETPLATFORM}/openlist ./
+COPY --chmod=755 entrypoint.sh /entrypoint.sh
+
+RUN adduser -u ${UID} -g ${GID} -h /opt/openlist/data -D -s /bin/sh ${USER} \
+    && chown -R ${UID}:${GID} /opt \
+    && chown -R ${UID}:${GID} /entrypoint.sh
+
+USER ${USER}
+RUN /entrypoint.sh version
+
+ENV UMASK=022 RUN_ARIA2=${INSTALL_ARIA2}
+VOLUME /opt/openlist/data/
+EXPOSE 5244 5245
+CMD [ "/entrypoint.sh" ]

origin/cmd/common.go

@@ -0,0 +1,51 @@
+package cmd
+
+import (
+	"os"
+	"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
+
+func initDaemon() {
+	ex, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+	exPath := filepath.Dir(ex)
+	_ = os.MkdirAll(filepath.Join(exPath, "daemon"), 0700)
+	pidFile = filepath.Join(exPath, "daemon/pid")
+	if utils.Exists(pidFile) {
+		bytes, err := os.ReadFile(pidFile)
+		if err != nil {
+			log.Fatal("failed to read pid file", err)
+		}
+		id, err := strconv.Atoi(string(bytes))
+		if err != nil {
+			log.Fatal("failed to parse pid data", err)
+		}
+		pid = id
+	}
+}

origin/cmd/flags/config.go

@@ -0,0 +1,10 @@
+package flags
+
+var (
+	DataDir     string
+	Debug       bool
+	NoPrefix    bool
+	Dev         bool
+	ForceBinDir bool
+	LogStd      bool
+)

origin/cmd/root.go

@@ -0,0 +1,36 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
+	_ "github.com/OpenListTeam/OpenList/v4/drivers"
+	_ "github.com/OpenListTeam/OpenList/v4/internal/archive"
+	_ "github.com/OpenListTeam/OpenList/v4/internal/offline_download"
+	"github.com/spf13/cobra"
+)
+
+var RootCmd = &cobra.Command{
+	Use:   "openlist",
+	Short: "A file list program that supports multiple storage.",
+	Long: `A file list program that supports multiple storage,
+built with love by OpenListTeam.
+Complete documentation is available at https://doc.oplist.org/`,
+}
+
+func Execute() {
+	if err := RootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	RootCmd.PersistentFlags().StringVar(&flags.DataDir, "data", "data", "data folder")
+	RootCmd.PersistentFlags().BoolVar(&flags.Debug, "debug", false, "start with debug mode")
+	RootCmd.PersistentFlags().BoolVar(&flags.NoPrefix, "no-prefix", false, "disable env prefix")
+	RootCmd.PersistentFlags().BoolVar(&flags.Dev, "dev", false, "start with dev mode")
+	RootCmd.PersistentFlags().BoolVar(&flags.ForceBinDir, "force-bin-dir", false, "Force to use the directory where the binary file is located as data directory")
+	RootCmd.PersistentFlags().BoolVar(&flags.LogStd, "log-std", false, "Force to log to std")
+}

origin/cmd/server.go

@@ -0,0 +1,261 @@
+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"
+)
+
+// ServerCmd represents the server command
+var ServerCmd = &cobra.Command{
+	Use:   "server",
+	Short: "Start the server at the specified address",
+	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
+		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.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())
+					}
+				}()
+			}
+		}
+		// Wait for interrupt signal to gracefully shutdown the server with
+		// a timeout of 1 second.
+		quit := make(chan os.Signal, 1)
+		// kill (no param) default send syscanll.SIGTERM
+		// kill -2 is syscall.SIGINT
+		// 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.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")
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(ServerCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// serverCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// serverCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+// OutOpenListInit 暴露用于外部启动server的函数
+func OutOpenListInit() {
+	var (
+		cmd  *cobra.Command
+		args []string
+	)
+	ServerCmd.Run(cmd, args)
+}

origin/docker-compose.yml

@@ -6,9 +6,10 @@ services:
     ports:
       - '5244:5244'
       - '5245:5245'
-    user: '0:0'
     environment:
+      - PUID=0
+      - PGID=0
       - UMASK=022
-      - TZ=Asia/Shanghai
+      - TZ=UTC
     container_name: openlist
     image: 'openlistteam/openlist:latest'