init

pkg/filesystem/driver/onedrive/api.go

@@ -0,0 +1,595 @@
+package onedrive
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path"
+	"strconv"
+	"strings"
+	"time"
+
+	model "github.com/cloudreve/Cloudreve/v3/models"
+	"github.com/cloudreve/Cloudreve/v3/pkg/cache"
+	"github.com/cloudreve/Cloudreve/v3/pkg/conf"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/chunk"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/chunk/backoff"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/fsctx"
+	"github.com/cloudreve/Cloudreve/v3/pkg/mq"
+	"github.com/cloudreve/Cloudreve/v3/pkg/request"
+	"github.com/cloudreve/Cloudreve/v3/pkg/util"
+)
+
+const (
+	// SmallFileSize 单文件上传接口最大尺寸
+	SmallFileSize uint64 = 4 * 1024 * 1024
+	// ChunkSize 服务端中转分片上传分片大小
+	ChunkSize uint64 = 10 * 1024 * 1024
+	// ListRetry 列取请求重试次数
+	ListRetry       = 1
+	chunkRetrySleep = time.Second * 5
+
+	notFoundError = "itemNotFound"
+)
+
+// GetSourcePath 获取文件的绝对路径
+func (info *FileInfo) GetSourcePath() string {
+	res, err := url.PathUnescape(info.ParentReference.Path)
+	if err != nil {
+		return ""
+	}
+
+	return strings.TrimPrefix(
+		path.Join(
+			strings.TrimPrefix(res, "/drive/root:"),
+			info.Name,
+		),
+		"/",
+	)
+}
+
+func (client *Client) getRequestURL(api string, opts ...Option) string {
+	options := newDefaultOption()
+	for _, o := range opts {
+		o.apply(options)
+	}
+
+	base, _ := url.Parse(client.Endpoints.EndpointURL)
+	if base == nil {
+		return ""
+	}
+
+	if options.useDriverResource {
+		base.Path = path.Join(base.Path, client.Endpoints.DriverResource, api)
+	} else {
+		base.Path = path.Join(base.Path, api)
+	}
+
+	return base.String()
+}
+
+// ListChildren 根据路径列取子对象
+func (client *Client) ListChildren(ctx context.Context, path string) ([]FileInfo, error) {
+	var requestURL string
+	dst := strings.TrimPrefix(path, "/")
+	if dst == "" {
+		requestURL = client.getRequestURL("root/children")
+	} else {
+		requestURL = client.getRequestURL("root:/" + dst + ":/children")
+	}
+
+	res, err := client.requestWithStr(ctx, "GET", requestURL+"?$top=999999999", "", 200)
+	if err != nil {
+		retried := 0
+		if v, ok := ctx.Value(fsctx.RetryCtx).(int); ok {
+			retried = v
+		}
+		if retried < ListRetry {
+			retried++
+			util.Log().Debug("Failed to list path %q: %s, will retry in 5 seconds.", path, err)
+			time.Sleep(time.Duration(5) * time.Second)
+			return client.ListChildren(context.WithValue(ctx, fsctx.RetryCtx, retried), path)
+		}
+		return nil, err
+	}
+
+	var (
+		decodeErr error
+		fileInfo  ListResponse
+	)
+	decodeErr = json.Unmarshal([]byte(res), &fileInfo)
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	return fileInfo.Value, nil
+}
+
+// Meta 根据资源ID或文件路径获取文件元信息
+func (client *Client) Meta(ctx context.Context, id string, path string) (*FileInfo, error) {
+	var requestURL string
+	if id != "" {
+		requestURL = client.getRequestURL("items/" + id)
+	} else {
+		dst := strings.TrimPrefix(path, "/")
+		requestURL = client.getRequestURL("root:/" + dst)
+	}
+
+	res, err := client.requestWithStr(ctx, "GET", requestURL+"?expand=thumbnails", "", 200)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		decodeErr error
+		fileInfo  FileInfo
+	)
+	decodeErr = json.Unmarshal([]byte(res), &fileInfo)
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	return &fileInfo, nil
+
+}
+
+// CreateUploadSession 创建分片上传会话
+func (client *Client) CreateUploadSession(ctx context.Context, dst string, opts ...Option) (string, error) {
+	options := newDefaultOption()
+	for _, o := range opts {
+		o.apply(options)
+	}
+
+	dst = strings.TrimPrefix(dst, "/")
+	requestURL := client.getRequestURL("root:/" + dst + ":/createUploadSession")
+	body := map[string]map[string]interface{}{
+		"item": {
+			"@microsoft.graph.conflictBehavior": options.conflictBehavior,
+		},
+	}
+	bodyBytes, _ := json.Marshal(body)
+
+	res, err := client.requestWithStr(ctx, "POST", requestURL, string(bodyBytes), 200)
+	if err != nil {
+		return "", err
+	}
+
+	var (
+		decodeErr     error
+		uploadSession UploadSessionResponse
+	)
+	decodeErr = json.Unmarshal([]byte(res), &uploadSession)
+	if decodeErr != nil {
+		return "", decodeErr
+	}
+
+	return uploadSession.UploadURL, nil
+}
+
+// GetSiteIDByURL 通过 SharePoint 站点 URL 获取站点ID
+func (client *Client) GetSiteIDByURL(ctx context.Context, siteUrl string) (string, error) {
+	siteUrlParsed, err := url.Parse(siteUrl)
+	if err != nil {
+		return "", err
+	}
+
+	hostName := siteUrlParsed.Hostname()
+	relativePath := strings.Trim(siteUrlParsed.Path, "/")
+	requestURL := client.getRequestURL(fmt.Sprintf("sites/%s:/%s", hostName, relativePath), WithDriverResource(false))
+	res, reqErr := client.requestWithStr(ctx, "GET", requestURL, "", 200)
+	if reqErr != nil {
+		return "", reqErr
+	}
+
+	var (
+		decodeErr error
+		siteInfo  Site
+	)
+	decodeErr = json.Unmarshal([]byte(res), &siteInfo)
+	if decodeErr != nil {
+		return "", decodeErr
+	}
+
+	return siteInfo.ID, nil
+}
+
+// GetUploadSessionStatus 查询上传会话状态
+func (client *Client) GetUploadSessionStatus(ctx context.Context, uploadURL string) (*UploadSessionResponse, error) {
+	res, err := client.requestWithStr(ctx, "GET", uploadURL, "", 200)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		decodeErr     error
+		uploadSession UploadSessionResponse
+	)
+	decodeErr = json.Unmarshal([]byte(res), &uploadSession)
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	return &uploadSession, nil
+}
+
+// UploadChunk 上传分片
+func (client *Client) UploadChunk(ctx context.Context, uploadURL string, content io.Reader, current *chunk.ChunkGroup) (*UploadSessionResponse, error) {
+	res, err := client.request(
+		ctx, "PUT", uploadURL, content,
+		request.WithContentLength(current.Length()),
+		request.WithHeader(http.Header{
+			"Content-Range": {current.RangeHeader()},
+		}),
+		request.WithoutHeader([]string{"Authorization", "Content-Type"}),
+		request.WithTimeout(0),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to upload OneDrive chunk #%d: %w", current.Index(), err)
+	}
+
+	if current.IsLast() {
+		return nil, nil
+	}
+
+	var (
+		decodeErr error
+		uploadRes UploadSessionResponse
+	)
+	decodeErr = json.Unmarshal([]byte(res), &uploadRes)
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	return &uploadRes, nil
+}
+
+// Upload 上传文件
+func (client *Client) Upload(ctx context.Context, file fsctx.FileHeader) error {
+	fileInfo := file.Info()
+	// 决定是否覆盖文件
+	overwrite := "fail"
+	if fileInfo.Mode&fsctx.Overwrite == fsctx.Overwrite {
+		overwrite = "replace"
+	}
+
+	size := int(fileInfo.Size)
+	dst := fileInfo.SavePath
+
+	// 小文件，使用简单上传接口上传
+	if size <= int(SmallFileSize) {
+		_, err := client.SimpleUpload(ctx, dst, file, int64(size), WithConflictBehavior(overwrite))
+		return err
+	}
+
+	// 大文件，进行分片
+	// 创建上传会话
+	uploadURL, err := client.CreateUploadSession(ctx, dst, WithConflictBehavior(overwrite))
+	if err != nil {
+		return err
+	}
+
+	// Initial chunk groups
+	chunks := chunk.NewChunkGroup(file, client.Policy.OptionsSerialized.ChunkSize, &backoff.ConstantBackoff{
+		Max:   model.GetIntSetting("chunk_retries", 5),
+		Sleep: chunkRetrySleep,
+	}, model.IsTrueVal(model.GetSettingByName("use_temp_chunk_buffer")))
+
+	uploadFunc := func(current *chunk.ChunkGroup, content io.Reader) error {
+		_, err := client.UploadChunk(ctx, uploadURL, content, current)
+		return err
+	}
+
+	// upload chunks
+	for chunks.Next() {
+		if err := chunks.Process(uploadFunc); err != nil {
+			return fmt.Errorf("failed to upload chunk #%d: %w", chunks.Index(), err)
+		}
+	}
+
+	return nil
+}
+
+// DeleteUploadSession 删除上传会话
+func (client *Client) DeleteUploadSession(ctx context.Context, uploadURL string) error {
+	_, err := client.requestWithStr(ctx, "DELETE", uploadURL, "", 204)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// SimpleUpload 上传小文件到dst
+func (client *Client) SimpleUpload(ctx context.Context, dst string, body io.Reader, size int64, opts ...Option) (*UploadResult, error) {
+	options := newDefaultOption()
+	for _, o := range opts {
+		o.apply(options)
+	}
+
+	dst = strings.TrimPrefix(dst, "/")
+	requestURL := client.getRequestURL("root:/" + dst + ":/content")
+	requestURL += ("?@microsoft.graph.conflictBehavior=" + options.conflictBehavior)
+
+	res, err := client.request(ctx, "PUT", requestURL, body, request.WithContentLength(int64(size)),
+		request.WithTimeout(0),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		decodeErr error
+		uploadRes UploadResult
+	)
+	decodeErr = json.Unmarshal([]byte(res), &uploadRes)
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	return &uploadRes, nil
+}
+
+// BatchDelete 并行删除给出的文件，返回删除失败的文件，及第一个遇到的错误。此方法将文件分为
+// 20个一组，调用Delete并行删除
+// TODO 测试
+func (client *Client) BatchDelete(ctx context.Context, dst []string) ([]string, error) {
+	groupNum := len(dst)/20 + 1
+	finalRes := make([]string, 0, len(dst))
+	res := make([]string, 0, 20)
+	var err error
+
+	for i := 0; i < groupNum; i++ {
+		end := 20*i + 20
+		if i == groupNum-1 {
+			end = len(dst)
+		}
+		res, err = client.Delete(ctx, dst[20*i:end])
+		finalRes = append(finalRes, res...)
+	}
+
+	return finalRes, err
+}
+
+// Delete 并行删除文件，返回删除失败的文件，及第一个遇到的错误，
+// 由于API限制，最多删除20个
+func (client *Client) Delete(ctx context.Context, dst []string) ([]string, error) {
+	body := client.makeBatchDeleteRequestsBody(dst)
+	res, err := client.requestWithStr(ctx, "POST", client.getRequestURL("$batch",
+		WithDriverResource(false)), body, 200)
+	if err != nil {
+		return dst, err
+	}
+
+	var (
+		decodeErr error
+		deleteRes BatchResponses
+	)
+	decodeErr = json.Unmarshal([]byte(res), &deleteRes)
+	if decodeErr != nil {
+		return dst, decodeErr
+	}
+
+	// 取得删除失败的文件
+	failed := getDeleteFailed(&deleteRes)
+	if len(failed) != 0 {
+		return failed, ErrDeleteFile
+	}
+	return failed, nil
+}
+
+func getDeleteFailed(res *BatchResponses) []string {
+	var failed = make([]string, 0, len(res.Responses))
+	for _, v := range res.Responses {
+		if v.Status != 204 && v.Status != 404 {
+			failed = append(failed, v.ID)
+		}
+	}
+	return failed
+}
+
+// makeBatchDeleteRequestsBody 生成批量删除请求正文
+func (client *Client) makeBatchDeleteRequestsBody(files []string) string {
+	req := BatchRequests{
+		Requests: make([]BatchRequest, len(files)),
+	}
+	for i, v := range files {
+		v = strings.TrimPrefix(v, "/")
+		filePath, _ := url.Parse("/" + client.Endpoints.DriverResource + "/root:/")
+		filePath.Path = path.Join(filePath.Path, v)
+		req.Requests[i] = BatchRequest{
+			ID:     v,
+			Method: "DELETE",
+			URL:    filePath.EscapedPath(),
+		}
+	}
+
+	res, _ := json.Marshal(req)
+	return string(res)
+}
+
+// GetThumbURL 获取给定尺寸的缩略图URL
+func (client *Client) GetThumbURL(ctx context.Context, dst string, w, h uint) (string, error) {
+	dst = strings.TrimPrefix(dst, "/")
+	requestURL := client.getRequestURL("root:/"+dst+":/thumbnails/0") + "/large"
+
+	res, err := client.requestWithStr(ctx, "GET", requestURL, "", 200)
+	if err != nil {
+		return "", err
+	}
+
+	var (
+		decodeErr error
+		thumbRes  ThumbResponse
+	)
+	decodeErr = json.Unmarshal([]byte(res), &thumbRes)
+	if decodeErr != nil {
+		return "", decodeErr
+	}
+
+	if thumbRes.URL != "" {
+		return thumbRes.URL, nil
+	}
+
+	if len(thumbRes.Value) == 1 {
+		if res, ok := thumbRes.Value[0]["large"]; ok {
+			return res.(map[string]interface{})["url"].(string), nil
+		}
+	}
+
+	return "", ErrThumbSizeNotFound
+}
+
+// MonitorUpload 监控客户端分片上传进度
+func (client *Client) MonitorUpload(uploadURL, callbackKey, path string, size uint64, ttl int64) {
+	// 回调完成通知chan
+	callbackChan := mq.GlobalMQ.Subscribe(callbackKey, 1)
+	defer mq.GlobalMQ.Unsubscribe(callbackKey, callbackChan)
+
+	timeout := model.GetIntSetting("onedrive_monitor_timeout", 600)
+	interval := model.GetIntSetting("onedrive_callback_check", 20)
+
+	for {
+		select {
+		case <-callbackChan:
+			util.Log().Debug("Client finished OneDrive callback.")
+			return
+		case <-time.After(time.Duration(ttl) * time.Second):
+			// 上传会话到期，仍未完成上传，创建占位符
+			client.DeleteUploadSession(context.Background(), uploadURL)
+			_, err := client.SimpleUpload(context.Background(), path, strings.NewReader(""), 0, WithConflictBehavior("replace"))
+			if err != nil {
+				util.Log().Debug("Failed to create placeholder file: %s", err)
+			}
+			return
+		case <-time.After(time.Duration(timeout) * time.Second):
+			util.Log().Debug("Checking OneDrive upload status.")
+			status, err := client.GetUploadSessionStatus(context.Background(), uploadURL)
+
+			if err != nil {
+				if resErr, ok := err.(*RespError); ok {
+					if resErr.APIError.Code == notFoundError {
+						util.Log().Debug("Upload completed, will check upload callback later.")
+						select {
+						case <-time.After(time.Duration(interval) * time.Second):
+							util.Log().Warning("No callback is made, file will be deleted.")
+							cache.Deletes([]string{callbackKey}, "callback_")
+							_, err = client.Delete(context.Background(), []string{path})
+							if err != nil {
+								util.Log().Warning("Failed to delete file without callback: %s", err)
+							}
+						case <-callbackChan:
+							util.Log().Debug("Client finished callback.")
+						}
+						return
+					}
+				}
+				util.Log().Debug("Failed to get upload session status: %s, continue next iteration.", err.Error())
+				continue
+			}
+
+			// 成功获取分片上传状态，检查文件大小
+			if len(status.NextExpectedRanges) == 0 {
+				continue
+			}
+			sizeRange := strings.Split(
+				status.NextExpectedRanges[len(status.NextExpectedRanges)-1],
+				"-",
+			)
+			if len(sizeRange) != 2 {
+				continue
+			}
+			uploadFullSize, _ := strconv.ParseUint(sizeRange[1], 10, 64)
+			if (sizeRange[0] == "0" && sizeRange[1] == "") || uploadFullSize+1 != size {
+				util.Log().Debug("Upload has not started, or uploaded file size not match, canceling upload session...")
+				// 取消上传会话，实测OneDrive取消上传会话后，客户端还是可以上传，
+				// 所以上传一个空文件占位，阻止客户端上传
+				client.DeleteUploadSession(context.Background(), uploadURL)
+				_, err := client.SimpleUpload(context.Background(), path, strings.NewReader(""), 0, WithConflictBehavior("replace"))
+				if err != nil {
+					util.Log().Debug("无法创建占位文件，%s", err)
+				}
+				return
+			}
+
+		}
+	}
+}
+
+func sysError(err error) *RespError {
+	return &RespError{APIError: APIError{
+		Code:    "system",
+		Message: err.Error(),
+	}}
+}
+
+func (client *Client) request(ctx context.Context, method string, url string, body io.Reader, option ...request.Option) (string, error) {
+	// 获取凭证
+	err := client.UpdateCredential(ctx, conf.SystemConfig.Mode == "slave")
+	if err != nil {
+		return "", sysError(err)
+	}
+
+	option = append(option,
+		request.WithHeader(http.Header{
+			"Authorization": {"Bearer " + client.Credential.AccessToken},
+			"Content-Type":  {"application/json"},
+		}),
+		request.WithContext(ctx),
+		request.WithTPSLimit(
+			fmt.Sprintf("policy_%d", client.Policy.ID),
+			client.Policy.OptionsSerialized.TPSLimit,
+			client.Policy.OptionsSerialized.TPSLimitBurst,
+		),
+	)
+
+	// 发送请求
+	res := client.Request.Request(
+		method,
+		url,
+		body,
+		option...,
+	)
+
+	if res.Err != nil {
+		return "", sysError(res.Err)
+	}
+
+	respBody, err := res.GetResponse()
+	if err != nil {
+		return "", sysError(err)
+	}
+
+	// 解析请求响应
+	var (
+		errResp   RespError
+		decodeErr error
+	)
+	// 如果有错误
+	if res.Response.StatusCode < 200 || res.Response.StatusCode >= 300 {
+		decodeErr = json.Unmarshal([]byte(respBody), &errResp)
+		if decodeErr != nil {
+			util.Log().Debug("Onedrive returns unknown response: %s", respBody)
+			return "", sysError(decodeErr)
+		}
+
+		if res.Response.StatusCode == 429 {
+			util.Log().Warning("OneDrive request is throttled.")
+			return "", backoff.NewRetryableErrorFromHeader(&errResp, res.Response.Header)
+		}
+
+		return "", &errResp
+	}
+
+	return respBody, nil
+}
+
+func (client *Client) requestWithStr(ctx context.Context, method string, url string, body string, expectedCode int) (string, error) {
+	// 发送请求
+	bodyReader := io.NopCloser(strings.NewReader(body))
+	return client.request(ctx, method, url, bodyReader,
+		request.WithContentLength(int64(len(body))),
+	)
+}

pkg/filesystem/driver/onedrive/client.go

@@ -0,0 +1,78 @@
+package onedrive
+
+import (
+	"errors"
+
+	"github.com/cloudreve/Cloudreve/v3/pkg/cluster"
+
+	model "github.com/cloudreve/Cloudreve/v3/models"
+	"github.com/cloudreve/Cloudreve/v3/pkg/request"
+)
+
+var (
+	// ErrAuthEndpoint 无法解析授权端点地址
+	ErrAuthEndpoint = errors.New("failed to parse endpoint url")
+	// ErrInvalidRefreshToken 上传策略无有效的RefreshToken
+	ErrInvalidRefreshToken = errors.New("no valid refresh token in this policy")
+	// ErrDeleteFile 无法删除文件
+	ErrDeleteFile = errors.New("cannot delete file")
+	// ErrClientCanceled 客户端取消操作
+	ErrClientCanceled = errors.New("client canceled")
+	// Desired thumb size not available
+	ErrThumbSizeNotFound = errors.New("thumb size not found")
+)
+
+// Client OneDrive客户端
+type Client struct {
+	Endpoints  *Endpoints
+	Policy     *model.Policy
+	Credential *Credential
+
+	ClientID     string
+	ClientSecret string
+	Redirect     string
+
+	Request           request.Client
+	ClusterController cluster.Controller
+}
+
+// Endpoints OneDrive客户端相关设置
+type Endpoints struct {
+	OAuthURL       string // OAuth认证的基URL
+	OAuthEndpoints *oauthEndpoint
+	EndpointURL    string // 接口请求的基URL
+	isInChina      bool   // 是否为世纪互联
+	DriverResource string // 要使用的驱动器
+}
+
+// NewClient 根据存储策略获取新的client
+func NewClient(policy *model.Policy) (*Client, error) {
+	client := &Client{
+		Endpoints: &Endpoints{
+			OAuthURL:       policy.BaseURL,
+			EndpointURL:    policy.Server,
+			DriverResource: policy.OptionsSerialized.OdDriver,
+		},
+		Credential: &Credential{
+			RefreshToken: policy.AccessKey,
+		},
+		Policy:            policy,
+		ClientID:          policy.BucketName,
+		ClientSecret:      policy.SecretKey,
+		Redirect:          policy.OptionsSerialized.OauthRedirect,
+		Request:           request.NewClient(),
+		ClusterController: cluster.DefaultController,
+	}
+
+	if client.Endpoints.DriverResource == "" {
+		client.Endpoints.DriverResource = "me/drive"
+	}
+
+	oauthBase := client.getOAuthEndpoint()
+	if oauthBase == nil {
+		return nil, ErrAuthEndpoint
+	}
+	client.Endpoints.OAuthEndpoints = oauthBase
+
+	return client, nil
+}

pkg/filesystem/driver/onedrive/handler.go

@@ -0,0 +1,238 @@
+package onedrive
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	model "github.com/cloudreve/Cloudreve/v3/models"
+	"github.com/cloudreve/Cloudreve/v3/pkg/cache"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/driver"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/fsctx"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/response"
+	"github.com/cloudreve/Cloudreve/v3/pkg/request"
+	"github.com/cloudreve/Cloudreve/v3/pkg/serializer"
+)
+
+// Driver OneDrive 适配器
+type Driver struct {
+	Policy     *model.Policy
+	Client     *Client
+	HTTPClient request.Client
+}
+
+// NewDriver 从存储策略初始化新的Driver实例
+func NewDriver(policy *model.Policy) (driver.Handler, error) {
+	client, err := NewClient(policy)
+	if policy.OptionsSerialized.ChunkSize == 0 {
+		policy.OptionsSerialized.ChunkSize = 50 << 20 // 50MB
+	}
+
+	return Driver{
+		Policy:     policy,
+		Client:     client,
+		HTTPClient: request.NewClient(),
+	}, err
+}
+
+// List 列取项目
+func (handler Driver) List(ctx context.Context, base string, recursive bool) ([]response.Object, error) {
+	base = strings.TrimPrefix(base, "/")
+	// 列取子项目
+	objects, _ := handler.Client.ListChildren(ctx, base)
+
+	// 获取真实的列取起始根目录
+	rootPath := base
+	if realBase, ok := ctx.Value(fsctx.PathCtx).(string); ok {
+		rootPath = realBase
+	} else {
+		ctx = context.WithValue(ctx, fsctx.PathCtx, base)
+	}
+
+	// 整理结果
+	res := make([]response.Object, 0, len(objects))
+	for _, object := range objects {
+		source := path.Join(base, object.Name)
+		rel, err := filepath.Rel(rootPath, source)
+		if err != nil {
+			continue
+		}
+		res = append(res, response.Object{
+			Name:         object.Name,
+			RelativePath: filepath.ToSlash(rel),
+			Source:       source,
+			Size:         object.Size,
+			IsDir:        object.Folder != nil,
+			LastModify:   time.Now(),
+		})
+	}
+
+	// 递归列取子目录
+	if recursive {
+		for _, object := range objects {
+			if object.Folder != nil {
+				sub, _ := handler.List(ctx, path.Join(base, object.Name), recursive)
+				res = append(res, sub...)
+			}
+		}
+	}
+
+	return res, nil
+}
+
+// Get 获取文件
+func (handler Driver) Get(ctx context.Context, path string) (response.RSCloser, error) {
+	// 获取文件源地址
+	downloadURL, err := handler.Source(
+		ctx,
+		path,
+		60,
+		false,
+		0,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取文件数据流
+	resp, err := handler.HTTPClient.Request(
+		"GET",
+		downloadURL,
+		nil,
+		request.WithContext(ctx),
+		request.WithTimeout(time.Duration(0)),
+	).CheckHTTPResponse(200).GetRSCloser()
+	if err != nil {
+		return nil, err
+	}
+
+	resp.SetFirstFakeChunk()
+
+	// 尝试自主获取文件大小
+	if file, ok := ctx.Value(fsctx.FileModelCtx).(model.File); ok {
+		resp.SetContentLength(int64(file.Size))
+	}
+
+	return resp, nil
+}
+
+// Put 将文件流保存到指定目录
+func (handler Driver) Put(ctx context.Context, file fsctx.FileHeader) error {
+	defer file.Close()
+
+	return handler.Client.Upload(ctx, file)
+}
+
+// Delete 删除一个或多个文件，
+// 返回未删除的文件，及遇到的最后一个错误
+func (handler Driver) Delete(ctx context.Context, files []string) ([]string, error) {
+	return handler.Client.BatchDelete(ctx, files)
+}
+
+// Thumb 获取文件缩略图
+func (handler Driver) Thumb(ctx context.Context, file *model.File) (*response.ContentResponse, error) {
+	var (
+		thumbSize = [2]uint{400, 300}
+		ok        = false
+	)
+	if thumbSize, ok = ctx.Value(fsctx.ThumbSizeCtx).([2]uint); !ok {
+		return nil, errors.New("failed to get thumbnail size")
+	}
+
+	res, err := handler.Client.GetThumbURL(ctx, file.SourceName, thumbSize[0], thumbSize[1])
+	if err != nil {
+		var apiErr *RespError
+		if errors.As(err, &apiErr); err == ErrThumbSizeNotFound || (apiErr != nil && apiErr.APIError.Code == notFoundError) {
+			// OneDrive cannot generate thumbnail for this file
+			return nil, driver.ErrorThumbNotSupported
+		}
+	}
+
+	return &response.ContentResponse{
+		Redirect: true,
+		URL:      res,
+	}, err
+}
+
+// Source 获取外链URL
+func (handler Driver) Source(
+	ctx context.Context,
+	path string,
+	ttl int64,
+	isDownload bool,
+	speed int,
+) (string, error) {
+	cacheKey := fmt.Sprintf("onedrive_source_%d_%s", handler.Policy.ID, path)
+	if file, ok := ctx.Value(fsctx.FileModelCtx).(model.File); ok {
+		cacheKey = fmt.Sprintf("onedrive_source_file_%d_%d", file.UpdatedAt.Unix(), file.ID)
+	}
+
+	// 尝试从缓存中查找
+	if cachedURL, ok := cache.Get(cacheKey); ok {
+		return handler.replaceSourceHost(cachedURL.(string))
+	}
+
+	// 缓存不存在，重新获取
+	res, err := handler.Client.Meta(ctx, "", path)
+	if err == nil {
+		// 写入新的缓存
+		cache.Set(
+			cacheKey,
+			res.DownloadURL,
+			model.GetIntSetting("onedrive_source_timeout", 1800),
+		)
+		return handler.replaceSourceHost(res.DownloadURL)
+	}
+	return "", err
+}
+
+func (handler Driver) replaceSourceHost(origin string) (string, error) {
+	if handler.Policy.OptionsSerialized.OdProxy != "" {
+		source, err := url.Parse(origin)
+		if err != nil {
+			return "", err
+		}
+
+		cdn, err := url.Parse(handler.Policy.OptionsSerialized.OdProxy)
+		if err != nil {
+			return "", err
+		}
+
+		// 替换反代地址
+		source.Scheme = cdn.Scheme
+		source.Host = cdn.Host
+		return source.String(), nil
+	}
+
+	return origin, nil
+}
+
+// Token 获取上传会话URL
+func (handler Driver) Token(ctx context.Context, ttl int64, uploadSession *serializer.UploadSession, file fsctx.FileHeader) (*serializer.UploadCredential, error) {
+	fileInfo := file.Info()
+
+	uploadURL, err := handler.Client.CreateUploadSession(ctx, fileInfo.SavePath, WithConflictBehavior("fail"))
+	if err != nil {
+		return nil, err
+	}
+
+	// 监控回调及上传
+	go handler.Client.MonitorUpload(uploadURL, uploadSession.Key, fileInfo.SavePath, fileInfo.Size, ttl)
+
+	uploadSession.UploadURL = uploadURL
+	return &serializer.UploadCredential{
+		SessionID:  uploadSession.Key,
+		ChunkSize:  handler.Policy.OptionsSerialized.ChunkSize,
+		UploadURLs: []string{uploadURL},
+	}, nil
+}
+
+// 取消上传凭证
+func (handler Driver) CancelToken(ctx context.Context, uploadSession *serializer.UploadSession) error {
+	return handler.Client.DeleteUploadSession(ctx, uploadSession.UploadURL)
+}

pkg/filesystem/driver/onedrive/lock.go

@@ -0,0 +1,25 @@
+package onedrive
+
+import "sync"
+
+// CredentialLock 针对存储策略凭证的锁
+type CredentialLock interface {
+	Lock(uint)
+	Unlock(uint)
+}
+
+var GlobalMutex = mutexMap{}
+
+type mutexMap struct {
+	locks sync.Map
+}
+
+func (m *mutexMap) Lock(id uint) {
+	lock, _ := m.locks.LoadOrStore(id, &sync.Mutex{})
+	lock.(*sync.Mutex).Lock()
+}
+
+func (m *mutexMap) Unlock(id uint) {
+	lock, _ := m.locks.LoadOrStore(id, &sync.Mutex{})
+	lock.(*sync.Mutex).Unlock()
+}

pkg/filesystem/driver/onedrive/oauth.go

@@ -0,0 +1,192 @@
+package onedrive
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/cloudreve/Cloudreve/v3/pkg/cache"
+	"github.com/cloudreve/Cloudreve/v3/pkg/filesystem/oauth"
+	"github.com/cloudreve/Cloudreve/v3/pkg/request"
+	"github.com/cloudreve/Cloudreve/v3/pkg/util"
+)
+
+// Error 实现error接口
+func (err OAuthError) Error() string {
+	return err.ErrorDescription
+}
+
+// OAuthURL 获取OAuth认证页面URL
+func (client *Client) OAuthURL(ctx context.Context, scope []string) string {
+	query := url.Values{
+		"client_id":     {client.ClientID},
+		"scope":         {strings.Join(scope, " ")},
+		"response_type": {"code"},
+		"redirect_uri":  {client.Redirect},
+	}
+	client.Endpoints.OAuthEndpoints.authorize.RawQuery = query.Encode()
+	return client.Endpoints.OAuthEndpoints.authorize.String()
+}
+
+// getOAuthEndpoint 根据指定的AuthURL获取详细的认证接口地址
+func (client *Client) getOAuthEndpoint() *oauthEndpoint {
+	base, err := url.Parse(client.Endpoints.OAuthURL)
+	if err != nil {
+		return nil
+	}
+	var (
+		token     *url.URL
+		authorize *url.URL
+	)
+	switch base.Host {
+	case "login.live.com":
+		token, _ = url.Parse("https://login.live.com/oauth20_token.srf")
+		authorize, _ = url.Parse("https://login.live.com/oauth20_authorize.srf")
+	case "login.chinacloudapi.cn":
+		client.Endpoints.isInChina = true
+		token, _ = url.Parse("https://login.chinacloudapi.cn/common/oauth2/v2.0/token")
+		authorize, _ = url.Parse("https://login.chinacloudapi.cn/common/oauth2/v2.0/authorize")
+	default:
+		token, _ = url.Parse("https://login.microsoftonline.com/common/oauth2/v2.0/token")
+		authorize, _ = url.Parse("https://login.microsoftonline.com/common/oauth2/v2.0/authorize")
+	}
+
+	return &oauthEndpoint{
+		token:     *token,
+		authorize: *authorize,
+	}
+}
+
+// ObtainToken 通过code或refresh_token兑换token
+func (client *Client) ObtainToken(ctx context.Context, opts ...Option) (*Credential, error) {
+	options := newDefaultOption()
+	for _, o := range opts {
+		o.apply(options)
+	}
+
+	body := url.Values{
+		"client_id":     {client.ClientID},
+		"redirect_uri":  {client.Redirect},
+		"client_secret": {client.ClientSecret},
+	}
+	if options.code != "" {
+		body.Add("grant_type", "authorization_code")
+		body.Add("code", options.code)
+	} else {
+		body.Add("grant_type", "refresh_token")
+		body.Add("refresh_token", options.refreshToken)
+	}
+	strBody := body.Encode()
+
+	res := client.Request.Request(
+		"POST",
+		client.Endpoints.OAuthEndpoints.token.String(),
+		ioutil.NopCloser(strings.NewReader(strBody)),
+		request.WithHeader(http.Header{
+			"Content-Type": {"application/x-www-form-urlencoded"}},
+		),
+		request.WithContentLength(int64(len(strBody))),
+	)
+	if res.Err != nil {
+		return nil, res.Err
+	}
+
+	respBody, err := res.GetResponse()
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		errResp    OAuthError
+		credential Credential
+		decodeErr  error
+	)
+
+	if res.Response.StatusCode != 200 {
+		decodeErr = json.Unmarshal([]byte(respBody), &errResp)
+	} else {
+		decodeErr = json.Unmarshal([]byte(respBody), &credential)
+	}
+	if decodeErr != nil {
+		return nil, decodeErr
+	}
+
+	if errResp.ErrorType != "" {
+		return nil, errResp
+	}
+
+	return &credential, nil
+
+}
+
+// UpdateCredential 更新凭证，并检查有效期
+func (client *Client) UpdateCredential(ctx context.Context, isSlave bool) error {
+	if isSlave {
+		return client.fetchCredentialFromMaster(ctx)
+	}
+
+	oauth.GlobalMutex.Lock(client.Policy.ID)
+	defer oauth.GlobalMutex.Unlock(client.Policy.ID)
+
+	// 如果已存在凭证
+	if client.Credential != nil && client.Credential.AccessToken != "" {
+		// 检查已有凭证是否过期
+		if client.Credential.ExpiresIn > time.Now().Unix() {
+			// 未过期，不要更新
+			return nil
+		}
+	}
+
+	// 尝试从缓存中获取凭证
+	if cacheCredential, ok := cache.Get("onedrive_" + client.ClientID); ok {
+		credential := cacheCredential.(Credential)
+		if credential.ExpiresIn > time.Now().Unix() {
+			client.Credential = &credential
+			return nil
+		}
+	}
+
+	// 获取新的凭证
+	if client.Credential == nil || client.Credential.RefreshToken == "" {
+		// 无有效的RefreshToken
+		util.Log().Error("Failed to refresh credential for policy %q, please login your Microsoft account again.", client.Policy.Name)
+		return ErrInvalidRefreshToken
+	}
+
+	credential, err := client.ObtainToken(ctx, WithRefreshToken(client.Credential.RefreshToken))
+	if err != nil {
+		return err
+	}
+
+	// 更新有效期为绝对时间戳
+	expires := credential.ExpiresIn - 60
+	credential.ExpiresIn = time.Now().Add(time.Duration(expires) * time.Second).Unix()
+	client.Credential = credential
+
+	// 更新存储策略的 RefreshToken
+	client.Policy.UpdateAccessKeyAndClearCache(credential.RefreshToken)
+
+	// 更新缓存
+	cache.Set("onedrive_"+client.ClientID, *credential, int(expires))
+
+	return nil
+}
+
+func (client *Client) AccessToken() string {
+	return client.Credential.AccessToken
+}
+
+// UpdateCredential 更新凭证，并检查有效期
+func (client *Client) fetchCredentialFromMaster(ctx context.Context) error {
+	res, err := client.ClusterController.GetPolicyOauthToken(client.Policy.MasterID, client.Policy.ID)
+	if err != nil {
+		return err
+	}
+
+	client.Credential = &Credential{AccessToken: res}
+	return nil
+}

pkg/filesystem/driver/onedrive/options.go

@@ -0,0 +1,59 @@
+package onedrive
+
+import "time"
+
+// Option 发送请求的额外设置
+type Option interface {
+	apply(*options)
+}
+
+type options struct {
+	redirect          string
+	code              string
+	refreshToken      string
+	conflictBehavior  string
+	expires           time.Time
+	useDriverResource bool
+}
+
+type optionFunc func(*options)
+
+// WithCode 设置接口Code
+func WithCode(t string) Option {
+	return optionFunc(func(o *options) {
+		o.code = t
+	})
+}
+
+// WithRefreshToken 设置接口RefreshToken
+func WithRefreshToken(t string) Option {
+	return optionFunc(func(o *options) {
+		o.refreshToken = t
+	})
+}
+
+// WithConflictBehavior 设置文件重名后的处理方式
+func WithConflictBehavior(t string) Option {
+	return optionFunc(func(o *options) {
+		o.conflictBehavior = t
+	})
+}
+
+// WithConflictBehavior 设置文件重名后的处理方式
+func WithDriverResource(t bool) Option {
+	return optionFunc(func(o *options) {
+		o.useDriverResource = t
+	})
+}
+
+func (f optionFunc) apply(o *options) {
+	f(o)
+}
+
+func newDefaultOption() *options {
+	return &options{
+		conflictBehavior:  "fail",
+		useDriverResource: true,
+		expires:           time.Now().UTC().Add(time.Duration(1) * time.Hour),
+	}
+}

pkg/filesystem/driver/onedrive/types.go

@@ -0,0 +1,140 @@
+package onedrive
+
+import (
+	"encoding/gob"
+	"net/url"
+)
+
+// RespError 接口返回错误
+type RespError struct {
+	APIError APIError `json:"error"`
+}
+
+// APIError 接口返回的错误内容
+type APIError struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+// UploadSessionResponse 分片上传会话
+type UploadSessionResponse struct {
+	DataContext        string   `json:"@odata.context"`
+	ExpirationDateTime string   `json:"expirationDateTime"`
+	NextExpectedRanges []string `json:"nextExpectedRanges"`
+	UploadURL          string   `json:"uploadUrl"`
+}
+
+// FileInfo 文件元信息
+type FileInfo struct {
+	Name            string          `json:"name"`
+	Size            uint64          `json:"size"`
+	Image           imageInfo       `json:"image"`
+	ParentReference parentReference `json:"parentReference"`
+	DownloadURL     string          `json:"@microsoft.graph.downloadUrl"`
+	File            *file           `json:"file"`
+	Folder          *folder         `json:"folder"`
+}
+
+type file struct {
+	MimeType string `json:"mimeType"`
+}
+
+type folder struct {
+	ChildCount int `json:"childCount"`
+}
+
+type imageInfo struct {
+	Height int `json:"height"`
+	Width  int `json:"width"`
+}
+
+type parentReference struct {
+	Path string `json:"path"`
+	Name string `json:"name"`
+	ID   string `json:"id"`
+}
+
+// UploadResult 上传结果
+type UploadResult struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	Size uint64 `json:"size"`
+}
+
+// BatchRequests 批量操作请求
+type BatchRequests struct {
+	Requests []BatchRequest `json:"requests"`
+}
+
+// BatchRequest 批量操作单个请求
+type BatchRequest struct {
+	ID      string            `json:"id"`
+	Method  string            `json:"method"`
+	URL     string            `json:"url"`
+	Body    interface{}       `json:"body,omitempty"`
+	Headers map[string]string `json:"headers,omitempty"`
+}
+
+// BatchResponses 批量操作响应
+type BatchResponses struct {
+	Responses []BatchResponse `json:"responses"`
+}
+
+// BatchResponse 批量操作单个响应
+type BatchResponse struct {
+	ID     string `json:"id"`
+	Status int    `json:"status"`
+}
+
+// ThumbResponse 获取缩略图的响应
+type ThumbResponse struct {
+	Value []map[string]interface{} `json:"value"`
+	URL   string                   `json:"url"`
+}
+
+// ListResponse 列取子项目响应
+type ListResponse struct {
+	Value   []FileInfo `json:"value"`
+	Context string     `json:"@odata.context"`
+}
+
+// oauthEndpoint OAuth接口地址
+type oauthEndpoint struct {
+	token     url.URL
+	authorize url.URL
+}
+
+// Credential 获取token时返回的凭证
+type Credential struct {
+	TokenType    string `json:"token_type"`
+	ExpiresIn    int64  `json:"expires_in"`
+	Scope        string `json:"scope"`
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	UserID       string `json:"user_id"`
+}
+
+// OAuthError OAuth相关接口的错误响应
+type OAuthError struct {
+	ErrorType        string `json:"error"`
+	ErrorDescription string `json:"error_description"`
+	CorrelationID    string `json:"correlation_id"`
+}
+
+// Site SharePoint 站点信息
+type Site struct {
+	Description string `json:"description"`
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	DisplayName string `json:"displayName"`
+	WebUrl      string `json:"webUrl"`
+}
+
+func init() {
+	gob.Register(Credential{})
+}
+
+// Error 实现error接口
+func (err RespError) Error() string {
+	return err.APIError.Message
+}