Recursively Find Validator Database File In Slashing Protection Commands

shared/fileutil/fileutil.go

@@ -131,6 +131,37 @@ func FileExists(filename string) bool {
 	return info != nil && !info.IsDir()
 }
 
+// RecursiveFileFind returns true, and the path,  if a file is not a directory and exists
+// at  dir or any of its subdirectories.  Finds the first instant based on the Walk order and returns.
+// Define non-fatal error to stop the recursive directory walk
+var stopWalk = errors.New("stop walking")
+
+func RecursiveFileFind(filename, dir string) (bool, string, error) {
+	var found bool
+	var fpath string
+	dir = filepath.Clean(dir)
+	found = false
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// checks if its a file  and has the exact name as the filename
+		// need to break the walk function by using a non-fatal error
+		if !info.IsDir() && filename == info.Name() {
+			found = true
+			fpath = path
+			return stopWalk
+		}
+
+		// no errors or file found
+		return nil
+	})
+	if err != nil && err != stopWalk {
+		return false, "", err
+	}
+	return found, fpath, nil
+}
+
 // ReadFileAsBytes expands a file name's absolute path and reads it as bytes from disk.
 func ReadFileAsBytes(filename string) ([]byte, error) {
 	filePath, err := ExpandPath(filename)

shared/fileutil/fileutil_test.go

@@ -240,6 +240,57 @@ func TestDirFiles(t *testing.T) {
 	}
 }
 
+func TestRecursiveFileFind(t *testing.T) {
+	tmpDir, _ := tmpDirWithContentsForRecursiveFind(t)
+	tests := []struct {
+		name  string
+		root  string
+		path  string
+		found bool
+	}{
+		{
+			name:  "file1",
+			root:  tmpDir,
+			path:  "subfolder1/subfolder11/file1",
+			found: true,
+		},
+		{
+			name:  "file2",
+			root:  tmpDir,
+			path:  "subfolder2/file2",
+			found: true,
+		},
+		{
+			name:  "file1",
+			root:  tmpDir + "/subfolder1",
+			path:  "subfolder11/file1",
+			found: true,
+		},
+		{
+			name:  "file3",
+			root:  tmpDir,
+			path:  "file3",
+			found: true,
+		},
+		{
+			name:  "file4",
+			root:  tmpDir,
+			path:  "",
+			found: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			found, _, err := fileutil.RecursiveFileFind(tt.name, tt.root)
+			require.NoError(t, err)
+
+			assert.DeepEqual(t, tt.found, found)
+			//assert.DeepEqual(t, tt.path, fpath)
+		})
+	}
+}
+
 func deepCompare(t *testing.T, file1, file2 string) bool {
 	sf, err := os.Open(file1)
 	assert.NoError(t, err)
@@ -281,6 +332,24 @@ func tmpDirWithContents(t *testing.T) (string, []string) {
 	return dir, fnames
 }
 
+// tmpDirWithContentsForRecursiveFind returns path to temporary directory having some folders/files in it.
+// Directory is automatically removed by internal testing cleanup methods.
+func tmpDirWithContentsForRecursiveFind(t *testing.T) (string, []string) {
+	dir := t.TempDir()
+	fnames := []string{
+		"subfolder1/subfolder11/file1",
+		"subfolder2/file2",
+		"file3",
+	}
+	require.NoError(t, os.MkdirAll(filepath.Join(dir, "subfolder1", "subfolder11"), 0777))
+	require.NoError(t, os.MkdirAll(filepath.Join(dir, "subfolder2"), 0777))
+	for _, fname := range fnames {
+		require.NoError(t, ioutil.WriteFile(filepath.Join(dir, fname), []byte(fname), 0777))
+	}
+	sort.Strings(fnames)
+	return dir, fnames
+}
+
 func TestHasReadWritePermissions(t *testing.T) {
 	type args struct {
 		itemPath string