SNOW-1905965: Add wildcard support in file ls (#606)

* SNOW-1905965: Add wildcard support in `file ls`

Added a feature that will make the following ls patterns possible:
* '*' matches any sequence of non-Separator characters
* '?' matches any single non-Separator character
* '[aml]' matches any single character within the brackets
* '[a-f]' matches any single character within the range specified in the brackets

* SNOW-1905965: Split path and pattern code paths

* SNOW-1905965: Add glob pattern support info to help

Author: sfc-gh-pkowalewski

services/localfile/client/client.go

@@ -917,6 +917,7 @@ func (*lsCmd) Usage() string {
 	return `ls [--long] [--directory] <path>:
   List the path given printing out each entry (N if it's a directory). Use --long to get ls -l style output.
   If the entry is a directory it will be suppressed from the output unless --directory is set (ls -d style).
+  The command supports glob patterns (*?[a-z]).
   NOTE: Only expands one level of a directory.
 `
 }

services/localfile/server/localfile.go

@@ -674,8 +674,12 @@ func (s *server) Copy(ctx context.Context, req *pb.CopyRequest) (_ *emptypb.Empt
 	return &emptypb.Empty{}, nil
 }
 
+// isGlobPattern checks if a path contains glob pattern characters.
+func isGlobPattern(path string) bool {
+	return strings.ContainsAny(path, "*?[")
+}
+
 func (s *server) listFor(entry string, ctx context.Context, consumer func(*pb.StatReply) error) error {
-	logger := logr.FromContextOrDiscard(ctx)
 	recorder := metrics.RecorderFromContextOrNoop(ctx)
 	if entry == "" {
 		recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "missing_entry"))
@@ -686,9 +690,49 @@ func (s *server) listFor(entry string, ctx context.Context, consumer func(*pb.St
 		return err
 	}
 
-	// We always send back the entry first.
-	logger.Info("ls", "filename", entry)
-	resp, err := osStat(entry, false)
+	if isGlobPattern(entry) {
+		return s.listGlob(entry, ctx, consumer)
+	}
+	return s.listPath(entry, ctx, consumer)
+}
+
+// listGlob lists files matching a glob pattern. Does not descend into directories.
+func (s *server) listGlob(pattern string, ctx context.Context, consumer func(*pb.StatReply) error) error {
+	logger := logr.FromContextOrDiscard(ctx)
+	recorder := metrics.RecorderFromContextOrNoop(ctx)
+
+	matches, err := filepath.Glob(pattern)
+	if err != nil {
+		recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "glob_err"))
+		return status.Errorf(codes.InvalidArgument, "invalid pattern: %v", err)
+	}
+	if len(matches) == 0 {
+		recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "no_matches_err"))
+		return status.Errorf(codes.NotFound, "no matches found for pattern %s", pattern)
+	}
+
+	for _, match := range matches {
+		logger.Info("ls", "glob-match", match)
+		resp, err := osStat(match, false)
+		if err != nil {
+			recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "stat_err"))
+			return err
+		}
+		if err := consumer(resp); err != nil {
+			recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "send_err"))
+			return status.Errorf(codes.Internal, "list: send error %v", err)
+		}
+	}
+	return nil
+}
+
+// listPath lists a specific path. If the path is a directory, its contents are listed (one level).
+func (s *server) listPath(path string, ctx context.Context, consumer func(*pb.StatReply) error) error {
+	logger := logr.FromContextOrDiscard(ctx)
+	recorder := metrics.RecorderFromContextOrNoop(ctx)
+
+	logger.Info("ls", "filename", path)
+	resp, err := osStat(path, false)
 	if err != nil {
 		recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "stat_err"))
 		return err
@@ -698,16 +742,15 @@ func (s *server) listFor(entry string, ctx context.Context, consumer func(*pb.St
 		return status.Errorf(codes.Internal, "list: send error %v", err)
 	}
 
-	// If it's directory we'll open it and go over its entries.
+	// If path is a directory, list its contents (one level only).
 	if fs.FileMode(resp.Mode).IsDir() {
-		entries, err := os.ReadDir(entry)
+		entries, err := os.ReadDir(path)
 		if err != nil {
 			recorder.CounterOrLog(ctx, localfileListFailureCounter, 1, attribute.String("reason", "read_dir_err"))
 			return status.Errorf(codes.Internal, "readdir: %v", err)
 		}
-		// Only do one level so iterate these and we're done.
 		for _, e := range entries {
-			name := filepath.Join(entry, e.Name())
+			name := filepath.Join(path, e.Name())
 			logger.Info("ls", "filename", name)
 			// Use lstat so that we don't return misleading directory contents from
 			// following symlinks.

services/localfile/server/localfile_test.go

@@ -1098,6 +1098,25 @@ func TestList(t *testing.T) {
 	symStat, err := osStat(symlink, true)
 	testutil.FatalOnErr("osStat", err, t)
 
+	// Create additional files for glob testing
+	globDir := t.TempDir()
+	logFile1, err := os.Create(filepath.Join(globDir, "app.log"))
+	testutil.FatalOnErr("os.Create", err, t)
+	logFile1.Close()
+	logFile2, err := os.Create(filepath.Join(globDir, "error.log"))
+	testutil.FatalOnErr("os.Create", err, t)
+	logFile2.Close()
+	txtFile, err := os.Create(filepath.Join(globDir, "readme.txt"))
+	testutil.FatalOnErr("os.Create", err, t)
+	txtFile.Close()
+
+	logFile1Stat, err := osStat(filepath.Join(globDir, "app.log"), true)
+	testutil.FatalOnErr("osStat", err, t)
+	logFile2Stat, err := osStat(filepath.Join(globDir, "error.log"), true)
+	testutil.FatalOnErr("osStat", err, t)
+	txtFileStat, err := osStat(filepath.Join(globDir, "readme.txt"), true)
+	testutil.FatalOnErr("osStat", err, t)
+
 	// Construct a directory with no perms. We should be able
 	// to stat this but then fail to readdir on it.
 	badDir := filepath.Join(t.TempDir(), "/foo")
@@ -1173,6 +1192,83 @@ func TestList(t *testing.T) {
 			},
 			wantErr: true,
 		},
+		{
+			name: "glob pattern matching log files",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "*.log"),
+			},
+			expected: []*pb.StatReply{
+				logFile1Stat,
+				logFile2Stat,
+			},
+		},
+		{
+			name: "glob pattern matching txt files",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "*.txt"),
+			},
+			expected: []*pb.StatReply{
+				txtFileStat,
+			},
+		},
+		{
+			name: "glob pattern with no matches",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "*.xyz"),
+			},
+			wantErr: true,
+		},
+		{
+			name: "glob pattern non-absolute path",
+			req: &pb.ListRequest{
+				Entry: "relative/*.log",
+			},
+			wantErr: true,
+		},
+		{
+			name: "glob pattern with directory traversal",
+			req: &pb.ListRequest{
+				Entry: "/tmp/../tmp/*.log",
+			},
+			wantErr: true,
+		},
+		{
+			name: "glob pattern matching all files",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "*"),
+			},
+			expected: []*pb.StatReply{
+				logFile1Stat,
+				logFile2Stat,
+				txtFileStat,
+			},
+		},
+		{
+			name: "glob pattern with question mark",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "???.log"),
+			},
+			expected: []*pb.StatReply{
+				logFile1Stat,
+			},
+		},
+		{
+			name: "glob pattern with bracket",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "*[om]*.*"),
+			},
+			expected: []*pb.StatReply{
+				logFile2Stat,
+				txtFileStat,
+			},
+		},
+		{
+			name: "broken pattern",
+			req: &pb.ListRequest{
+				Entry: filepath.Join(globDir, "[a"),
+			},
+			wantErr: true,
+		},
 	} {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {