feat(builder): delete cache if the cache is disabled (#422)

Author: Joshua-Anderson

pkg/gitreceive/build.go

@@ -90,8 +90,6 @@ func build(
 		}
 	}()
 
-	slugBuilderInfo := NewSlugBuilderInfo(appName, gitSha.Short())
-
 	client, err := controller.New()
 	if err != nil {
 		return err
@@ -112,6 +110,20 @@ func build(
 		}
 	}
 
+	_, disableCaching := appConf.Values["DEIS_DISABLE_CACHE"]
+	slugBuilderInfo := NewSlugBuilderInfo(appName, gitSha.Short(), disableCaching)
+
+	if slugBuilderInfo.DisableCaching() {
+		log.Debug("caching disabled for app %s", appName)
+		// If cache file exists, delete it
+		if _, err := storageDriver.Stat(context.Background(), slugBuilderInfo.CacheKey()); err == nil {
+			log.Debug("deleting cache %s for app %s", slugBuilderInfo.CacheKey(), appName)
+			if err := storageDriver.Delete(context.Background(), slugBuilderInfo.CacheKey()); err != nil {
+				return err
+			}
+		}
+	}
+
 	// build a tarball from the new objects
 	appTgz := fmt.Sprintf("%s.tar.gz", appName)
 	gitArchiveCmd := repoCmd(repoDir, "git", "archive", "--format=tar.gz", fmt.Sprintf("--output=%s", appTgz), gitSha.Short())
@@ -178,14 +190,19 @@ func build(
 		)
 	} else {
 		buildPodName = slugBuilderPodName(appName, gitSha.Short())
+
+		cacheKey := ""
+		if !slugBuilderInfo.DisableCaching() {
+			cacheKey = slugBuilderInfo.CacheKey()
+		}
 		pod = slugbuilderPod(
 			conf.Debug,
 			buildPodName,
 			conf.PodNamespace,
 			appConf.Values,
 			slugBuilderInfo.TarKey(),
 			slugBuilderInfo.PushKey(),
-			slugBuilderInfo.CacheKey(),
+			cacheKey,
 			gitSha.Short(),
 			buildPackURL,
 			conf.StorageType,

pkg/gitreceive/k8s_util.go

@@ -108,7 +108,8 @@ func slugbuilderPod(
 	pod.Spec.Containers[0].Name = slugBuilderName
 	pod.Spec.Containers[0].Image = image
 
-	if _, ok := env["DEIS_DISABLE_CACHE"]; !ok {
+	// If cacheKey is set, add it to environment
+	if cacheKey != "" {
 		addEnvToPod(pod, cachePath, cacheKey)
 	}
 

pkg/gitreceive/k8s_util_test.go

@@ -56,15 +56,12 @@ func TestBuildPod(t *testing.T) {
 	env := make(map[string]interface{})
 	env["KEY"] = "VALUE"
 
-	cacheDisabledEnv := make(map[string]interface{})
-	cacheDisabledEnv["DEIS_DISABLE_CACHE"] = "1"
-
 	var pod *api.Pod
 
 	slugBuilds := []slugBuildCase{
 		{true, "test", "default", emptyEnv, "tar", "put-url", "cache-url", "deadbeef", "", "", api.PullAlways, ""},
 		{true, "test", "default", env, "tar", "put-url", "cache-url", "deadbeef", "", "", api.PullAlways, ""},
-		{true, "test", "default", cacheDisabledEnv, "tar", "put-url", "cache-url", "deadbeef", "", "", api.PullAlways, ""},
+		{true, "test", "default", emptyEnv, "tar", "put-url", "", "deadbeef", "", "", api.PullAlways, ""},
 		{true, "test", "default", emptyEnv, "tar", "put-url", "cache-url", "deadbeef", "buildpack", "", api.PullAlways, ""},
 		{true, "test", "default", env, "tar", "put-url", "cache-url", "deadbeef", "buildpack", "", api.PullAlways, ""},
 		{true, "test", "default", env, "tar", "put-url", "cache-url", "deadbeef", "buildpack", "customimage", api.PullAlways, ""},
@@ -100,12 +97,12 @@ func TestBuildPod(t *testing.T) {
 		checkForEnv(t, pod, "TAR_PATH", build.tarKey)
 		checkForEnv(t, pod, "PUT_PATH", build.putKey)
 
-		if _, ok := build.env["DEIS_DISABLE_CACHE"]; !ok {
-			checkForEnv(t, pod, "CACHE_PATH", build.cacheKey)
-		} else {
+		if build.cacheKey == "" {
 			if cachePath, err := envValueFromKey(pod, "CACHE_PATH"); err == nil {
 				t.Errorf("expected CACHE_PATH not to be defined but it was defined with %v", cachePath)
 			}
+		} else {
+			checkForEnv(t, pod, "CACHE_PATH", build.cacheKey)
 		}
 
 		if build.buildPack != "" {

pkg/gitreceive/slug_builder_info.go

@@ -11,23 +11,26 @@ const (
 // SlugBuilderInfo contains all of the object storage related information needed to pass to a
 // slug builder.
 type SlugBuilderInfo struct {
-	pushKey  string
-	tarKey   string
-	cacheKey string
+	pushKey        string
+	tarKey         string
+	cacheKey       string
+	disableCaching bool
 }
 
 // NewSlugBuilderInfo creates and populates a new SlugBuilderInfo based on the given data
-func NewSlugBuilderInfo(appName string, shortSha string) *SlugBuilderInfo {
+func NewSlugBuilderInfo(appName string, shortSha string, disableCaching bool) *SlugBuilderInfo {
 	slugName := fmt.Sprintf("%s:git-%s", appName, shortSha)
 	tarKey := fmt.Sprintf("home/%s/tar", slugName)
 	// this is where workflow tells slugrunner to download the slug from, so we have to tell slugbuilder to upload it to here
 	pushKey := fmt.Sprintf("home/%s/push", slugName)
+
 	cacheKey := fmt.Sprintf("home/%s/cache", appName)
 
 	return &SlugBuilderInfo{
-		pushKey:  pushKey,
-		tarKey:   tarKey,
-		cacheKey: cacheKey,
+		pushKey:        pushKey,
+		tarKey:         tarKey,
+		cacheKey:       cacheKey,
+		disableCaching: disableCaching,
 	}
 }
 
@@ -44,6 +47,9 @@ func (s SlugBuilderInfo) TarKey() string { return s.tarKey }
 // it's application specific and persisted between deploys (doesn't contain git-sha)
 func (s SlugBuilderInfo) CacheKey() string { return s.cacheKey }
 
+// DisableCaching dictates whether or not the slugbuilder should persist the buildpack cache.
+func (s SlugBuilderInfo) DisableCaching() bool { return s.disableCaching }
+
 // AbsoluteSlugObjectKey returns the PushKey plus the final filename of the slug.
 func (s SlugBuilderInfo) AbsoluteSlugObjectKey() string { return s.PushKey() + "/" + slugTGZName }
 

pkg/gitreceive/slug_builder_info_test.go

@@ -4,53 +4,14 @@ import (
 	"testing"
 
 	"github.com/arschles/assert"
-	"github.com/deis/builder/pkg/git"
 )
 
-const (
-	rawSha  = "c3b4e4ba8b7267226ff02ad07a3a2cca9c9237de"
-	appName = "myapp"
-)
-
-func TestPushKey(t *testing.T) {
-	sha, err := git.NewSha(rawSha)
-	if err != nil {
-		t.Fatalf("error building git sha (%s)", err)
-	}
-	sbi := NewSlugBuilderInfo(appName, sha.Short())
-	expectedPushKey := "home/" + appName + ":git-" + sha.Short() + "/push"
-	if sbi.PushKey() != expectedPushKey {
-		t.Errorf("push key %s didn't match expected %s", sbi.PushKey(), expectedPushKey)
-	}
-}
-
-func TestTarKey(t *testing.T) {
-	sha, err := git.NewSha(rawSha)
-	if err != nil {
-		t.Fatalf("error building git sha (%s)", err)
-	}
-	sbi := NewSlugBuilderInfo(appName, sha.Short())
-	expectedTarKey := "home/" + appName + ":git-" + sha.Short() + "/tar"
-	if sbi.TarKey() != expectedTarKey {
-		t.Errorf("tar key %s didn't match expected %s", sbi.TarKey(), expectedTarKey)
-	}
-}
-
-func TestCacheKey(t *testing.T) {
-	sha, err := git.NewSha(rawSha)
-	if err != nil {
-		t.Fatalf("error building git sha (%s)", err)
-	}
-	sbi := NewSlugBuilderInfo(appName, sha.Short())
-	expectedCacheKey := "home/" + appName + "/cache"
-	if sbi.CacheKey() != expectedCacheKey {
-		t.Errorf("tar key %s didn't match expected %s", sbi.CacheKey(), expectedCacheKey)
-	}
-}
-
-func TestAbsoluteSlugObjectKey(t *testing.T) {
-	sha, err := git.NewSha(rawSha)
-	assert.NoErr(t, err)
-	sbi := NewSlugBuilderInfo(appName, sha.Short())
-	assert.Equal(t, sbi.AbsoluteSlugObjectKey(), sbi.PushKey()+"/"+slugTGZName, "absolute slug key")
+func TestSlugBuilderInfo(t *testing.T) {
+	sbi := NewSlugBuilderInfo("myapp", "c3b4e4ba", false)
+	assert.Equal(t, "home/myapp:git-c3b4e4ba/push", sbi.PushKey(), "key")
+	assert.Equal(t, "home/myapp:git-c3b4e4ba/tar", sbi.TarKey(), "key")
+	assert.Equal(t, "home/myapp/cache", sbi.CacheKey(), "key")
+	assert.Equal(t, "home/myapp:git-c3b4e4ba/push/slug.tgz", sbi.AbsoluteSlugObjectKey(), "key")
+	assert.Equal(t, "home/myapp:git-c3b4e4ba/push/Procfile", sbi.AbsoluteProcfileKey(), "key")
+	assert.Equal(t, false, sbi.DisableCaching(), "key")
 }