Local disk cache

Author: ola-rozenfeld

go/pkg/client/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//go/pkg/command",
         "//go/pkg/contextmd",
         "//go/pkg/digest",
+        "//go/pkg/diskcache",
         "//go/pkg/filemetadata",
         "//go/pkg/io/impath",
         "//go/pkg/io/walker",

go/pkg/client/cas_download.go

@@ -102,6 +102,17 @@ func (c *Client) DownloadOutputs(ctx context.Context, outs map[string]*TreeOutpu
 			symlinks = append(symlinks, out)
 			continue
 		}
+		if c.diskCache != nil {
+			absPath := out.Path
+			if !filepath.IsAbs(absPath) {
+				absPath = filepath.Join(outDir, absPath)
+			}
+			if c.diskCache.LoadCas(out.Digest, absPath) {
+				fullStats.Requested += out.Digest.Size
+				fullStats.Cached += out.Digest.Size
+				continue
+			}
+		}
 		if _, ok := downloads[out.Digest]; ok {
 			copies = append(copies, out)
 			// All copies are effectivelly cached
@@ -130,6 +141,11 @@ func (c *Client) DownloadOutputs(ctx context.Context, outs map[string]*TreeOutpu
 		if err := cache.Update(absPath, md); err != nil {
 			return fullStats, err
 		}
+		if c.diskCache != nil {
+			if err := c.diskCache.StoreCas(output.Digest, absPath); err != nil {
+				return fullStats, err
+			}
+		}
 	}
 	for _, out := range copies {
 		perm := c.RegularMode

go/pkg/client/client.go

@@ -19,6 +19,7 @@ import (
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/casng"
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/chunker"
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/digest"
+	"github.com/bazelbuild/remote-apis-sdks/go/pkg/diskcache"
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/retry"
 	"github.com/bazelbuild/remote-apis-sdks/go/pkg/uploadinfo"
 	"github.com/pkg/errors"
@@ -188,6 +189,7 @@ type Client struct {
 	uploadOnce          sync.Once
 	downloadOnce        sync.Once
 	useBatchCompression UseBatchCompression
+	diskCache           *diskcache.DiskCache
 }
 
 const (
@@ -333,6 +335,20 @@ func (o *TreeSymlinkOpts) Apply(c *Client) {
 	c.TreeSymlinkOpts = o
 }
 
+type DiskCacheOpts struct {
+	Context       context.Context
+	Path          string
+	MaxCapacityGb float64
+}
+
+// Apply sets the client's TreeSymlinkOpts.
+func (o *DiskCacheOpts) Apply(c *Client) {
+	if o.Path != "" {
+		capBytes := uint64(o.MaxCapacityGb * 1024 * 1024 * 1024)
+		c.diskCache = diskcache.New(o.Context, o.Path, capBytes)
+	}
+}
+
 // MaxBatchDigests is maximum amount of digests to batch in upload and download operations.
 type MaxBatchDigests int
 

go/pkg/client/exec.go

@@ -98,13 +98,23 @@ func (c *Client) ExecuteAction(ctx context.Context, ac *Action) (*repb.ActionRes
 }
 
 // CheckActionCache queries remote action cache, returning an ActionResult or nil if it doesn't exist.
-func (c *Client) CheckActionCache(ctx context.Context, acDg *repb.Digest) (*repb.ActionResult, error) {
+func (c *Client) CheckActionCache(ctx context.Context, dg digest.Digest) (*repb.ActionResult, error) {
+	if c.diskCache != nil {
+		if res, loaded := c.diskCache.LoadActionCache(dg); loaded {
+			return res, nil
+		}
+	}
 	res, err := c.GetActionResult(ctx, &repb.GetActionResultRequest{
 		InstanceName: c.InstanceName,
-		ActionDigest: acDg,
+		ActionDigest: dg.ToProto(),
 	})
 	switch st, _ := status.FromError(err); st.Code() {
 	case codes.OK:
+		if c.diskCache != nil {
+			if err := c.diskCache.StoreActionCache(dg, res); err != nil {
+				log.Errorf("error storing ActionResult of %s to disk cache: %v", dg, err)
+			}
+		}
 		return res, nil
 	case codes.NotFound:
 		return nil, nil
@@ -166,12 +176,13 @@ func (c *Client) PrepAction(ctx context.Context, ac *Action) (*repb.Digest, *rep
 	if err != nil {
 		return nil, nil, gerrors.WithMessage(err, "marshalling Action proto")
 	}
-	acDg := digest.NewFromBlob(acBlob).ToProto()
+	dg := digest.NewFromBlob(acBlob)
+	acDg := dg.ToProto()
 
 	// If the result is cacheable, check if it's already in the cache.
 	if !ac.DoNotCache || !ac.SkipCache {
 		log.V(1).Info("Checking cache")
-		res, err := c.CheckActionCache(ctx, acDg)
+		res, err := c.CheckActionCache(ctx, dg)
 		if err != nil {
 			return nil, nil, err
 		}

go/pkg/diskcache/BUILD.bazel

@@ -0,0 +1,33 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "diskcache",
+    srcs = [
+        "atim_darwin.go",
+        "atim_linux.go",
+        "atim_windows.go",
+        "diskcache.go",
+    ],
+    importpath = "github.com/bazelbuild/remote-apis-sdks/go/pkg/diskcache",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//go/pkg/digest",
+        "@com_github_bazelbuild_remote_apis//build/bazel/remote/execution/v2:remote_execution_go_proto",
+        "@com_github_golang_glog//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+    ],
+)
+
+go_test(
+    name = "diskcache_test",
+    srcs = ["diskcache_test.go"],
+    embed = [":diskcache"],
+    deps = [
+        "//go/pkg/digest",
+        "//go/pkg/testutil",
+        "@com_github_bazelbuild_remote_apis//build/bazel/remote/execution/v2:remote_execution_go_proto",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+        "@com_github_pborman_uuid//:go_default_library",
+        "@org_golang_x_sync//errgroup:go_default_library",
+    ],
+)

go/pkg/diskcache/atim_darwin.go

@@ -0,0 +1,16 @@
+// Utility to get the last accessed time on Darwin.
+package diskcache
+
+import (
+	"os"
+	"syscall"
+	"time"
+)
+
+func GetLastAccessTime(path string) (time.Time, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Unix(info.Sys().(*syscall.Stat_t).Atimespec.Unix()), nil
+}

go/pkg/diskcache/atim_linux.go

@@ -0,0 +1,16 @@
+// Utility to get the last accessed time on Linux.
+package diskcache
+
+import (
+	"os"
+	"syscall"
+	"time"
+)
+
+func GetLastAccessTime(path string) (time.Time, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Unix(info.Sys().(*syscall.Stat_t).Atim.Unix()), nil
+}

go/pkg/diskcache/atim_windows.go

@@ -0,0 +1,18 @@
+// Utility to get the last accessed time on Windows.
+package diskcache
+
+import (
+	"os"
+	"syscall"
+	"time"
+)
+
+// This will return correct values only if `fsutil behavior set disablelastaccess 0` is set.
+// Tracking of last access time is disabled by default on Windows.
+func GetLastAccessTime(path string) (time.Time, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Unix(0, info.Sys().(*syscall.Win32FileAttributeData).LastAccessTime.Nanoseconds()), nil
+}