Merge pull request #131 from arschles/storage-keys

ref(build.go): pulling slugbuilder storage params out

Author: arschles

pkg/gitreceive/build.go

@@ -12,25 +12,13 @@ import (
 
 	"github.com/aws/aws-sdk-go/service/s3"
 	"github.com/deis/builder/pkg"
+	"github.com/deis/builder/pkg/gitreceive/git"
 	"github.com/deis/builder/pkg/gitreceive/log"
 	"github.com/deis/builder/pkg/gitreceive/storage"
 	"github.com/pborman/uuid"
 	"gopkg.in/yaml.v2"
 )
 
-const (
-	// this constant represents the length of a shortened git sha - 8 characters long
-	shortShaIdx = 8
-)
-
-type errGitShaTooShort struct {
-	sha string
-}
-
-func (e errGitShaTooShort) Error() string {
-	return fmt.Sprintf("git sha %s was too short", e.sha)
-}
-
 // repoCmd returns exec.Command(first, others...) with its current working directory repoDir
 func repoCmd(repoDir, first string, others ...string) *exec.Cmd {
 	cmd := exec.Command(first, others...)
@@ -53,30 +41,26 @@ func run(cmd *exec.Cmd) error {
 	return cmd.Run()
 }
 
-func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
+func build(conf *Config, s3Client *s3.S3, builderKey, rawGitSha string) error {
 	repo := conf.Repository
-	if len(gitSha) <= shortShaIdx {
-		return errGitShaTooShort{sha: gitSha}
+	gitSha, err := git.NewSha(rawGitSha)
+	if err != nil {
+		return err
 	}
-	shortSha := gitSha[0:8]
+
 	appName := conf.App()
 
 	repoDir := filepath.Join(conf.GitHome, repo)
 	buildDir := filepath.Join(repoDir, "build")
 
-	slugName := fmt.Sprintf("%s:git-%s", appName, shortSha)
+	slugName := fmt.Sprintf("%s:git-%s", appName, gitSha.Short())
 	imageName := strings.Replace(slugName, ":", "-", -1)
 	if err := os.MkdirAll(buildDir, os.ModeDir); err != nil {
 		return fmt.Errorf("making the build directory %s (%s)", buildDir, err)
 	}
 	tmpDir := os.TempDir()
 
-	tarObjKey := fmt.Sprintf("home/%s/tar", slugName)
-	tarURL := fmt.Sprintf("%s/git/%s", s3Client.Endpoint, tarObjKey)
-
-	// this is where workflow tells slugrunner to download the slug from, so we have to tell slugbuilder to upload it to here
-	pushObjKey := fmt.Sprintf("home/%s/push", fmt.Sprintf("%s:git-%s", appName, gitSha))
-	pushURL := fmt.Sprintf("%s/%s", s3Client.Endpoint, pushObjKey)
+	slugBuilderInfo := storage.NewSlugBuilderInfo(s3Client.Endpoint, appName, slugName, gitSha)
 
 	// Get the application config from the controller, so we can check for a custom buildpack URL
 	appConf, err := getAppConfig(conf, builderKey, conf.Username, appName)
@@ -94,7 +78,7 @@ func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
 
 	// 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)
+	gitArchiveCmd := repoCmd(repoDir, "git", "archive", "--format=tar.gz", fmt.Sprintf("--output=%s", appTgz), gitSha.Full())
 	gitArchiveCmd.Stdout = os.Stdout
 	gitArchiveCmd.Stderr = os.Stderr
 	if err := run(gitArchiveCmd); err != nil {
@@ -153,15 +137,15 @@ func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
 	var finalManifest string
 	uid := uuid.New()[:8]
 	if usingDockerfile {
-		buildPodName = fmt.Sprintf("dockerbuild-%s-%s-%s", appName, shortSha, uid)
+		buildPodName = fmt.Sprintf("dockerbuild-%s-%s-%s", appName, gitSha.Short(), uid)
 		finalManifest = strings.Replace(string(fileBytes), "repo_name", buildPodName, -1)
-		finalManifest = strings.Replace(finalManifest, "puturl", pushURL, -1)
-		finalManifest = strings.Replace(finalManifest, "tar-url", tarURL, -1)
+		finalManifest = strings.Replace(finalManifest, "puturl", slugBuilderInfo.PushURL(), -1)
+		finalManifest = strings.Replace(finalManifest, "tar-url", slugBuilderInfo.TarURL(), -1)
 	} else {
-		buildPodName = fmt.Sprintf("slugbuild-%s-%s-%s", appName, shortSha, uid)
+		buildPodName = fmt.Sprintf("slugbuild-%s-%s-%s", appName, gitSha.Short(), uid)
 		finalManifest = strings.Replace(string(fileBytes), "repo_name", buildPodName, -1)
-		finalManifest = strings.Replace(finalManifest, "puturl", pushURL, -1)
-		finalManifest = strings.Replace(finalManifest, "tar-url", tarURL, -1)
+		finalManifest = strings.Replace(finalManifest, "puturl", slugBuilderInfo.PushURL(), -1)
+		finalManifest = strings.Replace(finalManifest, "tar-url", slugBuilderInfo.TarURL(), -1)
 		finalManifest = strings.Replace(finalManifest, "buildurl", buildPackURL, -1)
 	}
 
@@ -179,8 +163,10 @@ func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
 	if err != nil {
 		return fmt.Errorf("opening %s for read (%s)", appTgz, err)
 	}
-	if err := storage.UploadObject(s3Client, bucketName, tarObjKey, appTgzReader); err != nil {
-		return fmt.Errorf("uploading %s to %s/%s (%v)", absAppTgz, bucketName, tarObjKey, err)
+
+	log.Debug("Uploading tar to %s/%s/%s", s3Client.Endpoint, bucketName, slugBuilderInfo.TarKey())
+	if err := storage.UploadObject(s3Client, bucketName, slugBuilderInfo.TarKey(), appTgzReader); err != nil {
+		return fmt.Errorf("uploading %s to %s/%s (%v)", absAppTgz, bucketName, slugBuilderInfo.TarKey(), err)
 	}
 
 	log.Info("Starting build... but first, coffee!")
@@ -233,9 +219,9 @@ func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
 	// poll the s3 server to ensure the slug exists
 	// TODO: time out looking
 	for {
-		exists, err := storage.ObjectExists(s3Client, bucketName, pushObjKey)
+		exists, err := storage.ObjectExists(s3Client, bucketName, slugBuilderInfo.PushKey())
 		if err != nil {
-			return fmt.Errorf("Checking if object %s/%s exists (%s)", bucketName, pushObjKey, err)
+			return fmt.Errorf("Checking if object %s/%s exists (%s)", bucketName, slugBuilderInfo.PushKey(), err)
 		}
 		if exists {
 			break
@@ -247,7 +233,7 @@ func build(conf *Config, s3Client *s3.S3, builderKey, gitSha string) error {
 	log.Info("Launching...")
 
 	buildHook := &pkg.BuildHook{
-		Sha:         gitSha,
+		Sha:         gitSha.Full(),
 		ReceiveUser: conf.Username,
 		ReceiveRepo: appName,
 		Image:       appName,

pkg/gitreceive/git/sha.go

@@ -0,0 +1,36 @@
+package git
+
+import (
+	"fmt"
+	"regexp"
+)
+
+const (
+	// this constant represents the length of a shortened git sha - 8 characters long
+	shortShaIdx = 8
+)
+
+var shaRegex = regexp.MustCompile(`^[\da-f]{40}$`)
+
+type ErrInvalidGitSha struct {
+	sha string
+}
+
+func (e ErrInvalidGitSha) Error() string {
+	return fmt.Sprintf("git sha %s was invalid", e.sha)
+}
+
+type SHA struct {
+	full  string
+	short string
+}
+
+func NewSha(rawSha string) (*SHA, error) {
+	if !shaRegex.MatchString(rawSha) {
+		return nil, ErrInvalidGitSha{sha: rawSha}
+	}
+	return &SHA{full: rawSha, short: rawSha[0:8]}, nil
+}
+
+func (s SHA) Full() string  { return s.full }
+func (s SHA) Short() string { return s.short }

pkg/gitreceive/git/sha_test.go

@@ -0,0 +1,44 @@
+package git
+
+import (
+	"testing"
+)
+
+func TestShaTooShort(t *testing.T) {
+	shaStrs := []string{
+		"abcdefghij",
+		"abc",
+		"",
+	}
+	for i, shaStr := range shaStrs {
+		sha, err := NewSha(shaStr)
+		if err == nil {
+			t.Errorf("expected error for sha %s (#%d), got nothing", shaStr, i)
+			continue
+		}
+		if sha != nil {
+			t.Errorf("expected returned SHA struct to be nil, got %+v instead", *sha)
+		}
+	}
+}
+
+func TestNewSha(t *testing.T) {
+	shaStrs := []string{
+		"71a09fbed590558ff822536584fc77248f070384",
+		"39d8ef3ea964c98f884a67aecef56b4c8abfc700",
+		"1b48115b57304d04c8c2e72d62e0a9d1bcd0d48f",
+	}
+	for i, shaStr := range shaStrs {
+		sha, err := NewSha(shaStr)
+		if err != nil {
+			t.Errorf("expected no error for sha %s (#%d), got %s", shaStr, i, err)
+			continue
+		}
+		if sha.Full() != shaStr {
+			t.Errorf("expected full sha string to be %s, got %s", shaStr, sha.Full())
+		}
+		if sha.Short() != shaStr[0:8] {
+			t.Errorf("expected short sha to be first 8 characters of %s, got %s", shaStr, sha.Short())
+		}
+	}
+}

pkg/gitreceive/storage/slug_builder_info.go

@@ -0,0 +1,34 @@
+package storage
+
+import (
+	"fmt"
+
+	"github.com/deis/builder/pkg/gitreceive/git"
+)
+
+// SlugBuilderInfo contains all of the object storage related information needed to pass to a slug builder
+type SlugBuilderInfo struct {
+	pushKey string
+	pushURL string
+	tarKey  string
+	tarURL  string
+}
+
+// NewSlugBuilderInfo creates and populates a new SlugBuilderInfo based on the given data
+func NewSlugBuilderInfo(s3Endpoint, appName, slugName string, gitSha *git.SHA) *SlugBuilderInfo {
+	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:git-%s/push", appName, gitSha.Full())
+
+	return &SlugBuilderInfo{
+		pushKey: pushKey,
+		pushURL: fmt.Sprintf("%s/git/%s", s3Endpoint, pushKey),
+		tarKey:  tarKey,
+		tarURL:  fmt.Sprintf("%s/git/%s", s3Endpoint, tarKey),
+	}
+}
+
+func (s SlugBuilderInfo) PushKey() string { return s.pushKey }
+func (s SlugBuilderInfo) PushURL() string { return s.pushURL }
+func (s SlugBuilderInfo) TarKey() string  { return s.tarKey }
+func (s SlugBuilderInfo) TarURL() string  { return s.tarURL }

pkg/gitreceive/storage/slug_builder_info_test.go

@@ -0,0 +1,55 @@
+package storage
+
+import (
+	"testing"
+
+	"github.com/deis/builder/pkg/gitreceive/git"
+)
+
+const (
+	rawSha     = "c3b4e4ba8b7267226ff02ad07a3a2cca9c9237de"
+	s3Endpoint = "http://10.1.2.3:9090"
+	appName    = "myapp"
+	slugName   = "myslug"
+)
+
+func TestS3Endpoint(t *testing.T) {
+	sha, err := git.NewSha(rawSha)
+	if err != nil {
+		t.Fatalf("error building git sha (%s)", err)
+	}
+	sbi := NewSlugBuilderInfo(s3Endpoint, appName, slugName, sha)
+
+	expectedPushURL := s3Endpoint + "/git/" + sbi.PushKey()
+	if sbi.PushURL() != expectedPushURL {
+		t.Errorf("push URL %s didn't match expected %s", sbi.PushURL(), expectedPushURL)
+	}
+	expectedTarURL := s3Endpoint + "/git/" + sbi.TarKey()
+	if sbi.TarURL() != expectedTarURL {
+		t.Errorf("tar URL %s didn't match expected %s", sbi.TarURL(), expectedTarURL)
+	}
+}
+
+func TestPushKey(t *testing.T) {
+	sha, err := git.NewSha(rawSha)
+	if err != nil {
+		t.Fatalf("error building git sha (%s)", err)
+	}
+	sbi := NewSlugBuilderInfo(s3Endpoint, appName, slugName, sha)
+	expectedPushKey := "home/" + appName + ":git-" + sha.Full() + "/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(s3Endpoint, appName, slugName, sha)
+	expectedTarKey := "home/" + slugName + "/tar"
+	if sbi.TarKey() != expectedTarKey {
+		t.Errorf("tar key %s didn't match expected %s", sbi.TarKey(), expectedTarKey)
+	}
+}