602 lines
14 KiB
Go
602 lines
14 KiB
Go
package service
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log"
|
||
"os"
|
||
"path"
|
||
"path/filepath"
|
||
"strings"
|
||
|
||
"dubbo.apache.org/dubbo-go/v3/common/logger"
|
||
"github.com/dubbogo/grpc-go/metadata"
|
||
filesApi "github.com/filebrowser/filebrowser/v2/api/files"
|
||
fbErrors "github.com/filebrowser/filebrowser/v2/errors"
|
||
"github.com/filebrowser/filebrowser/v2/files"
|
||
"github.com/filebrowser/filebrowser/v2/fileutils"
|
||
"github.com/filebrowser/filebrowser/v2/http"
|
||
"github.com/filebrowser/filebrowser/v2/img"
|
||
"github.com/filebrowser/filebrowser/v2/rules"
|
||
"github.com/filebrowser/filebrowser/v2/search"
|
||
"github.com/mholt/archiver/v3"
|
||
"github.com/samber/lo"
|
||
"github.com/spf13/afero"
|
||
)
|
||
|
||
type FilesProvider struct {
|
||
filesApi.UnimplementedFileServer
|
||
}
|
||
|
||
const BASE_PATH = "../"
|
||
|
||
var imgSvc = img.New(4) // 图片预览可用协程数
|
||
|
||
func (f *FilesProvider) List(ctx context.Context, req *filesApi.FileListReq) (*filesApi.FileListResp, error) {
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: getFs(req.UserSpacePath),
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: true,
|
||
ReadHeader: true,
|
||
Content: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !file.IsDir {
|
||
return nil, errors.New("路径不是文件夹")
|
||
}
|
||
file.Listing.Sorting.Asc = req.Sorting.Asc
|
||
file.Listing.Sorting.By = req.Sorting.By
|
||
file.Listing.ApplySort()
|
||
result := &filesApi.FileListResp{
|
||
NumDirs: int32(file.NumDirs),
|
||
NumFiles: int32(file.NumFiles),
|
||
Sorting: &filesApi.Sorting{
|
||
By: file.Sorting.By,
|
||
Asc: file.Sorting.Asc,
|
||
},
|
||
Path: file.Path,
|
||
Name: file.Name,
|
||
Size: file.Size,
|
||
Extension: file.Extension,
|
||
Mode: file.Mode.String(),
|
||
IsDir: file.IsDir,
|
||
IsSymlink: file.IsSymlink,
|
||
Type: file.Type,
|
||
Items: make([]*filesApi.Items, len(file.Listing.Items)),
|
||
}
|
||
for _, v := range file.Listing.Items {
|
||
result.Items = append(result.Items, &filesApi.Items{
|
||
Path: v.Path,
|
||
Name: v.Name,
|
||
Size: v.Size,
|
||
Extension: v.Extension,
|
||
Mode: v.Mode.String(),
|
||
IsDir: v.IsDir,
|
||
IsSymlink: v.IsSymlink,
|
||
Type: v.Type,
|
||
})
|
||
}
|
||
return result, err
|
||
}
|
||
|
||
func (f *FilesProvider) Create(ctx context.Context, req *filesApi.CreateReq) (*filesApi.CreateResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
return new(filesApi.CreateResp), fs.MkdirAll(req.Path, files.PermDir)
|
||
}
|
||
|
||
func (f *FilesProvider) Delete(ctx context.Context, req *filesApi.DeleteReq) (*filesApi.DeleteResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
return new(filesApi.DeleteResp), fs.RemoveAll(req.Path)
|
||
}
|
||
|
||
func (f *FilesProvider) Upload(ctx context.Context, req *filesApi.UploadReq) (*filesApi.UploadResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
fi, err := fs.Create(req.Path)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer fi.Close()
|
||
_, err = fi.Write(req.Content)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return new(filesApi.UploadResp), nil
|
||
}
|
||
|
||
func (f *FilesProvider) Search(ctx context.Context, req *filesApi.SearchReq) (*filesApi.SearchResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
result := new(filesApi.SearchResp)
|
||
err := search.Search(fs, req.Path, req.Query, rules.EmptyChecker, func(path string, f os.FileInfo) error {
|
||
result.Items = append(result.Items, &filesApi.SearchResp_Nested{
|
||
Dir: f.IsDir(),
|
||
Path: path,
|
||
})
|
||
|
||
return nil
|
||
})
|
||
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return result, err
|
||
}
|
||
|
||
func (f *FilesProvider) TusCreate(ctx context.Context, req *filesApi.TusCreateReq) (*filesApi.TusCreateResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
switch {
|
||
case errors.Is(err, afero.ErrFileNotFound):
|
||
dirPath := filepath.Dir(req.Path)
|
||
if _, statErr := fs.Stat(dirPath); os.IsNotExist(statErr) {
|
||
if mkdirErr := fs.MkdirAll(dirPath, files.PermDir); mkdirErr != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
case err != nil:
|
||
return nil, err
|
||
}
|
||
fileFlags := os.O_CREATE | os.O_WRONLY
|
||
if req.Override {
|
||
fileFlags |= os.O_TRUNC
|
||
}
|
||
|
||
// if file exists
|
||
if file != nil {
|
||
if file.IsDir {
|
||
return nil, fmt.Errorf("上传路径不能是文件夹 %s", file.RealPath())
|
||
}
|
||
}
|
||
|
||
openFile, err := fs.OpenFile(req.Path, fileFlags, files.PermFile)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := openFile.Close(); err != nil {
|
||
return nil, err
|
||
}
|
||
logger.Infof("创建空文件，%v", openFile.Name())
|
||
return &filesApi.TusCreateResp{
|
||
UploadLength: -1,
|
||
UploadOffset: 0,
|
||
}, nil
|
||
}
|
||
|
||
func (f *FilesProvider) TusUpload(ctx context.Context, req *filesApi.TusUploadReq) (*filesApi.TusUploadResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
switch {
|
||
case errors.Is(err, afero.ErrFileNotFound):
|
||
return nil, errors.New("未找到文件")
|
||
case err != nil:
|
||
return nil, err
|
||
}
|
||
|
||
switch {
|
||
case file.IsDir:
|
||
return nil, fmt.Errorf("上传路径不能是文件夹 %s", file.RealPath())
|
||
case file.Size != req.UploadOffset:
|
||
return nil, fmt.Errorf(
|
||
"%s 文件大小符合: %d",
|
||
file.RealPath(),
|
||
req.UploadOffset,
|
||
)
|
||
}
|
||
openFile, err := fs.OpenFile(req.Path, os.O_WRONLY|os.O_APPEND, files.PermFile)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("could not open file: %w", err)
|
||
}
|
||
defer openFile.Close()
|
||
|
||
_, err = openFile.Seek(req.UploadOffset, 0)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("could not seek file: %w", err)
|
||
}
|
||
|
||
logger.Infof("写入文件块，offset:%v，块大小：%vbyte", req.UploadOffset, len(req.Content))
|
||
bytesWritten, err := io.Copy(openFile, bytes.NewBuffer(req.Content))
|
||
if err != nil {
|
||
return nil, fmt.Errorf("could not write to file: %w", err)
|
||
}
|
||
return &filesApi.TusUploadResp{
|
||
UploadOffset: bytesWritten,
|
||
}, nil
|
||
}
|
||
|
||
func (f *FilesProvider) Info(ctx context.Context, req *filesApi.FileInfoReq) (*filesApi.FileInfoResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
switch {
|
||
case errors.Is(err, afero.ErrFileNotFound):
|
||
return nil, errors.New("未找到文件")
|
||
case err != nil:
|
||
return nil, err
|
||
}
|
||
result := &filesApi.FileInfoResp{
|
||
Path: file.Path,
|
||
Name: file.Name,
|
||
Size: file.Size,
|
||
Extension: file.Extension,
|
||
Mode: file.Mode.String(),
|
||
IsDir: file.IsDir,
|
||
IsSymlink: file.IsSymlink,
|
||
Type: file.Type,
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func (f *FilesProvider) ResumableTransfer(ctx context.Context, req *filesApi.ResumableTransferReq) (*filesApi.ResumableTransferResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
_, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
switch {
|
||
case errors.Is(err, afero.ErrFileNotFound):
|
||
return nil, errors.New("未找到文件")
|
||
case err != nil:
|
||
return nil, err
|
||
}
|
||
openFile, err := fs.Open(req.Path)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("could not open file: %w", err)
|
||
}
|
||
defer openFile.Close()
|
||
logger.Debugf("设置文件读取，offset:%v，length：%v", req.Offset, req.Length)
|
||
_, err = openFile.Seek(req.Offset, 0)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
b := make([]byte, req.Length)
|
||
n, err := openFile.Read(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &filesApi.ResumableTransferResp{
|
||
Content: b[:n],
|
||
}, nil
|
||
}
|
||
|
||
func (f *FilesProvider) Preview(ctx context.Context, req *filesApi.PreviewReq) (*filesApi.PreviewResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: true,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
switch file.Type {
|
||
case "image":
|
||
{
|
||
b, err := f.createPreview(imgSvc, file, req.Size)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &filesApi.PreviewResp{
|
||
Content: b,
|
||
}, nil
|
||
|
||
}
|
||
default:
|
||
return nil, errors.New("目前只支持图片类型的预览")
|
||
}
|
||
}
|
||
|
||
func (f *FilesProvider) createPreview(imgSvc http.ImgService,
|
||
file *files.FileInfo, previewSize uint32) ([]byte, error) {
|
||
fd, err := file.Fs.Open(file.Path)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer fd.Close()
|
||
|
||
var (
|
||
width int
|
||
height int
|
||
options []img.Option
|
||
)
|
||
|
||
switch {
|
||
case previewSize == 1:
|
||
width = 1080
|
||
height = 1080
|
||
options = append(options, img.WithMode(img.ResizeModeFit), img.WithQuality(img.QualityMedium))
|
||
case previewSize == 0:
|
||
width = 256
|
||
height = 256
|
||
options = append(options, img.WithMode(img.ResizeModeFill), img.WithQuality(img.QualityLow), img.WithFormat(img.FormatJpeg))
|
||
default:
|
||
return nil, img.ErrUnsupportedFormat
|
||
}
|
||
|
||
buf := &bytes.Buffer{}
|
||
if err := imgSvc.Resize(context.Background(), fd, width, height, buf, options...); err != nil {
|
||
return nil, err
|
||
}
|
||
return buf.Bytes(), nil
|
||
}
|
||
|
||
func (f *FilesProvider) Action(_ context.Context, req *filesApi.ActionReq) (*filesApi.ActionResp, error) {
|
||
fs := getFs(req.UserSpacePath)
|
||
if req.Destination == "/" || req.Path == "/" {
|
||
return nil, errors.New("禁止操作用户空间根目录")
|
||
}
|
||
err := checkParent(req.Path, req.Destination)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !req.Override && !req.Rename {
|
||
if _, err = fs.Stat(req.Destination); err == nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
if req.Rename {
|
||
req.Destination = addVersionSuffix(req.Destination, fs)
|
||
}
|
||
return &filesApi.ActionResp{}, patchAction(req.Action, req.Path, req.Destination, fs)
|
||
}
|
||
|
||
func (f *FilesProvider) DirDownload(req *filesApi.DirDownloadReq, stream filesApi.File_DirDownloadServer) error {
|
||
var filenames []string
|
||
writer := newFileDownloadWriter(stream)
|
||
fs := getFs(req.UserSpacePath)
|
||
file, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: req.Path,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: true,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
if len(req.Files) == 0 {
|
||
filenames = append(filenames, file.Path)
|
||
} else {
|
||
filenames = lo.Map(req.Files, func(name string, _ int) string {
|
||
return filepath.Join(req.Path, slashClean(name))
|
||
})
|
||
}
|
||
|
||
extension, ar, err := parseQueryAlgorithm(req.Algo)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
err = ar.Create(writer)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer ar.Close()
|
||
|
||
commonDir := fileutils.CommonPrefix(filepath.Separator, filenames...)
|
||
|
||
name := filepath.Base(commonDir)
|
||
if name == "." || name == "" || name == string(filepath.Separator) {
|
||
name = file.Name
|
||
}
|
||
// Prefix used to distinguish a filelist generated
|
||
// archive from the full directory archive
|
||
if len(filenames) > 1 {
|
||
name = "_" + name
|
||
}
|
||
name += extension
|
||
stream.SendHeader(metadata.MD{
|
||
"filename": []string{name},
|
||
})
|
||
for _, fname := range filenames {
|
||
err = addFile(ar, fs, fname, commonDir)
|
||
if err != nil {
|
||
log.Printf("Failed to archive %s: %v", fname, err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
type fileDownloadWriter struct { // 用于实现archiver.Writer.Create(out io.Writer) error
|
||
stream filesApi.File_DirDownloadServer
|
||
}
|
||
|
||
func (f *fileDownloadWriter) Write(p []byte) (n int, err error) {
|
||
err = f.stream.Send(&filesApi.DirDownloadResp{
|
||
Content: p,
|
||
})
|
||
if err == nil {
|
||
n = len(p)
|
||
}
|
||
return
|
||
}
|
||
|
||
func newFileDownloadWriter(stream filesApi.File_DirDownloadServer) *fileDownloadWriter {
|
||
return &fileDownloadWriter{
|
||
stream: stream,
|
||
}
|
||
}
|
||
|
||
func getFs(userSpacePath string) afero.Fs {
|
||
bashAbs, _ := filepath.Abs(BASE_PATH)
|
||
|
||
if !strings.HasPrefix(userSpacePath, "/") {
|
||
userSpacePath = "/" + userSpacePath
|
||
}
|
||
_, err := os.Stat(bashAbs + userSpacePath)
|
||
if err != nil {
|
||
os.MkdirAll(bashAbs+userSpacePath, os.ModeDir)
|
||
}
|
||
return afero.NewBasePathFs(afero.NewOsFs(), bashAbs+userSpacePath)
|
||
}
|
||
|
||
func checkParent(src, dst string) error {
|
||
rel, err := filepath.Rel(src, dst)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
rel = filepath.ToSlash(rel)
|
||
if !strings.HasPrefix(rel, "../") && rel != ".." && rel != "." {
|
||
return fbErrors.ErrSourceIsParent
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func addVersionSuffix(source string, fs afero.Fs) string {
|
||
counter := 1
|
||
dir, name := path.Split(source)
|
||
ext := filepath.Ext(name)
|
||
base := strings.TrimSuffix(name, ext)
|
||
|
||
for {
|
||
if _, err := fs.Stat(source); err != nil {
|
||
break
|
||
}
|
||
renamed := fmt.Sprintf("%s(%d)%s", base, counter, ext)
|
||
source = path.Join(dir, renamed)
|
||
counter++
|
||
}
|
||
|
||
return source
|
||
}
|
||
|
||
func patchAction(action, src, dst string, fs afero.Fs) error {
|
||
switch action {
|
||
case "copy":
|
||
return fileutils.Copy(fs, src, dst)
|
||
case "rename":
|
||
src = path.Clean("/" + src)
|
||
dst = path.Clean("/" + dst)
|
||
|
||
_, err := files.NewFileInfo(&files.FileOptions{
|
||
Fs: fs,
|
||
Path: src,
|
||
Modify: true,
|
||
Expand: false,
|
||
ReadHeader: false,
|
||
Checker: rules.EmptyChecker,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
return fileutils.MoveFile(fs, src, dst)
|
||
default:
|
||
return fmt.Errorf("unsupported action %s: %w", action, fbErrors.ErrInvalidRequestParams)
|
||
}
|
||
}
|
||
|
||
func slashClean(name string) string {
|
||
if name == "" || name[0] != '/' {
|
||
name = "/" + name
|
||
}
|
||
return path.Clean(name)
|
||
}
|
||
|
||
func parseQueryAlgorithm(algo string) (string, archiver.Writer, error) {
|
||
switch algo {
|
||
case "zip", "true", "":
|
||
return ".zip", archiver.NewZip(), nil
|
||
case "tar":
|
||
return ".tar", archiver.NewTar(), nil
|
||
case "targz":
|
||
return ".tar.gz", archiver.NewTarGz(), nil
|
||
case "tarbz2":
|
||
return ".tar.bz2", archiver.NewTarBz2(), nil
|
||
case "tarxz":
|
||
return ".tar.xz", archiver.NewTarXz(), nil
|
||
case "tarlz4":
|
||
return ".tar.lz4", archiver.NewTarLz4(), nil
|
||
case "tarsz":
|
||
return ".tar.sz", archiver.NewTarSz(), nil
|
||
default:
|
||
return "", nil, errors.New("format not implemented")
|
||
}
|
||
}
|
||
|
||
func addFile(ar archiver.Writer, fs afero.Fs, path, commonPath string) error {
|
||
info, err := fs.Stat(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
if !info.IsDir() && !info.Mode().IsRegular() {
|
||
return nil
|
||
}
|
||
|
||
file, err := fs.Open(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer file.Close()
|
||
|
||
if path != commonPath {
|
||
filename := strings.TrimPrefix(path, commonPath)
|
||
filename = strings.TrimPrefix(filename, string(filepath.Separator))
|
||
err = ar.Write(archiver.File{
|
||
FileInfo: archiver.FileInfo{
|
||
FileInfo: info,
|
||
CustomName: filename,
|
||
},
|
||
ReadCloser: file,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
if info.IsDir() {
|
||
names, err := file.Readdirnames(0)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, name := range names {
|
||
fPath := filepath.Join(path, name)
|
||
err = addFile(ar, fs, fPath, commonPath)
|
||
if err != nil {
|
||
log.Printf("Failed to archive %s: %v", fPath, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|