play: fix cat/play working with directories

@TarantoolBot
Title: improve `tt cat` `tt play` working with directories

This commit improves the functionality of the `cat` and `play` commands
in the Tarantool CLI. It allows these commands to work recursively with
directories containing multiple files, enhancing their usability and
flexibility.

**Usage Example**:

```bash
tt cat -r /path/to/directory1 /path/to/directory2
tt play --recursive app:instance001 /path/to/directory1
```

Closes #TNTP-2367

Author: dmyger

CHANGELOG.md

@@ -9,10 +9,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 
+- In commands `tt cat|play <DIR>` added options `-r`/`--recursive` to
+  allow find WAL files inside nested subdirectories.
+
 ### Changed
 
 ### Fixed
 
+- `tt cat|play <DIR>` with directories handles only `.snap` or `.xlog` files.
+
 ## [2.9.1] - 2025-04-15
 
 The release includes minor fixes identified by Svacer and CVE linters.

cli/checkpoint/checkpoint.go

@@ -20,6 +20,7 @@ type Opts struct {
 	Format     string
 	Replica    []int
 	ShowSystem bool
+	Recursive  bool
 }
 
 // Cat print the contents of .snap/.xlog files.

cli/cmd/cat.go

@@ -26,18 +26,20 @@ var catFlags = checkpoint.Opts{
 	Format:     "yaml",
 	Replica:    nil,
 	ShowSystem: false,
+	Recursive:  false,
 }
 
 // NewCatCmd creates a new cat command.
 func NewCatCmd() *cobra.Command {
 	var catCmd = &cobra.Command{
-		Use:   "cat <FILE>...",
+		Use:   "cat <FILE|DIR>...",
 		Short: "Print into stdout the contents of .snap/.xlog FILE(s)",
 		Run:   RunModuleFunc(internalCatModule),
 		Example: "tt cat /path/to/file.snap /path/to/file.xlog /path/to/dir/ " +
 			"--timestamp 2024-11-13T14:02:36.818700000+00:00\n" +
 			"  tt cat /path/to/file.snap /path/to/file.xlog /path/to/dir/ " +
-			"--timestamp=1731592956.818",
+			"--timestamp=1731592956.818\n" +
+			"  tt cat --recursive /path/to/dir1 /path/to/dir2",
 		Args: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errors.New("it is required to specify at least one .xlog/.snap file " +
@@ -61,13 +63,15 @@ func NewCatCmd() *cobra.Command {
 		"Filter the output by replica id. May be passed more than once")
 	catCmd.Flags().BoolVar(&catFlags.ShowSystem, "show-system", catFlags.ShowSystem,
 		"Show the contents of system spaces")
+	catCmd.Flags().BoolVarP(&catFlags.Recursive, "recursive", "r", catFlags.Recursive,
+		"Process WAL files in directories recursively")
 
 	return catCmd
 }
 
 // internalCatModule is a default cat module.
 func internalCatModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
-	walFiles, err := util.CollectWALFiles(args)
+	walFiles, err := util.CollectWalFiles(args, catFlags.Recursive)
 	if err != nil {
 		return util.InternalError(
 			"Internal error: could not collect WAL files: %s",

cli/cmd/play.go

@@ -27,6 +27,7 @@ var playFlags = checkpoint.Opts{
 	Space:      nil,
 	Replica:    nil,
 	ShowSystem: false,
+	Recursive:  false,
 }
 
 var (
@@ -48,13 +49,14 @@ var (
 // NewPlayCmd creates a new play command.
 func NewPlayCmd() *cobra.Command {
 	var playCmd = &cobra.Command{
-		Use:   "play (<URI> | <APP_NAME> | <APP_NAME:INSTANCE_NAME>) <FILE>...",
+		Use:   "play (<URI> | <APP_NAME> | <APP_NAME:INSTANCE_NAME>) <FILE|DIR>...",
 		Short: "Play the contents of .snap/.xlog FILE(s) to another Tarantool instance",
 		Run:   RunModuleFunc(internalPlayModule),
 		Example: "tt play localhost:3013 /path/to/file.snap /path/to/file.xlog " +
 			"/path/to/dir/ --timestamp 2024-11-13T14:02:36.818700000+00:00\n" +
 			"  tt play app:instance001 /path/to/file.snap /path/to/file.xlog " +
-			"/path/to/dir/ --timestamp=1731592956.818",
+			"/path/to/dir/ --timestamp=1731592956.818\n" +
+			"  tt play --recursive app:instance001 /path/to/dir1 /path/to/dir2",
 		Args: playValidateArgs,
 	}
 
@@ -80,6 +82,8 @@ func NewPlayCmd() *cobra.Command {
 		"Filter the output by replica id. May be passed more than once")
 	playCmd.Flags().BoolVar(&playFlags.ShowSystem, "show-system", playFlags.ShowSystem,
 		"Show the contents of system spaces")
+	playCmd.Flags().BoolVarP(&playFlags.Recursive, "recursive", "r", playFlags.Recursive,
+		"Process WAL files in directories recursively")
 
 	return playCmd
 }
@@ -134,7 +138,7 @@ func internalPlayModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
 			version.GetVersion, args[0], err)
 	}
 
-	walFiles, err := util.CollectWALFiles(args[1:])
+	walFiles, err := util.CollectWalFiles(args[1:], playFlags.Recursive)
 	if err != nil {
 		return util.InternalError(
 			"Internal error: could not collect WAL files: %s",

cli/util/util.go

@@ -18,7 +18,6 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime/debug"
-	"slices"
 	"strconv"
 	"strings"
 	"text/template"
@@ -552,7 +551,6 @@ func RunCommandAndGetOutput(program string, args ...string) (string, error) {
 
 // ExtractTar extracts tar archive.
 func ExtractTar(tarName string) error {
-
 	path, err := filepath.Abs(tarName)
 	if err != nil {
 		return err
@@ -665,7 +663,6 @@ func ExecuteCommandStdin(program string, isVerbose bool, logFile *os.File, workD
 			cmd.Stdout = io.Discard
 			cmd.Stderr = io.Discard
 		}
-
 	}
 	if workDir == "" {
 		workDir, _ = os.Getwd()
@@ -998,44 +995,3 @@ func StringToTimestamp(input string) (string, error) {
 
 	return ts, nil
 }
-
-// CollectWALFiles globs files from args.
-func CollectWALFiles(paths []string) ([]string, error) {
-	collectedFiles := make([]string, 0)
-
-	sortSnapFilesFirst := func(left, right string) int {
-		reSnap := regexp.MustCompile(`\.snap`)
-		reXlog := regexp.MustCompile(`\.xlog`)
-		if reSnap.Match([]byte(left)) && reXlog.Match([]byte(right)) {
-			return -1
-		}
-		if reXlog.Match([]byte(left)) && reSnap.Match([]byte(right)) {
-			return 1
-		}
-		return 0
-	}
-
-	for _, path := range paths {
-		entry, err := os.Stat(path)
-		if err != nil {
-			return nil, err
-		}
-
-		if entry.IsDir() {
-			foundEntries, err := os.ReadDir(path)
-			if err != nil {
-				return nil, err
-			}
-			for _, entry := range foundEntries {
-				collectedFiles = append(collectedFiles, filepath.Join(path, entry.Name()))
-			}
-			slices.SortFunc(collectedFiles, sortSnapFilesFirst)
-
-			continue
-		}
-
-		collectedFiles = append(collectedFiles, path)
-	}
-
-	return collectedFiles, nil
-}

cli/util/util_test.go

@@ -798,64 +798,6 @@ func TestStringToTimestamp(t *testing.T) {
 	}
 }
 
-func TestCollectWALFiles(t *testing.T) {
-	srcDir := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "1.xlog"), []byte{}, 0644))
-	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "2.xlog"), []byte{}, 0644))
-	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "1.snap"), []byte{}, 0644))
-	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "2.snap"), []byte{}, 0644))
-	snap1 := fmt.Sprintf("%s/%s", srcDir, "1.snap")
-	snap2 := fmt.Sprintf("%s/%s", srcDir, "2.snap")
-	xlog1 := fmt.Sprintf("%s/%s", srcDir, "1.xlog")
-	xlog2 := fmt.Sprintf("%s/%s", srcDir, "2.xlog")
-
-	tests := []struct {
-		name           string
-		input          []string
-		output         []string
-		expectedErrMsg string
-	}{
-		{
-			name:   "no_file",
-			input:  []string{},
-			output: []string{},
-		},
-		{
-			name:           "incorrect_file",
-			input:          []string{"file"},
-			expectedErrMsg: "stat file: no such file or directory",
-		},
-		{
-			name:   "one_file",
-			input:  []string{xlog1},
-			output: []string{xlog1},
-		},
-		{
-			name:   "directory",
-			input:  []string{srcDir},
-			output: []string{snap1, snap2, xlog1, xlog2},
-		},
-		{
-			name:   "mix",
-			input:  []string{srcDir, "util_test.go"},
-			output: []string{snap1, snap2, xlog1, xlog2, "util_test.go"},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			result, err := CollectWALFiles(test.input)
-
-			if test.expectedErrMsg != "" {
-				assert.EqualError(t, err, test.expectedErrMsg)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, test.output, result)
-			}
-		})
-	}
-}
-
 func TestIsURL(t *testing.T) {
 	tests := []struct {
 		name     string

cli/util/wal.go

@@ -0,0 +1,142 @@
+package util
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/apex/log"
+)
+
+const (
+	snapSuffix = ".snap"
+	xlogSuffix = ".xlog"
+)
+
+// hasExt checks if the file name ends with the given suffix and is longer than the suffix itself.
+func hasExt(f string, s string) bool {
+	return strings.HasSuffix(f, s) && len(f) > len(s)
+}
+
+// isWAL checks if a file name has a .snap or .xlog extension.
+func isWal(f string) bool {
+	return hasExt(f, snapSuffix) || hasExt(f, xlogSuffix)
+}
+
+// sortWalFiles sorts a slice of file paths, ensuring .snap files come before .xlog files.
+// Files of the same type are sorted lexicographically.
+// The sorting happens in place.
+func sortWalFiles(files []string) {
+	slices.SortFunc(files, func(left, right string) int {
+		if hasExt(left, snapSuffix) && hasExt(right, xlogSuffix) {
+			return -1
+		}
+		if hasExt(left, xlogSuffix) && hasExt(right, snapSuffix) {
+			return 1
+		}
+		lDir, fName := filepath.Split(left)
+		rDir, rName := filepath.Split(right)
+		if lDir != rDir {
+			return strings.Compare(lDir, rDir)
+		}
+		return strings.Compare(fName, rName)
+	})
+}
+
+// collectWALsFromSinglePath is an internal helper to find WAL files starting from a single path.
+// It handles both files and directories, respecting the isRecursive flag for directories.
+// It returns absolute paths of found WAL files.
+func collectWALsFromSinglePath(path string, isRecursive bool) ([]string, error) {
+	collected := []string{}
+
+	info, err := os.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to stat path %q: %w", path, err)
+	}
+	path, err = filepath.Abs(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get absolute path for %q: %w", path, err)
+	}
+
+	if !info.IsDir() {
+		if isWal(info.Name()) {
+			collected = append(collected, path)
+		}
+		return collected, nil
+	}
+
+	// Handle the case where path is a directory.
+	if isRecursive {
+		err := filepath.WalkDir(path, func(p string, d fs.DirEntry, err error) error {
+			if err != nil {
+				log.Warnf("Skipping %q due to error during walk: %s", p, err)
+				if d != nil && d.IsDir() && errors.Is(err, fs.ErrPermission) {
+					// Skip directory if permission denied, but continue walking other parts.
+					return fs.SkipDir
+				}
+				return nil
+			}
+
+			if !d.IsDir() && isWal(d.Name()) {
+				collected = append(collected, p)
+			}
+			return nil
+		})
+		if err != nil {
+			log.Warnf("Error encountered during recursive walk of %q: %s", path, err)
+		}
+
+	} else {
+		dirEntries, readErr := os.ReadDir(path)
+		if readErr != nil {
+			log.Warnf("Failed to read directory %q: %s", path, readErr)
+			return collected, nil
+		}
+		for _, entry := range dirEntries {
+			if !entry.IsDir() && isWal(entry.Name()) {
+				collected = append(collected, filepath.Join(path, entry.Name()))
+			}
+		}
+	}
+
+	return collected, nil
+}
+
+// CollectWalFiles collects WAL (Write-Ahead Log) files based on the given
+// set of paths. It identifies files with ".snap" or ".xlog" extensions as WAL files.
+// For directory paths, it traverses them based on the isRecursive flag.
+// It skips directories or files it cannot access due to permissions, logging warnings.
+//
+// The function ensures that ".snap" files are sorted before ".xlog" files in the result,
+// and that the returned list contains unique absolute paths.
+//
+// Returns: A sorted, unique slice of strings containing the absolute paths of collected WAL files.
+func CollectWalFiles(paths []string, isRecursive bool) ([]string, error) {
+	allCollectedFiles := make([]string, 0)
+
+	for _, p := range paths {
+		filesFromPath, err := collectWALsFromSinglePath(p, isRecursive)
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				return nil, fmt.Errorf("required %q not found: %w", p, err)
+			}
+			log.Warnf("Error processing path %q: %v. Skipping this path.", p, err)
+			continue
+		}
+		if len(filesFromPath) == 0 {
+			log.Warnf("No WAL files found at %q", p)
+		} else {
+			allCollectedFiles = append(allCollectedFiles, filesFromPath...)
+		}
+	}
+
+	// Sort the aggregated list.
+	sortWalFiles(allCollectedFiles)
+
+	// For the case a file is included both as an individual file and as part of a directory.
+	return slices.Compact(allCollectedFiles), nil
+}