github
/
alist
mirror of https://github.com/Xhofe/alist
1
0
Fork 0
Code Issues Releases Wiki Activity

style: shorten name `operations` to `op`

pull/1604/head
Noah Hsu 2022-08-31 21:01:15 +08:00
parent 9ec6d5be7a
commit 7ac1d14eeb
35 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/lang.go
View File

@ -12,7 +12,7 @@ import (
_ "github.com/alist-org/alist/v3/drivers"
"github.com/alist-org/alist/v3/internal/bootstrap/data"
"github.com/alist-org/alist/v3/internal/conf"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/spf13/cobra"
)
@ -37,7 +37,7 @@ func convert(s string) string {
func generateDriversJson() {
drivers := make(Drivers)
drivers["drivers"] = make(KV[interface{}])
driverInfoMap := operations.GetDriverInfoMap()
driverInfoMap := op.GetDriverInfoMap()
for k, v := range driverInfoMap {
drivers["drivers"][k] = convert(k)
items := make(KV[interface{}])

2
drivers/aliyundrive/driver.go
View File

@ -48,7 +48,7 @@ func (d *AliDrive) Init(ctx context.Context, storage model.Storage) error {
return err
}
// TODO login / refresh token
//operations.MustSaveDriverStorage(d)
//op.MustSaveDriverStorage(d)
err = d.refreshToken()
if err != nil {
return err

4
drivers/aliyundrive/meta.go
View File

@ -2,7 +2,7 @@ package local
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -23,5 +23,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

4
drivers/aliyundrive/util.go
View File

@ -6,7 +6,7 @@ import (
"net/http"
"github.com/alist-org/alist/v3/drivers/base"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/go-resty/resty/v2"
)
@ -30,7 +30,7 @@ func (d *AliDrive) refreshToken() error {
return fmt.Errorf("failed to refresh token: %s", e.Message)
}
d.RefreshToken, d.AccessToken = resp.RefreshToken, resp.AccessToken
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return nil
}

4
drivers/local/driver.go
View File

@ -18,7 +18,7 @@ import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/errs"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/alist-org/alist/v3/server/common"
"github.com/disintegration/imaging"
@ -49,7 +49,7 @@ func (d *Local) Init(ctx context.Context, storage model.Storage) error {
}
}
}
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return err
}

4
drivers/local/meta.go
View File

@ -2,7 +2,7 @@ package local
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -23,5 +23,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

4
drivers/onedrive/meta.go
View File

@ -2,7 +2,7 @@ package onedrive
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -27,5 +27,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

4
drivers/onedrive/util.go
View File

@ -14,7 +14,7 @@ import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/errs"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/go-resty/resty/v2"
jsoniter "github.com/json-iterator/go"
@ -92,7 +92,7 @@ func (d *Onedrive) _refreshToken() error {
return errs.EmptyToken
}
d.RefreshToken, d.AccessToken = resp.RefreshToken, resp.AccessToken
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return nil
}

4
drivers/pikpak/meta.go
View File

@ -2,7 +2,7 @@ package local
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -22,5 +22,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

8
drivers/pikpak/util.go
View File

@ -5,7 +5,7 @@ import (
"net/http"
"github.com/alist-org/alist/v3/drivers/base"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/go-resty/resty/v2"
jsoniter "github.com/json-iterator/go"
)
@ -46,7 +46,7 @@ func (d *PikPak) refreshToken() error {
}).Post(url)
if err != nil {
d.Status = err.Error()
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return err
}
if e.ErrorCode != 0 {
@ -55,14 +55,14 @@ func (d *PikPak) refreshToken() error {
return d.login()
}
d.Status = e.Error
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return errors.New(e.Error)
}
data := res.Body()
d.Status = "work"
d.RefreshToken = jsoniter.Get(data, "refresh_token").ToString()
d.AccessToken = jsoniter.Get(data, "access_token").ToString()
operations.MustSaveDriverStorage(d)
op.MustSaveDriverStorage(d)
return nil
}

2
drivers/template/driver.go
View File

@ -29,7 +29,7 @@ func (d *Template) Init(ctx context.Context, storage model.Storage) error {
return err
}
// TODO login / refresh token
//operations.MustSaveDriverStorage(d)
//op.MustSaveDriverStorage(d)
return err
}

4
drivers/template/meta.go
View File

@ -2,7 +2,7 @@ package local
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -29,5 +29,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

4
drivers/virtual/meta.go
View File

@ -2,7 +2,7 @@ package virtual
import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
type Addition struct {
@ -26,5 +26,5 @@ func New() driver.Driver {
}
func init() {
operations.RegisterDriver(config, New)
op.RegisterDriver(config, New)
}

6
internal/aria2/add.go
View File

@ -7,7 +7,7 @@ import (
"github.com/alist-org/alist/v3/internal/conf"
"github.com/alist-org/alist/v3/internal/errs"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/task"
"github.com/google/uuid"
"github.com/pkg/errors"
@ -15,7 +15,7 @@ import (
func AddURI(ctx context.Context, uri string, dstDirPath string) error {
// check storage
storage, dstDirActualPath, err := operations.GetStorageAndActualPath(dstDirPath)
storage, dstDirActualPath, err := op.GetStorageAndActualPath(dstDirPath)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
@ -24,7 +24,7 @@ func AddURI(ctx context.Context, uri string, dstDirPath string) error {
return errors.WithStack(errs.UploadNotSupported)
}
// check path is valid
obj, err := operations.Get(ctx, storage, dstDirActualPath)
obj, err := op.Get(ctx, storage, dstDirActualPath)
if err != nil {
if !errs.IsObjectNotFound(err) {
return errors.WithMessage(err, "failed get object")

4
internal/aria2/aria2_test.go
View File

@ -10,7 +10,7 @@ import (
conf2 "github.com/alist-org/alist/v3/internal/conf"
"github.com/alist-org/alist/v3/internal/db"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/task"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
@ -39,7 +39,7 @@ func TestConnect(t *testing.T) {
func TestDown(t *testing.T) {
TestConnect(t)
err := operations.CreateStorage(context.Background(), model.Storage{
err := op.CreateStorage(context.Background(), model.Storage{
ID: 0,
MountPath: "/",
Index: 0,

6
internal/aria2/monitor.go
View File

@ -11,7 +11,7 @@ import (
"time"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/task"
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
@ -114,7 +114,7 @@ var TransferTaskManager = task.NewTaskManager(3, func(k *uint64) {
func (m *Monitor) Complete() error {
// check dstDir again
storage, dstDirActualPath, err := operations.GetStorageAndActualPath(m.dstDirPath)
storage, dstDirActualPath, err := op.GetStorageAndActualPath(m.dstDirPath)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
@ -158,7 +158,7 @@ func (m *Monitor) Complete() error {
ReadCloser: f,
Mimetype: mimetype,
}
return operations.Put(tsk.Ctx, storage, dstDirActualPath, stream, tsk.SetProgress)
return op.Put(tsk.Ctx, storage, dstDirActualPath, stream, tsk.SetProgress)
},
}))
}

4
internal/bootstrap/data/dev.go
View File

@ -7,12 +7,12 @@ import (
"github.com/alist-org/alist/v3/internal/db"
"github.com/alist-org/alist/v3/internal/message"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
log "github.com/sirupsen/logrus"
)
func initDevData() {
err := operations.CreateStorage(context.Background(), model.Storage{
err := op.CreateStorage(context.Background(), model.Storage{
MountPath: "/",
Index: 0,
Driver: "local",

4
internal/bootstrap/storage.go
View File

@ -6,7 +6,7 @@ import (
"github.com/alist-org/alist/v3/internal/conf"
"github.com/alist-org/alist/v3/internal/db"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
)
@ -17,7 +17,7 @@ func LoadStorages() {
}
go func(storages []model.Storage) {
for i := range storages {
err := operations.LoadStorage(context.Background(), storages[i])
err := op.LoadStorage(context.Background(), storages[i])
if err != nil {
utils.Log.Errorf("failed get enabled storages: %+v", err)
} else {

4
internal/db/storage.go
View File

@ -8,8 +8,8 @@ import (
)
// why don't need `cache` for storage?
// because all storage store in `operations.storagesMap`
// the most of the read operation is from `operations.storagesMap`
// because all storage store in `op.storagesMap`
// the most of the read operation is from `op.storagesMap`
// just for persistence in database
// CreateStorage just insert storage to database

18
internal/fs/copy.go
View File

@ -8,7 +8,7 @@ import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/task"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/pkg/errors"
@ -21,17 +21,17 @@ var CopyTaskManager = task.NewTaskManager(3, func(tid *uint64) {
// Copy if in the same storage, call move method
// if not, add copy task
func _copy(ctx context.Context, srcObjPath, dstDirPath string) (bool, error) {
srcStorage, srcObjActualPath, err := operations.GetStorageAndActualPath(srcObjPath)
srcStorage, srcObjActualPath, err := op.GetStorageAndActualPath(srcObjPath)
if err != nil {
return false, errors.WithMessage(err, "failed get src storage")
}
dstStorage, dstDirActualPath, err := operations.GetStorageAndActualPath(dstDirPath)
dstStorage, dstDirActualPath, err := op.GetStorageAndActualPath(dstDirPath)
if err != nil {
return false, errors.WithMessage(err, "failed get dst storage")
}
// copy if in the same storage, just call driver.Copy
if srcStorage.GetStorage() == dstStorage.GetStorage() {
return false, operations.Copy(ctx, srcStorage, srcObjActualPath, dstDirActualPath)
return false, op.Copy(ctx, srcStorage, srcObjActualPath, dstDirActualPath)
}
// not in the same storage
CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64]{
@ -45,13 +45,13 @@ func _copy(ctx context.Context, srcObjPath, dstDirPath string) (bool, error) {
func copyBetween2Storages(t *task.Task[uint64], srcStorage, dstStorage driver.Driver, srcObjPath, dstDirPath string) error {
t.SetStatus("getting src object")
srcObj, err := operations.Get(t.Ctx, srcStorage, srcObjPath)
srcObj, err := op.Get(t.Ctx, srcStorage, srcObjPath)
if err != nil {
return errors.WithMessagef(err, "failed get src [%s] file", srcObjPath)
}
if srcObj.IsDir() {
t.SetStatus("src object is dir, listing objs")
objs, err := operations.List(t.Ctx, srcStorage, srcObjPath, model.ListArgs{})
objs, err := op.List(t.Ctx, srcStorage, srcObjPath, model.ListArgs{})
if err != nil {
return errors.WithMessagef(err, "failed list src [%s] objs", srcObjPath)
}
@ -80,11 +80,11 @@ func copyBetween2Storages(t *task.Task[uint64], srcStorage, dstStorage driver.Dr
}
func copyFileBetween2Storages(tsk *task.Task[uint64], srcStorage, dstStorage driver.Driver, srcFilePath, dstDirPath string) error {
srcFile, err := operations.Get(tsk.Ctx, srcStorage, srcFilePath)
srcFile, err := op.Get(tsk.Ctx, srcStorage, srcFilePath)
if err != nil {
return errors.WithMessagef(err, "failed get src [%s] file", srcFilePath)
}
link, _, err := operations.Link(tsk.Ctx, srcStorage, srcFilePath, model.LinkArgs{})
link, _, err := op.Link(tsk.Ctx, srcStorage, srcFilePath, model.LinkArgs{})
if err != nil {
return errors.WithMessagef(err, "failed get [%s] link", srcFilePath)
}
@ -92,5 +92,5 @@ func copyFileBetween2Storages(tsk *task.Task[uint64], srcStorage, dstStorage dri
if err != nil {
return errors.WithMessagef(err, "failed get [%s] stream", srcFilePath)
}
return operations.Put(tsk.Ctx, dstStorage, dstDirPath, stream, tsk.SetProgress)
return op.Put(tsk.Ctx, dstStorage, dstDirPath, stream, tsk.SetProgress)
}

6
internal/fs/fs.go
View File

@ -5,13 +5,13 @@ import (
"github.com/alist-org/alist/v3/internal/driver"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
log "github.com/sirupsen/logrus"
)
// the param named path of functions in this package is a virtual path
// So, the purpose of this package is to convert virtual path to actual path
// then pass the actual path to the operations package
// then pass the actual path to the op package
func List(ctx context.Context, path string, refresh ...bool) ([]model.Obj, error) {
res, err := list(ctx, path, refresh...)
@ -97,7 +97,7 @@ func PutAsTask(dstDirPath string, file model.FileStreamer) error {
}
func GetStorage(path string) (driver.Driver, error) {
storageDriver, _, err := operations.GetStorageAndActualPath(path)
storageDriver, _, err := op.GetStorageAndActualPath(path)
if err != nil {
return nil, err
}

8
internal/fs/get.go
View File

@ -6,7 +6,7 @@ import (
"time"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/pkg/errors"
)
@ -15,14 +15,14 @@ func get(ctx context.Context, path string) (model.Obj, error) {
path = utils.StandardizePath(path)
// maybe a virtual file
if path != "/" {
virtualFiles := operations.GetStorageVirtualFilesByPath(stdpath.Dir(path))
virtualFiles := op.GetStorageVirtualFilesByPath(stdpath.Dir(path))
for _, f := range virtualFiles {
if f.GetName() == stdpath.Base(path) {
return f, nil
}
}
}
storage, actualPath, err := operations.GetStorageAndActualPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
if err != nil {
// if there are no storage prefix with path, maybe root folder
if path == "/" {
@ -35,5 +35,5 @@ func get(ctx context.Context, path string) (model.Obj, error) {
}
return nil, errors.WithMessage(err, "failed get storage")
}
return operations.Get(ctx, storage, actualPath)
return op.Get(ctx, storage, actualPath)
}

6
internal/fs/link.go
View File

@ -4,14 +4,14 @@ import (
"context"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/pkg/errors"
)
func link(ctx context.Context, path string, args model.LinkArgs) (*model.Link, model.Obj, error) {
storage, actualPath, err := operations.GetStorageAndActualPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
if err != nil {
return nil, nil, errors.WithMessage(err, "failed get storage")
}
return operations.Link(ctx, storage, actualPath, args)
return op.Link(ctx, storage, actualPath, args)
}

8
internal/fs/list.go
View File

@ -6,7 +6,7 @@ import (
"strings"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
@ -16,15 +16,15 @@ import (
func list(ctx context.Context, path string, refresh ...bool) ([]model.Obj, error) {
meta := ctx.Value("meta").(*model.Meta)
user := ctx.Value("user").(*model.User)
storage, actualPath, err := operations.GetStorageAndActualPath(path)
virtualFiles := operations.GetStorageVirtualFilesByPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
virtualFiles := op.GetStorageVirtualFilesByPath(path)
if err != nil {
if len(virtualFiles) != 0 {
return virtualFiles, nil
}
return nil, errors.WithMessage(err, "failed get storage")
}
objs, err := operations.List(ctx, storage, actualPath, model.ListArgs{
objs, err := op.List(ctx, storage, actualPath, model.ListArgs{
ReqPath: path,
}, refresh...)
if err != nil {

24
internal/fs/other.go
View File

@ -5,54 +5,54 @@ import (
"github.com/alist-org/alist/v3/internal/errs"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/pkg/errors"
)
func makeDir(ctx context.Context, path string) error {
storage, actualPath, err := operations.GetStorageAndActualPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
return operations.MakeDir(ctx, storage, actualPath)
return op.MakeDir(ctx, storage, actualPath)
}
func move(ctx context.Context, srcPath, dstDirPath string) error {
srcStorage, srcActualPath, err := operations.GetStorageAndActualPath(srcPath)
srcStorage, srcActualPath, err := op.GetStorageAndActualPath(srcPath)
if err != nil {
return errors.WithMessage(err, "failed get src storage")
}
dstStorage, dstDirActualPath, err := operations.GetStorageAndActualPath(dstDirPath)
dstStorage, dstDirActualPath, err := op.GetStorageAndActualPath(dstDirPath)
if err != nil {
return errors.WithMessage(err, "failed get dst storage")
}
if srcStorage.GetStorage() != dstStorage.GetStorage() {
return errors.WithStack(errs.MoveBetweenTwoStorages)
}
return operations.Move(ctx, srcStorage, srcActualPath, dstDirActualPath)
return op.Move(ctx, srcStorage, srcActualPath, dstDirActualPath)
}
func rename(ctx context.Context, srcPath, dstName string) error {
storage, srcActualPath, err := operations.GetStorageAndActualPath(srcPath)
storage, srcActualPath, err := op.GetStorageAndActualPath(srcPath)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
return operations.Rename(ctx, storage, srcActualPath, dstName)
return op.Rename(ctx, storage, srcActualPath, dstName)
}
func remove(ctx context.Context, path string) error {
storage, actualPath, err := operations.GetStorageAndActualPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
return operations.Remove(ctx, storage, actualPath)
return op.Remove(ctx, storage, actualPath)
}
func other(ctx context.Context, args model.FsOtherArgs) (interface{}, error) {
storage, actualPath, err := operations.GetStorageAndActualPath(args.Path)
storage, actualPath, err := op.GetStorageAndActualPath(args.Path)
if err != nil {
return nil, errors.WithMessage(err, "failed get storage")
}
args.Path = actualPath
return operations.Other(ctx, storage, args)
return op.Other(ctx, storage, args)
}

10
internal/fs/put.go
View File

@ -7,7 +7,7 @@ import (
"github.com/alist-org/alist/v3/internal/errs"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/task"
"github.com/alist-org/alist/v3/pkg/utils"
"github.com/pkg/errors"
@ -19,7 +19,7 @@ var UploadTaskManager = task.NewTaskManager(3, func(tid *uint64) {
// putAsTask add as a put task and return immediately
func putAsTask(dstDirPath string, file model.FileStreamer) error {
storage, dstDirActualPath, err := operations.GetStorageAndActualPath(dstDirPath)
storage, dstDirActualPath, err := op.GetStorageAndActualPath(dstDirPath)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
@ -36,7 +36,7 @@ func putAsTask(dstDirPath string, file model.FileStreamer) error {
UploadTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64]{
Name: fmt.Sprintf("upload %s to [%s](%s)", file.GetName(), storage.GetStorage().MountPath, dstDirActualPath),
Func: func(task *task.Task[uint64]) error {
return operations.Put(task.Ctx, storage, dstDirActualPath, file, nil)
return op.Put(task.Ctx, storage, dstDirActualPath, file, nil)
},
}))
return nil
@ -44,12 +44,12 @@ func putAsTask(dstDirPath string, file model.FileStreamer) error {
// putDirect put the file and return after finish
func putDirectly(ctx context.Context, dstDirPath string, file model.FileStreamer) error {
storage, dstDirActualPath, err := operations.GetStorageAndActualPath(dstDirPath)
storage, dstDirActualPath, err := op.GetStorageAndActualPath(dstDirPath)
if err != nil {
return errors.WithMessage(err, "failed get storage")
}
if storage.Config().NoUpload {
return errors.WithStack(errs.UploadNotSupported)
}
return operations.Put(ctx, storage, dstDirActualPath, file, nil)
return op.Put(ctx, storage, dstDirActualPath, file, nil)
}

6
internal/fs/util.go
View File

@ -9,16 +9,16 @@ import (
"strings"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/pkg/errors"
)
func ClearCache(path string) {
storage, actualPath, err := operations.GetStorageAndActualPath(path)
storage, actualPath, err := op.GetStorageAndActualPath(path)
if err != nil {
return
}
operations.ClearCache(storage, actualPath)
op.ClearCache(storage, actualPath)
}
func containsByName(files []model.Obj, file model.Obj) bool {

2
internal/operations/driver.go → internal/op/driver.go
View File

@ -1,4 +1,4 @@
package operations
package op
import (
"reflect"

6
internal/operations/driver_test.go → internal/op/driver_test.go
View File

@ -1,14 +1,14 @@
package operations_test
package op_test
import (
"testing"
_ "github.com/alist-org/alist/v3/drivers"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
)
func TestDriverItemsMap(t *testing.T) {
itemsMap := operations.GetDriverInfoMap()
itemsMap := op.GetDriverInfoMap()
if len(itemsMap) != 0 {
t.Logf("driverInfoMap: %v", itemsMap)
} else {

8
internal/operations/fs.go → internal/op/fs.go
View File

@ -1,4 +1,4 @@
package operations
package op
import (
"context"
@ -17,7 +17,7 @@ import (
log "github.com/sirupsen/logrus"
)
// In order to facilitate adding some other things before and after file operations
// In order to facilitate adding some other things before and after file op
var listCache = cache.NewMemCache(cache.WithShards[[]model.Obj](64))
var listG singleflight.Group[[]model.Obj]
@ -30,7 +30,7 @@ func ClearCache(storage driver.Driver, path string) {
// List files in storage, not contains virtual file
func List(ctx context.Context, storage driver.Driver, path string, args model.ListArgs, refresh ...bool) ([]model.Obj, error) {
path = utils.StandardizePath(path)
log.Debugf("operations.List %s", path)
log.Debugf("op.List %s", path)
dir, err := Get(ctx, storage, path)
if err != nil {
return nil, errors.WithMessage(err, "failed get dir")
@ -75,7 +75,7 @@ func isRoot(path, rootFolderPath string) bool {
// Get object from list of files
func Get(ctx context.Context, storage driver.Driver, path string) (model.Obj, error) {
path = utils.StandardizePath(path)
log.Debugf("operations.Get %s", path)
log.Debugf("op.Get %s", path)
if g, ok := storage.(driver.Getter); ok {
obj, err := g.Get(ctx, path)
if err == nil {

2
internal/operations/path.go → internal/op/path.go
View File

@ -1,4 +1,4 @@
package operations
package op
import (
stdpath "path"

2
internal/operations/storage.go → internal/op/storage.go
View File

@ -1,4 +1,4 @@
package operations
package op
import (
"context"

14
internal/operations/storage_test.go → internal/op/storage_test.go
View File

@ -1,4 +1,4 @@
package operations_test
package op_test
import (
"context"
@ -6,7 +6,7 @@ import (
"github.com/alist-org/alist/v3/internal/db"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/pkg/utils"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
@ -30,7 +30,7 @@ func TestCreateStorage(t *testing.T) {
{storage: model.Storage{Driver: "None", MountPath: "/none", Addition: `{"root_folder":"."}`}, isErr: true},
}
for _, storage := range storages {
err := operations.CreateStorage(context.Background(), storage.storage)
err := op.CreateStorage(context.Background(), storage.storage)
if err != nil {
if !storage.isErr {
t.Errorf("failed to create storage: %+v", err)
@ -43,7 +43,7 @@ func TestCreateStorage(t *testing.T) {
func TestGetStorageVirtualFilesByPath(t *testing.T) {
setupStorages(t)
virtualFiles := operations.GetStorageVirtualFilesByPath("/a")
virtualFiles := op.GetStorageVirtualFilesByPath("/a")
var names []string
for _, virtualFile := range virtualFiles {
names = append(names, virtualFile.GetName())
@ -58,11 +58,11 @@ func TestGetStorageVirtualFilesByPath(t *testing.T) {
func TestGetBalancedStorage(t *testing.T) {
setupStorages(t)
storage := operations.GetBalancedStorage("/a/d/e")
storage := op.GetBalancedStorage("/a/d/e")
if storage.GetStorage().MountPath != "/a/d/e" {
t.Errorf("expected: /a/d/e, got: %+v", storage.GetStorage().MountPath)
}
storage = operations.GetBalancedStorage("/a/d/e")
storage = op.GetBalancedStorage("/a/d/e")
if storage.GetStorage().MountPath != "/a/d/e.balance" {
t.Errorf("expected: /a/d/e.balance, got: %+v", storage.GetStorage().MountPath)
}
@ -77,7 +77,7 @@ func setupStorages(t *testing.T) {
{Driver: "local", MountPath: "/a/d/e.balance", Index: 4, Addition: `{"root_folder":"."}`},
}
for _, storage := range storages {
err := operations.CreateStorage(context.Background(), storage)
err := op.CreateStorage(context.Background(), storage)
if err != nil {
t.Fatalf("failed to create storage: %+v", err)
}

8
server/handles/driver.go
View File

@ -3,22 +3,22 @@ package handles
import (
"fmt"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/server/common"
"github.com/gin-gonic/gin"
)
func ListDriverInfo(c *gin.Context) {
common.SuccessResp(c, operations.GetDriverInfoMap())
common.SuccessResp(c, op.GetDriverInfoMap())
}
func ListDriverNames(c *gin.Context) {
common.SuccessResp(c, operations.GetDriverNames())
common.SuccessResp(c, op.GetDriverNames())
}
func GetDriverInfo(c *gin.Context) {
driverName := c.Query("driver")
infoMap := operations.GetDriverInfoMap()
infoMap := op.GetDriverInfoMap()
items, ok := infoMap[driverName]
if !ok {
common.ErrorStrResp(c, fmt.Sprintf("driver [%s] not found", driverName), 404)

12
server/handles/storage.go
View File

@ -5,7 +5,7 @@ import (
"github.com/alist-org/alist/v3/internal/db"
"github.com/alist-org/alist/v3/internal/model"
"github.com/alist-org/alist/v3/internal/operations"
"github.com/alist-org/alist/v3/internal/op"
"github.com/alist-org/alist/v3/server/common"
"github.com/gin-gonic/gin"
log "github.com/sirupsen/logrus"
@ -36,7 +36,7 @@ func CreateStorage(c *gin.Context) {
common.ErrorResp(c, err, 400)
return
}
if err := operations.CreateStorage(c, req); err != nil {
if err := op.CreateStorage(c, req); err != nil {
common.ErrorResp(c, err, 500, true)
} else {
common.SuccessResp(c)
@ -49,7 +49,7 @@ func UpdateStorage(c *gin.Context) {
common.ErrorResp(c, err, 400)
return
}
if err := operations.UpdateStorage(c, req); err != nil {
if err := op.UpdateStorage(c, req); err != nil {
common.ErrorResp(c, err, 500, true)
} else {
common.SuccessResp(c)
@ -63,7 +63,7 @@ func DeleteStorage(c *gin.Context) {
common.ErrorResp(c, err, 400)
return
}
if err := operations.DeleteStorageById(c, uint(id)); err != nil {
if err := op.DeleteStorageById(c, uint(id)); err != nil {
common.ErrorResp(c, err, 500, true)
return
}
@ -77,7 +77,7 @@ func DisableStorage(c *gin.Context) {
common.ErrorResp(c, err, 400)
return
}
if err := operations.DisableStorage(c, uint(id)); err != nil {
if err := op.DisableStorage(c, uint(id)); err != nil {
common.ErrorResp(c, err, 500, true)
return
}
@ -91,7 +91,7 @@ func EnableStorage(c *gin.Context) {
common.ErrorResp(c, err, 400)
return
}
if err := operations.EnableStorage(c, uint(id)); err != nil {
if err := op.EnableStorage(c, uint(id)); err != nil {
common.ErrorResp(c, err, 500, true)
return
}