Ignore invalid symlinks when computing Merkle tree (bazelbuild#134)

When given an output directory containing an invalid symlink (i.e., a
symlink pointing to a non-existent file), the SDK fails to compute
Merkle tree because of Stat failure. This change makes the SDK ignore
it.

Tested by both using this version of re-client and added unit-tests.

go/pkg/filemetadata/filemetadata.go

@@ -19,23 +19,35 @@ type Metadata struct {
 
 // FileError is the error returned by the Compute function.
 type FileError struct {
-	IsDirectory bool
-	IsNotFound  bool
-	Err         error
+	IsDirectory      bool
+	IsNotFound       bool
+	IsInvalidSymlink bool
+	Err              error
 }
 
 // Error returns the error message.
 func (e *FileError) Error() string {
 	return e.Err.Error()
 }
 
+func isSymlink(filename string) (bool, error) {
+	file, err := os.Lstat(filename)
+	if err != nil {
+		return false, err
+	}
+	return file.Mode()&os.ModeSymlink != 0, nil
+}
+
 // Compute computes a Metadata from a given file path.
 // If an error is returned, it will be of type *FileError.
 func Compute(filename string) *Metadata {
 	md := &Metadata{Digest: digest.Empty}
 	file, err := os.Stat(filename)
 	if err != nil {
 		fe := &FileError{Err: err}
+		if s, err := isSymlink(filename); err == nil && s {
+			fe.IsInvalidSymlink = true
+		}
 		if os.IsNotExist(err) {
 			fe.IsNotFound = true
 		}

go/pkg/tree/tree.go

@@ -66,7 +66,14 @@ func loadFiles(execRoot string, excl []*command.InputExclusion, path string, fs
 	meta := cache.Get(absPath)
 	t := command.FileInputType
 	if meta.Err != nil {
-		if e, ok := meta.Err.(*filemetadata.FileError); !ok || !e.IsDirectory {
+		e, ok := meta.Err.(*filemetadata.FileError)
+		if !ok {
+			return meta.Err
+		}
+		if e.IsInvalidSymlink {
+			return nil
+		}
+		if !e.IsDirectory {
 			return meta.Err
 		}
 		t = command.DirectoryInputType

go/pkg/tree/tree_test.go

@@ -462,6 +462,32 @@ func TestComputeMerkleTree(t *testing.T) {
 				TotalInputBytes:  2*fooDg.Size + fooDirDg.Size,
 			},
 		},
+		{
+			desc: "File invalid symlink",
+			input: []*inputPath{
+				{path: "fooDir/foo", fileContents: fooBlob, isExecutable: true},
+				{path: "foo", isSymlink: true, symlinkTarget: "fooDir/foo"},
+				{path: "bar", isSymlink: true, symlinkTarget: "fooDir/bar"},
+			},
+			spec: &command.InputSpec{
+				Inputs: []string{"fooDir", "foo"},
+			},
+			rootDir: &repb.Directory{
+				Directories: []*repb.DirectoryNode{{Name: "fooDir", Digest: fooDirDgPb}},
+				Files:       []*repb.FileNode{{Name: "foo", Digest: fooDgPb, IsExecutable: true}},
+			},
+			additionalBlobs: [][]byte{fooBlob, fooDirBlob},
+			wantCacheCalls: map[string]int{
+				"fooDir":     1,
+				"fooDir/foo": 1,
+				"foo":        1,
+			},
+			wantStats: &Stats{
+				InputDirectories: 2,
+				InputFiles:       2,
+				TotalInputBytes:  2*fooDg.Size + fooDirDg.Size,
+			},
+		},
 		{
 			desc: "Directory absolute symlink",
 			input: []*inputPath{