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

chore(fs): rename some param

refactor/fs
Noah Hsu 2022-06-21 16:37:51 +08:00
parent 9633af4e25
commit 55c4a925ba
4 changed files with 30 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
internal/fs/copy.go
View File

@ -21,47 +21,47 @@ var CopyTaskManager = task.NewTaskManager[uint64, struct{}](3, func(tid *uint64)
// Copy if in an account, call move method // Copy if in an account, call move method
// if not, add copy task // if not, add copy task
func Copy(ctx context.Context, account driver.Driver, srcPath, dstPath string) (bool, error) { func Copy(ctx context.Context, account driver.Driver, srcObjPath, dstDirPath string) (bool, error) {
srcAccount, srcActualPath, err := operations.GetAccountAndActualPath(srcPath) srcAccount, srcObjActualPath, err := operations.GetAccountAndActualPath(srcObjPath)
if err != nil { if err != nil {
return false, errors.WithMessage(err, "failed get src account") return false, errors.WithMessage(err, "failed get src account")
} }
dstAccount, dstActualPath, err := operations.GetAccountAndActualPath(dstPath) dstAccount, dstDirActualPath, err := operations.GetAccountAndActualPath(dstDirPath)
if err != nil { if err != nil {
return false, errors.WithMessage(err, "failed get dst account") return false, errors.WithMessage(err, "failed get dst account")
} }
// copy if in an account, just call driver.Copy // copy if in an account, just call driver.Copy
if srcAccount.GetAccount() == dstAccount.GetAccount() { if srcAccount.GetAccount() == dstAccount.GetAccount() {
return false, operations.Copy(ctx, account, srcActualPath, dstActualPath) return false, operations.Copy(ctx, account, srcObjActualPath, dstDirActualPath)
} }
// not in an account // not in an account
CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{ CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{
Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcActualPath, dstAccount.GetAccount().VirtualPath, dstActualPath), Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcObjActualPath, dstAccount.GetAccount().VirtualPath, dstDirActualPath),
Func: func(task *task.Task[uint64, struct{}]) error { Func: func(task *task.Task[uint64, struct{}]) error {
return CopyBetween2Accounts(task, srcAccount, dstAccount, srcActualPath, dstActualPath) return CopyBetween2Accounts(task, srcAccount, dstAccount, srcObjActualPath, dstDirActualPath)
}, },
})) }))
return true, nil return true, nil
} }
func CopyBetween2Accounts(t *task.Task[uint64, struct{}], srcAccount, dstAccount driver.Driver, srcPath, dstPath string) error { func CopyBetween2Accounts(t *task.Task[uint64, struct{}], srcAccount, dstAccount driver.Driver, srcObjPath, dstDirPath string) error {
t.SetStatus("getting src object") t.SetStatus("getting src object")
srcObj, err := operations.Get(t.Ctx, srcAccount, srcPath) srcObj, err := operations.Get(t.Ctx, srcAccount, srcObjPath)
if err != nil { if err != nil {
return errors.WithMessagef(err, "failed get src [%s] file", srcPath) return errors.WithMessagef(err, "failed get src [%s] file", srcObjPath)
} }
if srcObj.IsDir() { if srcObj.IsDir() {
t.SetStatus("src object is dir, listing objs") t.SetStatus("src object is dir, listing objs")
objs, err := operations.List(t.Ctx, srcAccount, srcPath) objs, err := operations.List(t.Ctx, srcAccount, srcObjPath)
if err != nil { if err != nil {
return errors.WithMessagef(err, "failed list src [%s] objs", srcPath) return errors.WithMessagef(err, "failed list src [%s] objs", srcObjPath)
} }
for _, obj := range objs { for _, obj := range objs {
if utils.IsCanceled(t.Ctx) { if utils.IsCanceled(t.Ctx) {
return nil return nil
} }
srcObjPath := stdpath.Join(srcPath, obj.GetName()) srcObjPath := stdpath.Join(srcObjPath, obj.GetName())
dstObjPath := stdpath.Join(dstPath, obj.GetName()) dstObjPath := stdpath.Join(dstDirPath, obj.GetName())
CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{ CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{
Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcObjPath, dstAccount.GetAccount().VirtualPath, dstObjPath), Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcObjPath, dstAccount.GetAccount().VirtualPath, dstObjPath),
Func: func(t *task.Task[uint64, struct{}]) error { Func: func(t *task.Task[uint64, struct{}]) error {
@ -71,27 +71,27 @@ func CopyBetween2Accounts(t *task.Task[uint64, struct{}], srcAccount, dstAccount
} }
} else { } else {
CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{ CopyTaskManager.Submit(task.WithCancelCtx(&task.Task[uint64, struct{}]{
Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcPath, dstAccount.GetAccount().VirtualPath, dstPath), Name: fmt.Sprintf("copy [%s](%s) to [%s](%s)", srcAccount.GetAccount().VirtualPath, srcObjPath, dstAccount.GetAccount().VirtualPath, dstDirPath),
Func: func(t *task.Task[uint64, struct{}]) error { Func: func(t *task.Task[uint64, struct{}]) error {
return CopyFileBetween2Accounts(t, srcAccount, dstAccount, srcPath, dstPath) return CopyFileBetween2Accounts(t, srcAccount, dstAccount, srcObjPath, dstDirPath)
}, },
})) }))
} }
return nil return nil
} }
func CopyFileBetween2Accounts(tsk *task.Task[uint64, struct{}], srcAccount, dstAccount driver.Driver, srcPath, dstPath string) error { func CopyFileBetween2Accounts(tsk *task.Task[uint64, struct{}], srcAccount, dstAccount driver.Driver, srcFilePath, dstDirPath string) error {
srcFile, err := operations.Get(tsk.Ctx, srcAccount, srcPath) srcFile, err := operations.Get(tsk.Ctx, srcAccount, srcFilePath)
if err != nil { if err != nil {
return errors.WithMessagef(err, "failed get src [%s] file", srcPath) return errors.WithMessagef(err, "failed get src [%s] file", srcFilePath)
} }
link, err := operations.Link(tsk.Ctx, srcAccount, srcPath, model.LinkArgs{}) link, err := operations.Link(tsk.Ctx, srcAccount, srcFilePath, model.LinkArgs{})
if err != nil { if err != nil {
return errors.WithMessagef(err, "failed get [%s] link", srcPath) return errors.WithMessagef(err, "failed get [%s] link", srcFilePath)
} }
stream, err := getFileStreamFromLink(srcFile, link) stream, err := getFileStreamFromLink(srcFile, link)
if err != nil { if err != nil {
return errors.WithMessagef(err, "failed get [%s] stream", srcPath) return errors.WithMessagef(err, "failed get [%s] stream", srcFilePath)
} }
return operations.Put(tsk.Ctx, dstAccount, dstPath, stream, tsk.SetProgress) return operations.Put(tsk.Ctx, dstAccount, dstDirPath, stream, tsk.SetProgress)
} }

4
internal/fs/put.go
View File

@ -16,8 +16,8 @@ var UploadTaskManager = task.NewTaskManager[uint64, struct{}](3, func(tid *uint6
}) })
// Put add as a put task // Put add as a put task
func Put(ctx context.Context, account driver.Driver, dstDir string, file model.FileStreamer) error { func Put(ctx context.Context, account driver.Driver, dstDirPath string, file model.FileStreamer) error {
account, actualParentPath, err := operations.GetAccountAndActualPath(dstDir) account, actualParentPath, err := operations.GetAccountAndActualPath(dstDirPath)
if account.Config().NoUpload { if account.Config().NoUpload {
return errors.WithStack(ErrUploadNotSupported) return errors.WithStack(ErrUploadNotSupported)
} }

4
internal/fs/write.go
View File

@ -15,12 +15,12 @@ func MakeDir(ctx context.Context, account driver.Driver, path string) error {
return operations.MakeDir(ctx, account, actualPath) return operations.MakeDir(ctx, account, actualPath)
} }
func Move(ctx context.Context, account driver.Driver, srcPath, dstPath string) error { func Move(ctx context.Context, account driver.Driver, srcPath, dstDirPath string) error {
srcAccount, srcActualPath, err := operations.GetAccountAndActualPath(srcPath) srcAccount, srcActualPath, err := operations.GetAccountAndActualPath(srcPath)
if err != nil { if err != nil {
return errors.WithMessage(err, "failed get src account") return errors.WithMessage(err, "failed get src account")
} }
dstAccount, dstActualPath, err := operations.GetAccountAndActualPath(dstPath) dstAccount, dstActualPath, err := operations.GetAccountAndActualPath(dstDirPath)
if err != nil { if err != nil {
return errors.WithMessage(err, "failed get dst account") return errors.WithMessage(err, "failed get dst account")
} }

8
internal/operations/fs.go
View File

@ -145,12 +145,12 @@ func MakeDir(ctx context.Context, account driver.Driver, path string) error {
} }
} }
func Move(ctx context.Context, account driver.Driver, srcPath, dstPath string) error { func Move(ctx context.Context, account driver.Driver, srcPath, dstDirPath string) error {
srcObj, err := Get(ctx, account, srcPath) srcObj, err := Get(ctx, account, srcPath)
if err != nil { if err != nil {
return errors.WithMessage(err, "failed to get src object") return errors.WithMessage(err, "failed to get src object")
} }
dstDir, err := Get(ctx, account, stdpath.Dir(dstPath)) dstDir, err := Get(ctx, account, dstDirPath)
if err != nil { if err != nil {
return errors.WithMessage(err, "failed to get dst dir") return errors.WithMessage(err, "failed to get dst dir")
} }
@ -166,12 +166,12 @@ func Rename(ctx context.Context, account driver.Driver, srcPath, dstName string)
} }
// Copy Just copy file[s] in an account // Copy Just copy file[s] in an account
func Copy(ctx context.Context, account driver.Driver, srcPath, dstPath string) error { func Copy(ctx context.Context, account driver.Driver, srcPath, dstDirPath string) error {
srcObj, err := Get(ctx, account, srcPath) srcObj, err := Get(ctx, account, srcPath)
if err != nil { if err != nil {
return errors.WithMessage(err, "failed to get src object") return errors.WithMessage(err, "failed to get src object")
} }
dstDir, err := Get(ctx, account, stdpath.Dir(dstPath)) dstDir, err := Get(ctx, account, dstDirPath)
return account.Copy(ctx, srcObj, dstDir) return account.Copy(ctx, srcObj, dstDir)
} }