Feat: upyun download / thumb / sign

pkg/filesystem/driver/local/file.go

@@ -0,0 +1,38 @@
+package local
+
+import (
+	"io"
+)
+
+// FileStream 用户传来的文件
+type FileStream struct {
+	File        io.ReadCloser
+	Size        uint64
+	VirtualPath string
+	Name        string
+	MIMEType    string
+}
+
+func (file FileStream) Read(p []byte) (n int, err error) {
+	return file.File.Read(p)
+}
+
+func (file FileStream) GetMIMEType() string {
+	return file.MIMEType
+}
+
+func (file FileStream) GetSize() uint64 {
+	return file.Size
+}
+
+func (file FileStream) Close() error {
+	return file.File.Close()
+}
+
+func (file FileStream) GetFileName() string {
+	return file.Name
+}
+
+func (file FileStream) GetVirtualPath() string {
+	return file.VirtualPath
+}

pkg/filesystem/driver/local/file_test.go

@@ -0,0 +1,48 @@
+package local
+
+import (
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+func TestFileStream_GetFileName(t *testing.T) {
+	asserts := assert.New(t)
+	file := FileStream{Name: "123"}
+	asserts.Equal("123", file.GetFileName())
+}
+
+func TestFileStream_GetMIMEType(t *testing.T) {
+	asserts := assert.New(t)
+	file := FileStream{MIMEType: "123"}
+	asserts.Equal("123", file.GetMIMEType())
+}
+
+func TestFileStream_GetSize(t *testing.T) {
+	asserts := assert.New(t)
+	file := FileStream{Size: 123}
+	asserts.Equal(uint64(123), file.GetSize())
+}
+
+func TestFileStream_Read(t *testing.T) {
+	asserts := assert.New(t)
+	file := FileStream{
+		File: ioutil.NopCloser(strings.NewReader("123")),
+	}
+	var p = make([]byte, 3)
+	{
+		n, err := file.Read(p)
+		asserts.Equal(3, n)
+		asserts.NoError(err)
+	}
+}
+
+func TestFileStream_Close(t *testing.T) {
+	asserts := assert.New(t)
+	file := FileStream{
+		File: ioutil.NopCloser(strings.NewReader("123")),
+	}
+	err := file.Close()
+	asserts.NoError(err)
+}

pkg/filesystem/driver/local/handler.go

@@ -0,0 +1,165 @@
+package local
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	model "github.com/HFO4/cloudreve/models"
+	"github.com/HFO4/cloudreve/pkg/auth"
+	"github.com/HFO4/cloudreve/pkg/cache"
+	"github.com/HFO4/cloudreve/pkg/conf"
+	"github.com/HFO4/cloudreve/pkg/filesystem/fsctx"
+	"github.com/HFO4/cloudreve/pkg/filesystem/response"
+	"github.com/HFO4/cloudreve/pkg/serializer"
+	"github.com/HFO4/cloudreve/pkg/util"
+	"io"
+	"net/url"
+	"os"
+	"path/filepath"
+)
+
+// Driver 本地策略适配器
+type Driver struct {
+	Policy *model.Policy
+}
+
+// Get 获取文件内容
+func (handler Driver) Get(ctx context.Context, path string) (response.RSCloser, error) {
+	// 打开文件
+	file, err := os.Open(path)
+	if err != nil {
+		util.Log().Debug("无法打开文件：%s", err)
+		return nil, err
+	}
+
+	// 开启一个协程，用于请求结束后关闭reader
+	// go closeReader(ctx, file)
+
+	return file, nil
+}
+
+// closeReader 用于在请求结束后关闭reader
+// TODO 让业务代码自己关闭
+func closeReader(ctx context.Context, closer io.Closer) {
+	select {
+	case <-ctx.Done():
+		_ = closer.Close()
+
+	}
+}
+
+// Put 将文件流保存到指定目录
+func (handler Driver) Put(ctx context.Context, file io.ReadCloser, dst string, size uint64) error {
+	defer file.Close()
+	dst = filepath.FromSlash(dst)
+
+	// 如果目标目录不存在，创建
+	basePath := filepath.Dir(dst)
+	if !util.Exists(basePath) {
+		err := os.MkdirAll(basePath, 0700)
+		if err != nil {
+			util.Log().Warning("无法创建目录，%s", err)
+			return err
+		}
+	}
+
+	// 创建目标文件
+	out, err := os.Create(dst)
+	if err != nil {
+		util.Log().Warning("无法创建文件，%s", err)
+		return err
+	}
+	defer out.Close()
+
+	// 写入文件内容
+	_, err = io.Copy(out, file)
+	return err
+}
+
+// Delete 删除一个或多个文件，
+// 返回未删除的文件，及遇到的最后一个错误
+func (handler Driver) Delete(ctx context.Context, files []string) ([]string, error) {
+	deleteFailed := make([]string, 0, len(files))
+	var retErr error
+
+	for _, value := range files {
+		err := os.Remove(filepath.FromSlash(value))
+		if err != nil {
+			util.Log().Warning("无法删除文件，%s", err)
+			retErr = err
+			deleteFailed = append(deleteFailed, value)
+		}
+
+		// 尝试删除文件的缩略图（如果有）
+		_ = os.Remove(value + conf.ThumbConfig.FileSuffix)
+	}
+
+	return deleteFailed, retErr
+}
+
+// Thumb 获取文件缩略图
+func (handler Driver) Thumb(ctx context.Context, path string) (*response.ContentResponse, error) {
+	file, err := handler.Get(ctx, path+conf.ThumbConfig.FileSuffix)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response.ContentResponse{
+		Redirect: false,
+		Content:  file,
+	}, nil
+}
+
+// Source 获取外链URL
+func (handler Driver) Source(
+	ctx context.Context,
+	path string,
+	baseURL url.URL,
+	ttl int64,
+	isDownload bool,
+	speed int,
+) (string, error) {
+	file, ok := ctx.Value(fsctx.FileModelCtx).(model.File)
+	if !ok {
+		return "", errors.New("无法获取文件记录上下文")
+	}
+
+	var (
+		signedURI *url.URL
+		err       error
+	)
+	if isDownload {
+		// 创建下载会话，将文件信息写入缓存
+		downloadSessionID := util.RandStringRunes(16)
+		err = cache.Set("download_"+downloadSessionID, file, int(ttl))
+		if err != nil {
+			return "", serializer.NewError(serializer.CodeCacheOperation, "无法创建下载会话", err)
+		}
+
+		// 签名生成文件记录
+		signedURI, err = auth.SignURI(
+			auth.General,
+			fmt.Sprintf("/api/v3/file/download/%s", downloadSessionID),
+			ttl,
+		)
+	} else {
+		// 签名生成文件记录
+		signedURI, err = auth.SignURI(
+			auth.General,
+			fmt.Sprintf("/api/v3/file/get/%d/%s", file.ID, file.Name),
+			ttl,
+		)
+	}
+
+	if err != nil {
+		return "", serializer.NewError(serializer.CodeEncryptError, "无法对URL进行签名", err)
+	}
+
+	finalURL := baseURL.ResolveReference(signedURI).String()
+	return finalURL, nil
+}
+
+// Token 获取上传策略和认证Token，本地策略直接返回空值
+func (handler Driver) Token(ctx context.Context, ttl int64, key string) (serializer.UploadCredential, error) {
+	return serializer.UploadCredential{}, nil
+}

pkg/filesystem/driver/local/handller_test.go

@@ -0,0 +1,194 @@
+package local
+
+import (
+	"context"
+	model "github.com/HFO4/cloudreve/models"
+	"github.com/HFO4/cloudreve/pkg/auth"
+	"github.com/HFO4/cloudreve/pkg/conf"
+	"github.com/HFO4/cloudreve/pkg/filesystem/fsctx"
+	"github.com/HFO4/cloudreve/pkg/util"
+	"github.com/jinzhu/gorm"
+	"github.com/stretchr/testify/assert"
+	"io"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestHandler_Put(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+
+	testCases := []struct {
+		file io.ReadCloser
+		dst  string
+		err  bool
+	}{
+		{
+			file: ioutil.NopCloser(strings.NewReader("test input file")),
+			dst:  "test/test/txt",
+			err:  false,
+		},
+		{
+			file: ioutil.NopCloser(strings.NewReader("test input file")),
+			dst:  "/notexist:/S.TXT",
+			err:  true,
+		},
+	}
+
+	for _, testCase := range testCases {
+		err := handler.Put(ctx, testCase.file, testCase.dst, 15)
+		if testCase.err {
+			asserts.Error(err)
+		} else {
+			asserts.NoError(err)
+			asserts.True(util.Exists(testCase.dst))
+		}
+	}
+}
+
+func TestHandler_Delete(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+
+	file, err := os.Create("test.file")
+	asserts.NoError(err)
+	_ = file.Close()
+	list, err := handler.Delete(ctx, []string{"test.file"})
+	asserts.Equal([]string{}, list)
+	asserts.NoError(err)
+
+	file, err = os.Create("test.file")
+	asserts.NoError(err)
+	_ = file.Close()
+	list, err = handler.Delete(ctx, []string{"test.file", "test.notexist"})
+	asserts.Equal([]string{"test.notexist"}, list)
+	asserts.Error(err)
+
+	list, err = handler.Delete(ctx, []string{"test.notexist"})
+	asserts.Equal([]string{"test.notexist"}, list)
+	asserts.Error(err)
+}
+
+func TestHandler_Get(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// 成功
+	file, err := os.Create("TestHandler_Get.txt")
+	asserts.NoError(err)
+	_ = file.Close()
+
+	rs, err := handler.Get(ctx, "TestHandler_Get.txt")
+	asserts.NoError(err)
+	asserts.NotNil(rs)
+
+	// 文件不存在
+
+	rs, err = handler.Get(ctx, "TestHandler_Get_notExist.txt")
+	asserts.Error(err)
+	asserts.Nil(rs)
+}
+
+func TestHandler_Thumb(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+	file, err := os.Create("TestHandler_Thumb" + conf.ThumbConfig.FileSuffix)
+	asserts.NoError(err)
+	file.Close()
+
+	// 正常
+	{
+		thumb, err := handler.Thumb(ctx, "TestHandler_Thumb")
+		asserts.NoError(err)
+		asserts.NotNil(thumb.Content)
+	}
+
+	// 不存在
+	{
+		_, err := handler.Thumb(ctx, "not_exist")
+		asserts.Error(err)
+	}
+}
+
+func TestHandler_Source(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+	auth.General = auth.HMACAuth{SecretKey: []byte("test")}
+
+	// 成功
+	{
+		file := model.File{
+			Model: gorm.Model{
+				ID: 1,
+			},
+			Name: "test.jpg",
+		}
+		ctx := context.WithValue(ctx, fsctx.FileModelCtx, file)
+		baseURL, err := url.Parse("https://cloudreve.org")
+		asserts.NoError(err)
+		sourceURL, err := handler.Source(ctx, "", *baseURL, 0, false, 0)
+		asserts.NoError(err)
+		asserts.NotEmpty(sourceURL)
+		asserts.Contains(sourceURL, "sign=")
+		asserts.Contains(sourceURL, "https://cloudreve.org")
+	}
+
+	// 无法获取上下文
+	{
+		baseURL, err := url.Parse("https://cloudreve.org")
+		asserts.NoError(err)
+		sourceURL, err := handler.Source(ctx, "", *baseURL, 0, false, 0)
+		asserts.Error(err)
+		asserts.Empty(sourceURL)
+	}
+}
+
+func TestHandler_GetDownloadURL(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+	auth.General = auth.HMACAuth{SecretKey: []byte("test")}
+
+	// 成功
+	{
+		file := model.File{
+			Model: gorm.Model{
+				ID: 1,
+			},
+			Name: "test.jpg",
+		}
+		ctx := context.WithValue(ctx, fsctx.FileModelCtx, file)
+		baseURL, err := url.Parse("https://cloudreve.org")
+		asserts.NoError(err)
+		downloadURL, err := handler.Source(ctx, "", *baseURL, 10, true, 0)
+		asserts.NoError(err)
+		asserts.Contains(downloadURL, "sign=")
+		asserts.Contains(downloadURL, "https://cloudreve.org")
+	}
+
+	// 无法获取上下文
+	{
+		baseURL, err := url.Parse("https://cloudreve.org")
+		asserts.NoError(err)
+		downloadURL, err := handler.Source(ctx, "", *baseURL, 10, true, 0)
+		asserts.Error(err)
+		asserts.Empty(downloadURL)
+	}
+}
+
+func TestHandler_Token(t *testing.T) {
+	asserts := assert.New(t)
+	handler := Driver{}
+	ctx := context.Background()
+	_, err := handler.Token(ctx, 10, "123")
+	asserts.NoError(err)
+}