feat: add stop functionality for decompress tasks and improve UI for task management (#12582)

lan-yonghui · web-flow · commit e57dc1240ba3 · 2026-04-28T07:31:40.000Z
diff --git a/agent/app/api/v2/file.go b/agent/app/api/v2/file.go
@@ -292,6 +292,26 @@ func (b *BaseApi) DeCompressFile(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags File
+// @Summary Stop decompress task
+// @Accept json
+// @Param request body request.FileDeCompressStopReq true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /files/decompress/stop [post]
+func (b *BaseApi) StopDeCompressFile(c *gin.Context) {
+	var req request.FileDeCompressStopReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := fileService.StopDeCompress(req.TaskID); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags File
 // @Summary Load file content
 // @Accept json
diff --git a/agent/app/dto/request/file.go b/agent/app/dto/request/file.go
@@ -90,6 +90,11 @@ type FileDeCompress struct {
 	Type   string `json:"type"  validate:"required"`
 	Path   string `json:"path" validate:"required"`
 	Secret string `json:"secret"`
+	TaskID string `json:"taskID"`
+}
+
+type FileDeCompressStopReq struct {
+	TaskID string `json:"taskID" validate:"required"`
 }
 
 type FileEdit struct {
diff --git a/agent/app/service/app.go b/agent/app/service/app.go
@@ -896,7 +896,7 @@ func getAppFromRepo(downloadPath string) error {
 		return err
 	}
 
-	if err := fileOp.Decompress(packagePath, global.Dir.ResourceDir, files.SdkZip, ""); err != nil {
+	if err := fileOp.Decompress(context.Background(), packagePath, global.Dir.ResourceDir, files.SdkZip, ""); err != nil {
 		return err
 	}
 	defer func() {
diff --git a/agent/app/service/app_utils.go b/agent/app/service/app_utils.go
@@ -1034,7 +1034,7 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App
 		}
 		return
 	}
-	if err = fileOp.Decompress(filePath, appResourceDir, files.SdkTarGz, ""); err != nil {
+	if err = fileOp.Decompress(context.Background(), filePath, appResourceDir, files.SdkTarGz, ""); err != nil {
 		if logger == nil {
 			global.LOG.Errorf("decompress app[%s] error %v", app.Name, err)
 		} else {
diff --git a/agent/app/service/backup_mysql.go b/agent/app/service/backup_mysql.go
@@ -1,6 +1,7 @@
 package service
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path"
@@ -263,7 +264,7 @@ func loadSqlFile(file string) (string, error) {
 			_ = os.RemoveAll(dstDir)
 			return "", err
 		}
-		if err := archiver.Extract(file, dstDir, ""); err != nil {
+		if err := archiver.Extract(context.Background(), file, dstDir, ""); err != nil {
 			_ = os.RemoveAll(dstDir)
 			return "", err
 		}
diff --git a/agent/app/service/file.go b/agent/app/service/file.go
@@ -40,6 +40,7 @@ import (
 	"golang.org/x/text/transform"
 
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
 	terminalai "github.com/1Panel-dev/1Panel/agent/utils/terminal/ai"
@@ -59,6 +60,7 @@ type IFileService interface {
 	Compress(c request.FileCompress) error
 	StopCompress(taskID string) error
 	DeCompress(c request.FileDeCompress) error
+	StopDeCompress(taskID string) error
 	GetContent(op request.FileContentReq) (response.FileInfo, error)
 	GetPreviewContent(op request.FileContentReq) (response.FileInfo, error)
 	SaveContent(edit request.FileEdit) error
@@ -89,7 +91,7 @@ const (
 	fileRemarkEncodedMaxLen = 256
 )
 
-func NewIFileService() IFileService {
+func NewIFileService() FileService {
 	return &FileService{}
 }
 
@@ -472,6 +474,16 @@ func preflightCompressTool(compressType files.CompressType) error {
 	}
 }
 
+func preflightDecompressTool(decompressType files.CompressType) error {
+	switch decompressType {
+	case files.Tar, files.Zip, files.TarGz, files.Rar, files.X7z:
+		_, err := files.NewExtractShellArchiver(decompressType)
+		return err
+	default:
+		return nil
+	}
+}
+
 func (f *FileService) StopCompress(taskID string) error {
 	if cancel, ok := global.TaskCtxMap[taskID]; ok {
 		cancel()
@@ -480,12 +492,62 @@ func (f *FileService) StopCompress(taskID string) error {
 	return buserr.New("TaskNotFound")
 }
 
+func (f *FileService) StopDeCompress(taskID string) error {
+	if cancel, ok := global.TaskCtxMap[taskID]; ok {
+		cancel()
+		return nil
+	}
+	return buserr.New("TaskNotFound")
+}
+
 func (f *FileService) DeCompress(c request.FileDeCompress) error {
 	fo := files.NewFileOp()
 	if c.Type == "tar" && len(c.Secret) != 0 {
 		c.Type = "tar.gz"
 	}
-	return fo.Decompress(c.Path, c.Dst, files.CompressType(c.Type), c.Secret)
+	if err := preflightDecompressTool(files.CompressType(c.Type)); err != nil {
+		return err
+	}
+	taskItem, err := task.NewTask(c.Path, task.TaskExec, task.TaskScopeTask, c.TaskID, 1)
+	if err != nil {
+		return err
+	}
+	go func() {
+		taskItem.AddSubTask(c.Path, func(t *task.Task) error {
+			t.LogStart(c.Path)
+			dstExisted := fo.Stat(c.Dst)
+			parentDir := filepath.Dir(c.Dst)
+			if !fo.Stat(parentDir) {
+				if err := fo.CreateDir(parentDir, constant.DirPerm); err != nil {
+					return err
+				}
+			}
+			tempDst, err := os.MkdirTemp(parentDir, ".decompress-*")
+			if err != nil {
+				return err
+			}
+			success := false
+			defer func() {
+				_ = os.RemoveAll(tempDst)
+				if !success && !dstExisted {
+					_ = os.RemoveAll(c.Dst)
+				}
+			}()
+			if err := fo.Decompress(t.TaskCtx, c.Path, tempDst, files.CompressType(c.Type), c.Secret); err != nil {
+				return err
+			}
+			if err := fo.CreateDir(c.Dst, constant.DirPerm); err != nil {
+				return err
+			}
+			if err := cmd.NewCommandMgr(cmd.WithContext(t.TaskCtx)).RunBashCf("cp -rfp '%s'/. '%s'", tempDst, c.Dst); err != nil {
+				return err
+			}
+			success = true
+			return nil
+		}, nil)
+		_ = taskItem.Execute()
+	}()
+	return nil
 }
 
 func (f *FileService) GetContent(op request.FileContentReq) (response.FileInfo, error) {
diff --git a/agent/router/ro_file.go b/agent/router/ro_file.go
@@ -25,6 +25,7 @@ func (f *FileRouter) InitRouter(Router *gin.RouterGroup) {
 		fileRouter.POST("/compress", baseApi.CompressFile)
 		fileRouter.POST("/compress/stop", baseApi.StopCompressFile)
 		fileRouter.POST("/decompress", baseApi.DeCompressFile)
+		fileRouter.POST("/decompress/stop", baseApi.StopDeCompressFile)
 		fileRouter.POST("/content", baseApi.GetContent)
 		fileRouter.POST("/preview", baseApi.PreviewContent)
 		fileRouter.POST("/save", baseApi.SaveContent)
diff --git a/agent/utils/files/archiver.go b/agent/utils/files/archiver.go
@@ -8,7 +8,7 @@ import (
 )
 
 type ShellArchiver interface {
-	Extract(filePath, dstDir string, secret string) error
+	Extract(ctx context.Context, filePath, dstDir string, secret string) error
 	Compress(ctx context.Context, sourcePaths []string, dstFile string, secret string) error
 }
 
diff --git a/agent/utils/files/file_op.go b/agent/utils/files/file_op.go
@@ -910,13 +910,13 @@ func decodeGBK(input string) (string, error) {
 	return decoded, nil
 }
 
-func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType) error {
+func (f FileOp) decompressWithSDK(ctx context.Context, srcFile string, dst string, cType CompressType) error {
 	format := getFormat(cType)
 	if cType == Gz {
-		if err := f.tryDecompressTarGz(srcFile, dst, format); err == nil {
+		if err := f.tryDecompressTarGz(ctx, srcFile, dst, format); err == nil {
 			return nil
 		}
-		return f.DecompressGzFile(srcFile, dst)
+		return f.DecompressGzFile(ctx, srcFile, dst)
 	}
 
 	type dirEntry struct {
@@ -976,7 +976,7 @@ func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType
 		return err
 	}
 	defer input.Close()
-	if err := format.Extract(context.Background(), input, nil, handler); err != nil {
+	if err := format.Extract(ctx, input, nil, handler); err != nil {
 		return err
 	}
 	for i := len(dirs) - 1; i >= 0; i-- {
@@ -985,21 +985,21 @@ func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType
 	return nil
 }
 
-func (f FileOp) Decompress(srcFile string, dst string, cType CompressType, secret string) error {
+func (f FileOp) Decompress(ctx context.Context, srcFile string, dst string, cType CompressType, secret string) error {
 	if cType == Tar || cType == Zip || cType == TarGz || cType == Rar || cType == X7z {
 		shellArchiver, err := NewExtractShellArchiver(cType)
 		if !f.Stat(dst) {
 			_ = f.CreateDir(dst, 0755)
 		}
 		if err == nil {
-			if err = shellArchiver.Extract(srcFile, dst, secret); err == nil {
+			if err = shellArchiver.Extract(ctx, srcFile, dst, secret); err == nil {
 				return nil
 			}
 			if cType == TarGz {
 				if strings.Contains(err.Error(), "bad decrypt") {
 					return buserr.New("ErrBadDecrypt")
 				}
-				if err := shellArchiver.Extract(srcFile, dst, "-"); strings.Contains(err.Error(), "bad decrypt") {
+				if err := shellArchiver.Extract(ctx, srcFile, dst, "-"); strings.Contains(err.Error(), "bad decrypt") {
 					return buserr.New("ErrBadDecrypt")
 				}
 			}
@@ -1009,7 +1009,7 @@ func (f FileOp) Decompress(srcFile string, dst string, cType CompressType, secre
 			}
 		}
 	}
-	return f.decompressWithSDK(srcFile, dst, cType)
+	return f.decompressWithSDK(ctx, srcFile, dst, cType)
 }
 
 func ZipFile(ctx context.Context, files []archiver.File, dst afero.File, progress func(current, total int, message string)) error {
@@ -1088,7 +1088,7 @@ func (r *contextReader) Read(p []byte) (int, error) {
 	}
 }
 
-func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.CompressedArchive) error {
+func (f FileOp) tryDecompressTarGz(ctx context.Context, srcFile string, dst string, format archiver.CompressedArchive) error {
 	input, err := f.Fs.Open(srcFile)
 	if err != nil {
 		return err
@@ -1139,7 +1139,7 @@ func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.C
 		return nil
 	}
 
-	if err := format.Extract(context.Background(), input, nil, handler); err != nil {
+	if err := format.Extract(ctx, input, nil, handler); err != nil {
 		return err
 	}
 	if !extracted {
@@ -1151,7 +1151,7 @@ func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.C
 	return nil
 }
 
-func (f FileOp) DecompressGzFile(srcFile, dst string) error {
+func (f FileOp) DecompressGzFile(ctx context.Context, srcFile, dst string) error {
 	var archiveModTime time.Time
 	if st, err := f.Fs.Stat(srcFile); err == nil {
 		archiveModTime = st.ModTime()
@@ -1163,7 +1163,7 @@ func (f FileOp) DecompressGzFile(srcFile, dst string) error {
 	}
 	defer in.Close()
 
-	gr, err := gzip.NewReader(in)
+	gr, err := gzip.NewReader(&contextReader{ctx: ctx, r: in})
 	if err != nil {
 		return fmt.Errorf("gzip reader creation failed: %w", err)
 	}
diff --git a/agent/utils/files/rar.go b/agent/utils/files/rar.go
@@ -19,11 +19,11 @@ func NewRarArchiver() ShellArchiver {
 	return &RarArchiver{}
 }
 
-func (z RarArchiver) Extract(filePath, dstDir string, _ string) error {
+func (z RarArchiver) Extract(ctx context.Context, filePath, dstDir string, _ string) error {
 	if err := checkCmdAvailability("unrar"); err != nil {
 		return err
 	}
-	return cmd.RunDefaultBashCf("unrar x -y -o+ %q %q", filePath, dstDir)
+	return cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashCf("unrar x -y -o+ %q %q", filePath, dstDir)
 }
 
 func (z RarArchiver) Compress(ctx context.Context, sourcePaths []string, dstFile string, _ string) (err error) {
diff --git a/agent/utils/files/tar.go b/agent/utils/files/tar.go
@@ -18,8 +18,8 @@ func NewTarArchiver(compressType CompressType) ShellArchiver {
 	}
 }
 
-func (t TarArchiver) Extract(FilePath string, dstDir string, secret string) error {
-	return cmd.RunDefaultBashCf("%s %s \"%s\" -C \"%s\"", t.Cmd, t.getOptionStr("extract"), FilePath, dstDir)
+func (t TarArchiver) Extract(ctx context.Context, FilePath string, dstDir string, secret string) error {
+	return cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashCf("%s %s \"%s\" -C \"%s\"", t.Cmd, t.getOptionStr("extract"), FilePath, dstDir)
 }
 
 func (t TarArchiver) Compress(ctx context.Context, sourcePaths []string, dstFile string, secret string) error {
diff --git a/agent/utils/files/tar_gz.go b/agent/utils/files/tar_gz.go
@@ -21,7 +21,7 @@ func NewTarGzArchiver() ShellArchiver {
 	return &TarGzArchiver{}
 }
 
-func (t TarGzArchiver) Extract(filePath, dstDir string, secret string) error {
+func (t TarGzArchiver) Extract(ctx context.Context, filePath, dstDir string, secret string) error {
 	if err := os.MkdirAll(dstDir, 0755); err != nil {
 		return fmt.Errorf("failed to create destination dir: %w", err)
 	}
@@ -35,7 +35,7 @@ func (t TarGzArchiver) Extract(filePath, dstDir string, secret string) error {
 		commands = fmt.Sprintf("tar -zxvf '%s' -C '%s' > /dev/null 2>&1", filePath, dstDir)
 		global.LOG.Debug(commands)
 	}
-	if err = cmd.RunDefaultBashC(commands); err != nil {
+	if err = cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashC(commands); err != nil {
 		return err
 	}
 	return nil
diff --git a/agent/utils/files/x7z.go b/agent/utils/files/x7z.go
@@ -19,11 +19,11 @@ func NewX7zArchiver() ShellArchiver {
 	return &X7zArchiver{}
 }
 
-func (z X7zArchiver) Extract(filePath, dstDir string, _ string) error {
+func (z X7zArchiver) Extract(ctx context.Context, filePath, dstDir string, _ string) error {
 	if err := checkCmdAvailability("7z"); err != nil {
 		return err
 	}
-	return cmd.RunDefaultBashCf("7z x -y -o%q %q", dstDir, filePath)
+	return cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashCf("7z x -y -o%q %q", dstDir, filePath)
 }
 
 func (z X7zArchiver) Compress(ctx context.Context, sourcePaths []string, dstFile string, _ string) (err error) {
diff --git a/agent/utils/files/zip.go b/agent/utils/files/zip.go
@@ -20,11 +20,11 @@ func NewZipArchiver() ShellArchiver {
 	return &ZipArchiver{}
 }
 
-func (z ZipArchiver) Extract(filePath, dstDir string, secret string) error {
+func (z ZipArchiver) Extract(ctx context.Context, filePath, dstDir string, secret string) error {
 	if err := checkCmdAvailability("unzip"); err != nil {
 		return err
 	}
-	return cmd.RunDefaultBashCf("unzip -qo %s -d %s", filePath, dstDir)
+	return cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashCf("unzip -qo %s -d %s", filePath, dstDir)
 }
 
 func (z ZipArchiver) Compress(ctx context.Context, sourcePaths []string, dstFile string, _ string) error {
diff --git a/frontend/src/api/interface/file.ts b/frontend/src/api/interface/file.ts
@@ -149,6 +149,11 @@ export namespace File {
         dst: string;
         type: string;
         secret: string;
+        taskID?: string;
+    }
+
+    export interface FileDeCompressStopReq {
+        taskID: string;
     }
 
     export interface FileEdit {
diff --git a/frontend/src/api/modules/files.ts b/frontend/src/api/modules/files.ts
@@ -57,8 +57,15 @@ export const stopCompressFile = (taskID: string) => {
     return http.post('files/compress/stop', { taskID } as File.FileCompressStopReq);
 };
 
-export const deCompressFile = (form: File.FileDeCompress) => {
-    return http.post<File.File>('files/decompress', form, TimeoutEnum.T_10M);
+export const deCompressFile = (form: File.FileDeCompress, config?: AxiosRequestConfig) => {
+    return http.service.post<File.File>('files/decompress', form, {
+        timeout: TimeoutEnum.T_10M,
+        ...config,
+    });
+};
+
+export const stopDeCompressFile = (taskID: string) => {
+    return http.post('files/decompress/stop', { taskID } as File.FileDeCompressStopReq);
 };
 
 export const getFileContent = (params: File.ReqFile) => {
diff --git a/frontend/src/views/host/file-management/decompress/index.vue b/frontend/src/views/host/file-management/decompress/index.vue
diff --git a/frontend/src/views/host/file-management/index.vue b/frontend/src/views/host/file-management/index.vue

Original file line number	Diff line number	Diff line change
`@@ -896,7 +896,7 @@ func getAppFromRepo(downloadPath string) error {`
`896`	`896`	`return err`
`897`	`897`	`}`
`898`	`898`
`899`		`- if err := fileOp.Decompress(packagePath, global.Dir.ResourceDir, files.SdkZip, ""); err != nil {`
	`899`	`+ if err := fileOp.Decompress(context.Background(), packagePath, global.Dir.ResourceDir, files.SdkZip, ""); err != nil {`
`900`	`900`	`return err`
`901`	`901`	`}`
`902`	`902`	`defer func() {`
Original file line number	Diff line number	Diff line change
`@@ -1034,7 +1034,7 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App`
`1034`	`1034`	`}`
`1035`	`1035`	`return`
`1036`	`1036`	`}`
`1037`		`- if err = fileOp.Decompress(filePath, appResourceDir, files.SdkTarGz, ""); err != nil {`
	`1037`	`+ if err = fileOp.Decompress(context.Background(), filePath, appResourceDir, files.SdkTarGz, ""); err != nil {`
`1038`	`1038`	`if logger == nil {`
`1039`	`1039`	`global.LOG.Errorf("decompress app[%s] error %v", app.Name, err)`
`1040`	`1040`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import (`
`8`	`8`	`)`
`9`	`9`
`10`	`10`	`type ShellArchiver interface {`
`11`		`- Extract(filePath, dstDir string, secret string) error`
	`11`	`+ Extract(ctx context.Context, filePath, dstDir string, secret string) error`
`12`	`12`	`Compress(ctx context.Context, sourcePaths []string, dstFile string, secret string) error`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -910,13 +910,13 @@ func decodeGBK(input string) (string, error) {`
`910`	`910`	`return decoded, nil`
`911`	`911`	`}`
`912`	`912`
`913`		`-func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType) error {`
	`913`	`+func (f FileOp) decompressWithSDK(ctx context.Context, srcFile string, dst string, cType CompressType) error {`
`914`	`914`	`format := getFormat(cType)`
`915`	`915`	`if cType == Gz {`
`916`		`- if err := f.tryDecompressTarGz(srcFile, dst, format); err == nil {`
	`916`	`+ if err := f.tryDecompressTarGz(ctx, srcFile, dst, format); err == nil {`
`917`	`917`	`return nil`
`918`	`918`	`}`
`919`		`- return f.DecompressGzFile(srcFile, dst)`
	`919`	`+ return f.DecompressGzFile(ctx, srcFile, dst)`
`920`	`920`	`}`
`921`	`921`
`922`	`922`	`type dirEntry struct {`
`@@ -976,7 +976,7 @@ func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType`
`976`	`976`	`return err`
`977`	`977`	`}`
`978`	`978`	`defer input.Close()`
`979`		`- if err := format.Extract(context.Background(), input, nil, handler); err != nil {`
	`979`	`+ if err := format.Extract(ctx, input, nil, handler); err != nil {`
`980`	`980`	`return err`
`981`	`981`	`}`
`982`	`982`	`for i := len(dirs) - 1; i >= 0; i-- {`
`@@ -985,21 +985,21 @@ func (f FileOp) decompressWithSDK(srcFile string, dst string, cType CompressType`
`985`	`985`	`return nil`
`986`	`986`	`}`
`987`	`987`
`988`		`-func (f FileOp) Decompress(srcFile string, dst string, cType CompressType, secret string) error {`
	`988`	`+func (f FileOp) Decompress(ctx context.Context, srcFile string, dst string, cType CompressType, secret string) error {`
`989`	`989`	`if cType == Tar \|\| cType == Zip \|\| cType == TarGz \|\| cType == Rar \|\| cType == X7z {`
`990`	`990`	`shellArchiver, err := NewExtractShellArchiver(cType)`
`991`	`991`	`if !f.Stat(dst) {`
`992`	`992`	`_ = f.CreateDir(dst, 0755)`
`993`	`993`	`}`
`994`	`994`	`if err == nil {`
`995`		`- if err = shellArchiver.Extract(srcFile, dst, secret); err == nil {`
	`995`	`+ if err = shellArchiver.Extract(ctx, srcFile, dst, secret); err == nil {`
`996`	`996`	`return nil`
`997`	`997`	`}`
`998`	`998`	`if cType == TarGz {`
`999`	`999`	`if strings.Contains(err.Error(), "bad decrypt") {`
`1000`	`1000`	`return buserr.New("ErrBadDecrypt")`
`1001`	`1001`	`}`
`1002`		`- if err := shellArchiver.Extract(srcFile, dst, "-"); strings.Contains(err.Error(), "bad decrypt") {`
	`1002`	`+ if err := shellArchiver.Extract(ctx, srcFile, dst, "-"); strings.Contains(err.Error(), "bad decrypt") {`
`1003`	`1003`	`return buserr.New("ErrBadDecrypt")`
`1004`	`1004`	`}`
`1005`	`1005`	`}`
`@@ -1009,7 +1009,7 @@ func (f FileOp) Decompress(srcFile string, dst string, cType CompressType, secre`
`1009`	`1009`	`}`
`1010`	`1010`	`}`
`1011`	`1011`	`}`
`1012`		`- return f.decompressWithSDK(srcFile, dst, cType)`
	`1012`	`+ return f.decompressWithSDK(ctx, srcFile, dst, cType)`
`1013`	`1013`	`}`
`1014`	`1014`
`1015`	`1015`	`func ZipFile(ctx context.Context, files []archiver.File, dst afero.File, progress func(current, total int, message string)) error {`
`@@ -1088,7 +1088,7 @@ func (r *contextReader) Read(p []byte) (int, error) {`
`1088`	`1088`	`}`
`1089`	`1089`	`}`
`1090`	`1090`
`1091`		`-func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.CompressedArchive) error {`
	`1091`	`+func (f FileOp) tryDecompressTarGz(ctx context.Context, srcFile string, dst string, format archiver.CompressedArchive) error {`
`1092`	`1092`	`input, err := f.Fs.Open(srcFile)`
`1093`	`1093`	`if err != nil {`
`1094`	`1094`	`return err`
`@@ -1139,7 +1139,7 @@ func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.C`
`1139`	`1139`	`return nil`
`1140`	`1140`	`}`
`1141`	`1141`
`1142`		`- if err := format.Extract(context.Background(), input, nil, handler); err != nil {`
	`1142`	`+ if err := format.Extract(ctx, input, nil, handler); err != nil {`
`1143`	`1143`	`return err`
`1144`	`1144`	`}`
`1145`	`1145`	`if !extracted {`
`@@ -1151,7 +1151,7 @@ func (f FileOp) tryDecompressTarGz(srcFile string, dst string, format archiver.C`
`1151`	`1151`	`return nil`
`1152`	`1152`	`}`
`1153`	`1153`
`1154`		`-func (f FileOp) DecompressGzFile(srcFile, dst string) error {`
	`1154`	`+func (f FileOp) DecompressGzFile(ctx context.Context, srcFile, dst string) error {`
`1155`	`1155`	`var archiveModTime time.Time`
`1156`	`1156`	`if st, err := f.Fs.Stat(srcFile); err == nil {`
`1157`	`1157`	`archiveModTime = st.ModTime()`
`@@ -1163,7 +1163,7 @@ func (f FileOp) DecompressGzFile(srcFile, dst string) error {`
`1163`	`1163`	`}`
`1164`	`1164`	`defer in.Close()`
`1165`	`1165`
`1166`		`- gr, err := gzip.NewReader(in)`
	`1166`	`+ gr, err := gzip.NewReader(&contextReader{ctx: ctx, r: in})`
`1167`	`1167`	`if err != nil {`
`1168`	`1168`	`return fmt.Errorf("gzip reader creation failed: %w", err)`
`1169`	`1169`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,11 @@ func NewRarArchiver() ShellArchiver {`
`19`	`19`	`return &RarArchiver{}`
`20`	`20`	`}`
`21`	`21`
`22`		`-func (z RarArchiver) Extract(filePath, dstDir string, _ string) error {`
	`22`	`+func (z RarArchiver) Extract(ctx context.Context, filePath, dstDir string, _ string) error {`
`23`	`23`	`if err := checkCmdAvailability("unrar"); err != nil {`
`24`	`24`	`return err`
`25`	`25`	`}`
`26`		`- return cmd.RunDefaultBashCf("unrar x -y -o+ %q %q", filePath, dstDir)`
	`26`	`+ return cmd.NewCommandMgr(cmd.WithContext(ctx)).RunBashCf("unrar x -y -o+ %q %q", filePath, dstDir)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`func (z RarArchiver) Compress(ctx context.Context, sourcePaths []string, dstFile string, _ string) (err error) {`