feat(caller): support install ffmpeg for linux(arm64,x86_64)

Author: ihexon

.golangci.yaml

@@ -5,6 +5,7 @@ run:
 linters:
   default: all
   disable:
+    - noinlineerr
     - canonicalheader
     - containedctx
     - contextcheck

cmd/main.go

@@ -41,7 +41,8 @@ func main() {
 		Action: start,
 	}
 
-	if err := app.Run(context.Background(), os.Args); err != nil {
+	err := app.Run(context.Background(), os.Args)
+	if err != nil {
 		logrus.Fatal(err)
 	}
 }
@@ -59,8 +60,10 @@ func start(ctx context.Context, command *cli.Command) error {
 
 	g.Go(func() error {
 		errChan := make(chan error, 1)
+
 		go func() {
 			logrus.Infof("Start ssh server on %q", command.String(listen))
+
 			errChan <- ssh.ListenAndServe(command.String(listen), nil, handler.WithMiddleware(
 				ffmpeg.Run,
 				ffmpeg.Install,

pkg/archiver/tarxz.go

@@ -26,35 +26,37 @@ func Unarchive(tarball, dst string) error {
 	}
 	defer archiveFile.Close()
 
-	format, input, identifyErr := archives.Identify(context.Background(), tarball, archiveFile)
-	if identifyErr != nil {
-		return fmt.Errorf("identify format: %w", identifyErr)
+	format, input, err := archives.Identify(context.Background(), tarball, archiveFile)
+	if err != nil {
+		return fmt.Errorf("identify format: %w", err)
 	}
 
 	extractor, ok := format.(archives.Extractor)
 	if !ok {
 		return fmt.Errorf("unsupported format for extraction")
 	}
 
-	if dirErr := createDirWithPermissions(dst, dirPermissions); dirErr != nil {
-		return fmt.Errorf("creating destination directory: %w", dirErr)
+	if err := createDirWithPermissions(dst, dirPermissions); err != nil {
+		return fmt.Errorf("creating destination directory: %w", err)
 	}
 
 	handler := func(ctx context.Context, f archives.FileInfo) error {
 		return handleFile(f, dst)
 	}
 
-	if extractErr := extractor.Extract(context.Background(), input, handler); extractErr != nil {
-		return fmt.Errorf("extracting files: %w", extractErr)
+	if err := extractor.Extract(context.Background(), input, handler); err != nil {
+		return fmt.Errorf("extracting files: %w", err)
 	}
 
 	return nil
 }
 
 func createDirWithPermissions(path string, mode os.FileMode) error {
-	if err := os.MkdirAll(path, mode); err != nil {
+	err := os.MkdirAll(path, mode)
+	if err != nil {
 		return fmt.Errorf("mkdir: %w", err)
 	}
+
 	return nil
 }
 
@@ -68,6 +70,7 @@ func securePath(basePath, relativePath string) (string, error) {
 	if !strings.HasPrefix(filepath.Clean(dstPath)+string(os.PathSeparator), filepath.Clean(basePath)+string(os.PathSeparator)) {
 		return "", fmt.Errorf("illegal file path: %s", dstPath)
 	}
+
 	return dstPath, nil
 }
 
@@ -80,16 +83,20 @@ func handleFile(f archives.FileInfo, dst string) error {
 
 	// Ensure the parent directory exists
 	parentDir := filepath.Dir(dstPath)
-	if dirErr := createDirWithPermissions(parentDir, dirPermissions); dirErr != nil {
+
+	dirErr := createDirWithPermissions(parentDir, dirPermissions)
+	if dirErr != nil {
 		return dirErr
 	}
 
 	// Handle directories
 	if f.IsDir() {
 		// Create the directory with permissions from the archive
-		if dirErr := createDirWithPermissions(dstPath, f.Mode()); dirErr != nil {
+		dirErr := createDirWithPermissions(dstPath, f.Mode())
+		if dirErr != nil {
 			return fmt.Errorf("creating directory: %w", dirErr)
 		}
+
 		return nil
 	}
 
@@ -99,7 +106,9 @@ func handleFile(f archives.FileInfo, dst string) error {
 			logrus.Warnf("Ignoring symlink: %s -> %s", f.NameInArchive, f.LinkTarget)
 			return nil
 		}
-		if linkErr := os.Symlink(f.LinkTarget, dstPath); linkErr != nil {
+
+		linkErr := os.Symlink(f.LinkTarget, dstPath)
+		if linkErr != nil {
 			return fmt.Errorf("creating symlink: %w", linkErr)
 		}
 	}
@@ -112,12 +121,15 @@ func handleFile(f archives.FileInfo, dst string) error {
 
 	// If parent directory is read-only, temporarily make it writable
 	if originalMode.Mode().Perm()&0o200 == 0 {
-		if chmodErr := os.Chmod(parentDir, originalMode.Mode()|0o200); chmodErr != nil {
+		chmodErr := os.Chmod(parentDir, originalMode.Mode()|0o200)
+		if chmodErr != nil {
 			return fmt.Errorf("chmod parent directory: %w", chmodErr)
 		}
+
 		defer func() {
 			// Restore the original permissions after writing
-			if chmodErr := os.Chmod(parentDir, originalMode.Mode()); chmodErr != nil {
+			chmodErr := os.Chmod(parentDir, originalMode.Mode())
+			if chmodErr != nil {
 				logrus.Warnf("Failed to restore original permissions for %s: %v", parentDir, chmodErr)
 			}
 		}()

pkg/define/whitelist.go

@@ -13,5 +13,6 @@ func IsWhitelisted(command string) bool {
 			return true
 		}
 	}
+
 	return false
 }

pkg/exec/exec_test.go

@@ -28,21 +28,25 @@ const MyJSONData = `
 
 func TestExecPathCover(t *testing.T) {
 	p := filepath.Join("/tmp", "mount-point.json")
+
 	jsonFile, err := os.Create(p)
 	if err != nil {
 		logrus.Fatalf("Failed to create json file: %v", err)
 	}
+
 	_, _ = jsonFile.WriteString(MyJSONData)
 	MyJSONFile = p
 
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		t.Fatalf("Failed to get user home dir: %v", err)
 	}
+
 	path, err := ContainerPath2HostPath("test")
 	if err != nil {
 		t.Fatalf("ContainerPath2HostPath failed: %v", err)
 	}
+
 	if path != "test" {
 		t.Error("ContainerPath2HostPath failed")
 	}
@@ -51,6 +55,7 @@ func TestExecPathCover(t *testing.T) {
 	if err != nil {
 		t.Errorf("ContainerPath2HostPath failed: %v", err)
 	}
+
 	if path != filepath.Join(homeDir, ooStorage) {
 		t.Error("ContainerPath2HostPath failed")
 	}
@@ -59,6 +64,7 @@ func TestExecPathCover(t *testing.T) {
 	if err != nil {
 		t.Errorf("ContainerPath2HostPath failed: %v", err)
 	}
+
 	if path != filepath.Join(homeDir, ooHomePrefix, ooSessions) {
 		t.Error("ContainerPath2HostPath failed")
 	}
@@ -67,6 +73,7 @@ func TestExecPathCover(t *testing.T) {
 	if err != nil {
 		t.Errorf("ContainerPath2HostPath failed: %v", err)
 	}
+
 	if path != "/Users/localuser/Desktop" {
 		t.Error("ContainerPath2HostPath failed")
 	}
@@ -75,17 +82,20 @@ func TestExecPathCover(t *testing.T) {
 	if err != nil {
 		t.Errorf("ContainerPath2HostPath failed: %v", err)
 	}
+
 	if path != "/Users/localuser/Downloads" {
 		t.Error("ContainerPath2HostPath failed")
 	}
 }
 
 func TestExecPathCover2(t *testing.T) {
 	p := filepath.Join("/tmp", "mount-point.json")
+
 	jsonFile, err := os.Create(p)
 	if err != nil {
 		logrus.Fatalf("Failed to create json file: %v", err)
 	}
+
 	_, _ = jsonFile.WriteString(MyJSONData)
 	MyJSONFile = p
 
@@ -101,5 +111,6 @@ func TestExecPathCover2(t *testing.T) {
 	if err != nil {
 		return
 	}
+
 	t.Log(sanitizers)
 }

pkg/exec/sanitizers.go

@@ -41,10 +41,12 @@ func loadJSON(path string) (*DataStruct, error) {
 	defer file.Close()
 
 	var data DataStruct
+
 	decoder := json.NewDecoder(file)
 	if err = decoder.Decode(&data); err != nil {
 		return nil, err
 	}
+
 	return &data, nil
 }
 
@@ -75,6 +77,7 @@ func ContainerPath2HostPath(arg string) (string, error) {
 		path := filepath.Join(homeDir, ooHomePrefix, ooSessions)
 		newArg := strings.Replace(arg, oomolSessions, path, 1)
 		logrus.Warnf("%q --> %q", arg, newArg)
+
 		return newArg, nil
 	}
 
@@ -83,10 +86,12 @@ func ContainerPath2HostPath(arg string) (string, error) {
 		path := filepath.Join(homeDir, ooStorage)
 		newArg := strings.Replace(arg, oomolStorage, path, 1)
 		logrus.Warnf("%q --> %q", arg, newArg)
+
 		return newArg, nil
 	}
 
 	logrus.Infof("Load MountPoint json file: %q", MyJSONFile)
+
 	jsonData, err := loadJSON(MyJSONFile)
 	if err != nil {
 		return "", fmt.Errorf("failed to load json file: %v", err)
@@ -99,21 +104,26 @@ func ContainerPath2HostPath(arg string) (string, error) {
 			if strings.Contains(arg, mountPoint.ContainerPath) {
 				newArg := strings.Replace(arg, mountPoint.ContainerPath, mountPoint.HostPath, 1)
 				logrus.Warnf("%q --> %q", arg, newArg)
+
 				return newArg, nil
 			}
 		}
 	}
+
 	return arg, nil
 }
 
 func DoArgsSanitizers(args []string) ([]string, error) {
 	newArgs := make([]string, 0)
+
 	for _, arg := range args {
 		singleArg, err := ContainerPath2HostPath(arg)
 		if err != nil {
 			return nil, fmt.Errorf("failed to convert container path to host path: %v", err)
 		}
+
 		newArgs = append(newArgs, singleArg)
 	}
+
 	return newArgs, nil
 }

pkg/handler/ffmpeg/handler.go

@@ -18,7 +18,9 @@ func Run(next ssh.Handler) ssh.Handler {
 		targetBin := s.Command()[0]
 		if targetBin == define.FFPROBEBin || targetBin == define.FFMPEGBin {
 			logrus.Infof("run middleware: %q\n", RunFFMPEGStage)
+
 			stubber := ffmpeg.NewVersion6(s)
+
 			args, err := exec.DoArgsSanitizers(s.Command()[1:])
 			if err != nil {
 				slog.Fatalf(s, "DoArgsSanitizers error: %v\r\n", err)
@@ -51,7 +53,8 @@ func Install(next ssh.Handler) ssh.Handler {
 			stubber := ffmpeg.NewVersion6(s)
 
 			// we first test the ffmpeg call be called, if ffmpeg can be called without error, just return
-			if err := stubber.Test(s.Context()); err == nil {
+			err := stubber.Test(s.Context())
+			if err == nil {
 				slog.Infof(s, "ffmpeg package installed before\r\n")
 				return
 			}
@@ -60,31 +63,37 @@ func Install(next ssh.Handler) ssh.Handler {
 				slog.Fatalf(s, "Download ffmpeg error: %v\r\n", err)
 				return
 			}
+
 			slog.Infof(s, "Download ffmpeg success\r\n")
 
 			if err := stubber.Unpack(s.Context()); err != nil {
 				slog.Fatalf(s, "Unpack ffmpeg error: %v\r\n", err)
 				return
 			}
+
 			slog.Infof(s, "Unpack ffmpeg success\r\n")
 
 			if err := stubber.Setup(s.Context()); err != nil {
 				slog.Fatalf(s, "Setup ffmpeg error: %v", err)
 				return
 			}
+
 			slog.Infof(s, "Setup ffmpeg success\r\n")
 
 			if err := stubber.Test(s.Context()); err != nil {
 				slog.Fatalf(s, "Test ffmpeg package error: %v\r\n", err)
 				return
 			}
+
 			slog.Infof(s, "Test ffmpeg package success\r\n")
 
 			if err := stubber.CleanUp(s.Context()); err != nil {
 				slog.Fatalf(s, "Clean up ffmpeg error: %v\r\n", err)
 				return
 			}
+
 			slog.Infof(s, "Clean up ffmpeg success\r\n")
+
 			return
 		}
 

pkg/handler/handler.go

@@ -22,7 +22,9 @@ func WithMiddleware(mw ...Middleware) ssh.Option {
 		for _, m := range mw {
 			h = m(h)
 		}
+
 		s.Handler = h
+
 		return nil
 	}
 }
@@ -33,6 +35,7 @@ func ValidateCmdline(next ssh.Handler) ssh.Handler {
 		// Parameter parsing follows the openssh standard implementation
 		// https://stackoverflow.com/questions/53465980/how-to-keep-parameter-with-spaces-when-running-remote-script-file-with-ssh
 		logrus.Infof("Validate string: %q\n", s.Command())
+
 		str := s.Command()
 		if len(str) == 0 {
 			slog.Fatalf(s, "Empty command, Support commands: %q \r\n", define.Whitelist)
@@ -55,6 +58,7 @@ func ShowVersion(next ssh.Handler) ssh.Handler {
 			slog.Printf(s, "%s\r\n", define.CurrentVersion)
 			return
 		}
+
 		next(s)
 	}
 }

pkg/logger/log.go

@@ -41,6 +41,7 @@ func SetupLogger() error {
 		DisableColors:   false,
 		TimestampFormat: "2006-01-02 15:04:05.000",
 	})
+
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return fmt.Errorf("failed to get user home directory: %w", err)
@@ -55,17 +56,20 @@ func SetupLogger() error {
 	logDir := filepath.Dir(logFile)
 
 	logrus.Infof("Try to make logDir dir: %q", logDir)
+
 	if err = os.MkdirAll(logDir, 0755); err != nil {
 		return fmt.Errorf("failed to create log directory %q: %v", logDir, err)
 	}
 
 	logrus.Infof("Try to open log file: %q", logFile)
+
 	fd, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
 	if err != nil {
 		return fmt.Errorf("failed to open log file %q: %v", logFile, err)
 	}
 
 	logrus.SetOutput(fd)
 	logrus.SetLevel(logrus.InfoLevel)
+
 	return nil
 }