Add symlink info to file metadata

go.sum

@@ -32,6 +32,7 @@ github.com/bazelbuild/remote-apis v0.0.0-20190507145712-5556e9c6153f h1:KLZodm2m
 github.com/bazelbuild/remote-apis v0.0.0-20190507145712-5556e9c6153f/go.mod h1:9Y+1FnaNUGVV6wKE0Jdh+mguqDUsyd9uUqokalrC7DQ=
 github.com/bazelbuild/remote-apis v0.0.0-20191104140458-e77c4eb2ca48 h1:bgj+Oufa8F4rCHe/8omhml7cBlg3VmNhF66ed1vT2Bw=
 github.com/bazelbuild/remote-apis v0.0.0-20191104140458-e77c4eb2ca48/go.mod h1:9Y+1FnaNUGVV6wKE0Jdh+mguqDUsyd9uUqokalrC7DQ=
+github.com/bazelbuild/remote-apis v0.0.0-20200624085034-0afc3700d177 h1:JeDdP1ZsFOMctOzhcwYfLkGaLT8Nzxc1AXkXKUrWbAw=
 github.com/boombuler/barcode v1.0.0 h1:s1TvRnXwL2xJRaccrdcBQMZxq6X7DvsMogtmJeHDdrc=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
 github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625 h1:ckJgFhFWywOx+YLEMIJsTb+NV6NexWICk5+AMSuz3ss=
@@ -111,6 +112,7 @@ github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/gonum/blas v0.0.0-20181208220705-f22b278b28ac h1:Q0Jsdxl5jbxouNs1TQYt0gxesYMU4VXRbsTlgDloZ50=

go/pkg/filemetadata/cache_posix_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestExecutableCacheLoad(t *testing.T) {
 	c := NewSingleFlightCache()
-	filename, err := createFile(t, true, "")
+	filename, err := createFile(t, &testFileParams{executable: true})
 	if err != nil {
 		t.Fatalf("Failed to create tmp file for testing digests: %v", err)
 	}

go/pkg/filemetadata/cache_test.go

@@ -16,7 +16,7 @@ var (
 
 func TestSimpleCacheLoad(t *testing.T) {
 	c := NewSingleFlightCache()
-	filename, err := createFile(t, false, "")
+	filename, err := createFile(t, &testFileParams{})
 	if err != nil {
 		t.Fatalf("Failed to create tmp file for testing digests: %v", err)
 	}
@@ -45,7 +45,7 @@ func TestSimpleCacheLoad(t *testing.T) {
 
 func TestCacheOnceLoadMultiple(t *testing.T) {
 	c := NewSingleFlightCache()
-	filename, err := createFile(t, false, "")
+	filename, err := createFile(t, &testFileParams{})
 	if err != nil {
 		t.Fatalf("Failed to create tmp file for testing digests: %v", err)
 	}
@@ -75,7 +75,7 @@ func TestCacheOnceLoadMultiple(t *testing.T) {
 
 func TestLoadAfterChangeWithoutValidation(t *testing.T) {
 	c := NewSingleFlightCache()
-	filename, err := createFile(t, false, "")
+	filename, err := createFile(t, &testFileParams{})
 	if err != nil {
 		t.Fatalf("Failed to create tmp file for testing digests: %v", err)
 	}

go/pkg/filemetadata/filemetadata.go

@@ -8,19 +8,25 @@ import (
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/digest"
 )
 
+// SymlinkMetadata contains details if the given path is a symlink.
+type SymlinkMetadata struct {
+	Target     string
+	IsDangling bool
+}
+
 // Metadata contains details for a particular file.
 type Metadata struct {
 	Digest       digest.Digest
 	IsExecutable bool
 	Err          error
+	Symlink      *SymlinkMetadata
 }
 
 // FileError is the error returned by the Compute function.
 type FileError struct {
-	IsDirectory      bool
-	IsNotFound       bool
-	IsInvalidSymlink bool
-	Err              error
+	IsDirectory bool
+	IsNotFound  bool
+	Err         error
 }
 
 // Error returns the error message.
@@ -41,11 +47,25 @@ func isSymlink(filename string) (bool, error) {
 func Compute(filename string) *Metadata {
 	md := &Metadata{Digest: digest.Empty}
 	file, err := os.Stat(filename)
+	if isSym, _ := isSymlink(filename); isSym {
+		md.Symlink = &SymlinkMetadata{}
+		if err != nil {
+			md.Err = &FileError{Err: err}
+			md.Symlink.IsDangling = true
+			return md
+		}
+		dest, err := os.Readlink(filename)
+		if err != nil {
+			// This should never happen given that we have verified |filename| is a symlink.
+			md.Err = &FileError{Err: err}
+			md.Symlink.IsDangling = true
+			return md
+		}
+		md.Symlink.Target = dest
+	}
+
 	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/filemetadata/filemetadata_test.go

@@ -1,37 +1,50 @@
 package filemetadata
 
 import (
+	"crypto/rand"
+	"encoding/hex"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/digest"
 	"github.com/google/go-cmp/cmp"
 )
 
-func TestCompute(t *testing.T) {
+type testFileParams struct {
+	contents   string
+	executable bool
+}
+
+func TestComputeFiles(t *testing.T) {
 	tests := []struct {
-		name       string
-		contents   string
-		executable bool
+		name string
+		*testFileParams
 	}{
 		{
-			name:     "empty",
-			contents: "",
+			name: "empty",
+			testFileParams: &testFileParams{
+				contents: "",
+			},
 		},
 		{
-			name:     "non-executable",
-			contents: "bla",
+			name: "non-executable",
+			testFileParams: &testFileParams{
+				contents: "bla",
+			},
 		},
 		{
-			name:       "executable",
-			contents:   "foo",
-			executable: true,
+			name: "executable",
+			testFileParams: &testFileParams{
+				contents:   "foo",
+				executable: true,
+			},
 		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			filename, err := createFile(t, tc.executable, tc.contents)
+			filename, err := createFile(t, tc.testFileParams)
 			if err != nil {
 				t.Fatalf("Failed to create tmp file for testing digests: %v", err)
 			}
@@ -66,10 +79,111 @@ func TestComputeDirectory(t *testing.T) {
 	}
 }
 
-func createFile(t *testing.T, executable bool, contents string) (string, error) {
+type testSymlinkCreationResult struct {
+	symlink string
+	target  string
+}
+
+func (sc *testSymlinkCreationResult) cleanup() {
+	os.RemoveAll(sc.symlink)
+	os.RemoveAll(sc.target)
+}
+
+func TestComputeSymlinksToFile(t *testing.T) {
+	tests := []struct {
+		name   string
+		target *testFileParams
+	}{
+		{
+			name: "valid",
+			target: &testFileParams{
+				contents: "bla",
+			},
+		},
+		{
+			name: "valid-executable",
+			target: &testFileParams{
+				contents:   "executable",
+				executable: true,
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			fileParams := tc.target
+			symlinkResult, err := createSymlinkTofile(t, fileParams)
+			if err != nil {
+				t.Fatalf("Failed to create tmp symlink for testing digests: %v", err)
+			}
+			defer symlinkResult.cleanup()
+
+			symlinkPath := symlinkResult.symlink
+			got := Compute(symlinkPath)
+
+			if got.Err != nil {
+				t.Errorf("Compute(%v) failed. Got error: %v", symlinkPath, got.Err)
+			}
+			want := &Metadata{
+				Symlink: &SymlinkMetadata{
+					Target:     symlinkResult.target,
+					IsDangling: false,
+				},
+				Digest:       digest.NewFromBlob([]byte(fileParams.contents)),
+				IsExecutable: fileParams.executable,
+			}
+
+			if diff := cmp.Diff(want, got); diff != "" {
+				t.Errorf("Compute(%v) returned diff. (-want +got)\n%s", symlinkPath, diff)
+			}
+		})
+	}
+}
+
+func TestComputeDanglingSymlinks(t *testing.T) {
+	// Create a temporary fake target so that os.Symlink() can work.
+	symlinkResult, err := createSymlinkTofile(t, &testFileParams{
+		contents: "transient",
+	})
+	if err != nil {
+		t.Fatalf("Failed to create tmp symlink for testing digests: %v", err)
+	}
+	// Make the symlink dangling
+	os.RemoveAll(symlinkResult.target)
+	defer symlinkResult.cleanup()
+
+	symlinkPath := symlinkResult.symlink
+	got := Compute(symlinkPath)
+	if got.Err == nil || !got.Symlink.IsDangling {
+		t.Errorf("Compute(%v) should fail because the symlink is dangling", symlinkPath)
+	}
+	if got.Symlink.Target != "" {
+		t.Errorf("Compute(%v) should fail because the symlink is dangling, got target: %s", symlinkPath, got.Symlink.Target)
+	}
+}
+
+func TestComputeSymlinksToDirectory(t *testing.T) {
+	targetPath, err := ioutil.TempDir(os.TempDir(), "")
+	if err != nil {
+		t.Fatalf("Failed to create tmp directory: %v", err)
+	}
+	symlinkResult, err := createSymlinkToTarget(t, targetPath)
+
+	if err != nil {
+		t.Fatalf("Failed to create tmp symlink for testing digests: %v", err)
+	}
+	defer symlinkResult.cleanup()
+
+	symlinkPath := symlinkResult.symlink
+	got := Compute(symlinkPath)
+	if fe, ok := got.Err.(*FileError); !ok || !fe.IsDirectory {
+		t.Errorf("Compute(%v).Err = %v, want FileError{IsDirectory:true}", symlinkPath, got.Err)
+	}
+}
+
+func createFile(t *testing.T, fp *testFileParams) (string, error) {
 	t.Helper()
 	perm := os.FileMode(0666)
-	if executable {
+	if fp.executable {
 		perm = os.FileMode(0766)
 	}
 	tmpFile, err := ioutil.TempFile(os.TempDir(), "")
@@ -83,8 +197,32 @@ func createFile(t *testing.T, executable bool, contents string) (string, error)
 		return "", err
 	}
 	filename := tmpFile.Name()
-	if err = ioutil.WriteFile(filename, []byte(contents), os.ModeTemporary); err != nil {
+	if err = ioutil.WriteFile(filename, []byte(fp.contents), os.ModeTemporary); err != nil {
 		return "", err
 	}
 	return filename, nil
 }
+
+func createSymlinkTofile(t *testing.T, target *testFileParams) (*testSymlinkCreationResult, error) {
+	targetPath, err := createFile(t, target)
+	if err != nil {
+		return nil, err
+	}
+	return createSymlinkToTarget(t, targetPath)
+}
+
+func createSymlinkToTarget(t *testing.T, targetPath string) (*testSymlinkCreationResult, error) {
+	t.Helper()
+
+	randBytes := make([]byte, 16)
+	rand.Read(randBytes)
+	symlinkPath := filepath.Join(os.TempDir(), hex.EncodeToString(randBytes))
+	if err := os.Symlink(targetPath, symlinkPath); err != nil {
+		return nil, err
+	}
+
+	return &testSymlinkCreationResult{
+		symlink: symlinkPath,
+		target:  targetPath,
+	}, nil
+}

go/pkg/tree/tree.go

@@ -65,14 +65,14 @@ func loadFiles(execRoot string, excl []*command.InputExclusion, path string, fs
 	absPath := filepath.Clean(filepath.Join(execRoot, path))
 	meta := cache.Get(absPath)
 	t := command.FileInputType
+	if smd := meta.Symlink; smd != nil && smd.IsDangling {
+		return nil
+	}
 	if meta.Err != nil {
 		e, ok := meta.Err.(*filemetadata.FileError)
 		if !ok {
 			return meta.Err
 		}
-		if e.IsInvalidSymlink {
-			return nil
-		}
 		if !e.IsDirectory {
 			return meta.Err
 		}