ref(cookoo): remove cookoo dependency from builder

Author: smothiki

boot.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"runtime"
 
-	cookoolog "github.com/Masterminds/cookoo/log"
 	"github.com/codegangsta/cli"
 	"github.com/deis/builder/pkg"
 	"github.com/deis/builder/pkg/cleaner"
@@ -36,7 +35,6 @@ func init() {
 func main() {
 	if os.Getenv("DEBUG") == "true" {
 		pkglog.DefaultLogger.SetDebug(true)
-		cookoolog.Level = cookoolog.LogDebug
 		log.Printf("Running in debug mode")
 	}
 

glide.yaml

@@ -8,12 +8,6 @@ import:
 - package: github.com/kelseyhightower/envconfig
 - package: github.com/gorilla/mux
   version: e444e69cbd2e2e3e0749a2f3c717cec491552bbf
-- package: github.com/Masterminds/cookoo
-  version: 110a04ff7dc3e7c9b86c1a2413906a16a2bb65cb
-  subpackages:
-  - log
-  - safely
-  - fmt
 - package: golang.org/x/crypto
   version: f7445b17d61953e333441674c2d11e91ae4559d3
   subpackages:

pkg/builder.go

@@ -6,12 +6,9 @@ package pkg
 
 import (
 	"fmt"
-	"log"
-	"os"
 
-	"github.com/Masterminds/cookoo"
-	clog "github.com/Masterminds/cookoo/log"
 	"github.com/deis/builder/pkg/sshd"
+	"github.com/deis/pkg/log"
 )
 
 // Return codes that will be sent to the shell.
@@ -29,38 +26,15 @@ const (
 //
 // Run returns on of the Status* status code constants.
 func RunBuilder(sshHostIP string, sshHostPort int, gitHomeDir string, sshServerCircuit *sshd.Circuit, pushLock sshd.RepositoryLock) int {
-	reg, router, ocxt := cookoo.Cookoo()
-	log.SetFlags(0) // Time is captured elsewhere.
-
-	// We layer the context to add better logging and also synchronize
-	// access so that goroutines don't get into race conditions.
-	cxt := cookoo.SyncContext(ocxt)
-	cxt.Put("cookoo.Router", router)
-	cxt.AddLogger("stdout", os.Stdout)
-
-	// Build the routes. See routes.go.
-	routes(reg)
-
-	// Bootstrap the background services. If this fails, we stop.
-	if err := router.HandleRequest("boot", cxt, false); err != nil {
-		clog.Errf(cxt, "Fatal errror on boot: %s", err)
+	address := fmt.Sprintf("%s:%d", sshHostIP, sshHostPort)
+	cfg, err := sshd.Configure()
+	if err != nil {
+		log.Err("SSH server configuration failed: %s", err)
 		return StatusLocalError
 	}
-
-	cxt.Put(sshd.Address, fmt.Sprintf("%s:%d", sshHostIP, sshHostPort))
-
-	// Supply route names for handling various internal routing. While this
-	// isn't necessary for Cookoo, it makes it easy for us to mock these
-	// routes in tests. c.f. sshd/server.go
-	cxt.Put("route.sshd.pubkeyAuth", "pubkeyAuth")
-	cxt.Put("route.sshd.sshPing", "sshPing")
-	cxt.Put("route.sshd.sshGitReceive", "sshGitReceive")
-
-	// Start the SSH service.
-	// TODO: We could refactor Serve to be a command, and then run this as
-	// a route.
-	if err := sshd.Serve(reg, router, sshServerCircuit, gitHomeDir, pushLock, cxt); err != nil {
-		clog.Errf(cxt, "SSH server failed: %s", err)
+	receivetype := "gitreceive"
+	if err := sshd.Serve(cfg, sshServerCircuit, gitHomeDir, pushLock, address, receivetype); err != nil {
+		log.Err("SSH server failed: %s", err)
 		return StatusLocalError
 	}
 

pkg/commands.go

@@ -15,10 +15,7 @@ import (
 	"sync"
 	"text/template"
 
-	"github.com/deis/builder/pkg/controller"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/cookoo/log"
+	"github.com/deis/pkg/log"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -46,119 +43,79 @@ var preReceiveHookTpl = template.Must(template.New("hooks").Parse(preReceiveHook
 
 // Receive receives a Git repo.
 // This will only work for git-receive-pack.
-//
-// Params:
-// 	- operation (string): e.g. git-receive-pack
-// 	- repoName (string): The repository name, in the form '/REPO.git'.
-// 	- channel (ssh.Channel): The channel.
-// 	- request (*ssh.Request): The channel.
-// 	- gitHome (string): Defaults to /home/git.
-// 	- userInfo (*controller.UserInfo): Deis user information.
-//
-// Returns:
-// 	- nothing
-func Receive(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	if ok, z := p.Requires("channel", "request", "userinfo"); !ok {
-		return nil, fmt.Errorf("Missing requirements %q", z)
-	}
-	repoName := p.Get("repoName", "").(string)
-	operation := p.Get("operation", "").(string)
-	channel := p.Get("channel", nil).(ssh.Channel)
-	gitHome := p.Get("gitHome", "/home/git").(string)
-	userinfo := p.Get("userinfo", nil).(*controller.UserInfo)
+func Receive(
+	repo, operation, gitHome string,
+	channel ssh.Channel,
+	fingerprint, username, conndata, receivetype string) error {
 
-	log.Debugf(c, "receiving git repo name: %s, operation: %s, fingerprint: %s, user: %s", repoName, operation, userinfo.Fingerprint, userinfo.Username)
-
-	repo, err := cleanRepoName(repoName)
-	if err != nil {
-		log.Warnf(c, "Illegal repo name: %s.", err)
-		channel.Stderr().Write([]byte("No repo given"))
-		return nil, err
-	}
+	log.Info("receiving git repo name: %s, operation: %s, fingerprint: %s, user: %s", repo, operation, fingerprint, username)
 
-	if ok := checkIfAllowed(repo, userinfo.Apps); !ok {
-		return nil, fmt.Sprintf("The user %v has no permission in application %v", userinfo.Username, repo)
+	if receivetype == "mock" {
+		channel.Write([]byte("OK"))
+		return nil
 	}
-
-	repo += ".git"
-
 	repoPath := filepath.Join(gitHome, repo)
-	log.Debugf(c, "creating repo directory %s", repoPath)
-	if _, err := createRepo(c, repoPath); err != nil {
+	log.Info("creating repo directory %s", repoPath)
+	if _, err := createRepo(repoPath); err != nil {
 		err = fmt.Errorf("Did not create new repo (%s)", err)
-		log.Warnf(c, err.Error())
-		return nil, err
+
+		return err
 	}
 
-	log.Debugf(c, "writing pre-receive hook under %s", repoPath)
-	if err := createPreReceiveHook(c, gitHome, repoPath); err != nil {
+	log.Info("writing pre-receive hook under %s", repoPath)
+	if err := createPreReceiveHook(gitHome, repoPath); err != nil {
 		err = fmt.Errorf("Did not write pre-receive hook (%s)", err)
-		log.Warnf(c, err.Error())
-		return nil, err
+		return err
 	}
 
 	cmd := exec.Command("git-shell", "-c", fmt.Sprintf("%s '%s'", operation, repo))
-	log.Infof(c, strings.Join(cmd.Args, " "))
+	log.Info(strings.Join(cmd.Args, " "))
 
 	var errbuff bytes.Buffer
 
 	cmd.Dir = gitHome
 	cmd.Env = []string{
-		fmt.Sprintf("RECEIVE_USER=%s", userinfo.Username),
+		fmt.Sprintf("RECEIVE_USER=%s", username),
 		fmt.Sprintf("RECEIVE_REPO=%s", repo),
-		fmt.Sprintf("RECEIVE_FINGERPRINT=%s", userinfo.Fingerprint),
+		fmt.Sprintf("RECEIVE_FINGERPRINT=%s", fingerprint),
 		fmt.Sprintf("SSH_ORIGINAL_COMMAND=%s '%s'", operation, repo),
-		fmt.Sprintf("SSH_CONNECTION=%s", c.Get("SSH_CONNECTION", "0 0 0 0").(string)),
+		fmt.Sprintf("SSH_CONNECTION=%s", conndata),
 	}
 	cmd.Env = append(cmd.Env, os.Environ()...)
 
-	log.Debugf(c, "Working Dir: %s", cmd.Dir)
-	log.Debugf(c, "Environment: %s", strings.Join(cmd.Env, ","))
+	log.Debug("Working Dir: %s", cmd.Dir)
+	log.Debug("Environment: %s", strings.Join(cmd.Env, ","))
 
 	inpipe, err := cmd.StdinPipe()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	cmd.Stdout = channel
 	cmd.Stderr = io.MultiWriter(channel.Stderr(), &errbuff)
 
 	if err := cmd.Start(); err != nil {
 		err = fmt.Errorf("Failed to start git pre-receive hook: %s (%s)", err, errbuff.Bytes())
-		log.Warnf(c, err.Error())
-		return nil, err
+		return err
 	}
 
 	if _, err := io.Copy(inpipe, channel); err != nil {
 		err = fmt.Errorf("Failed to write git objects into the git pre-receive hook (%s)", err)
-		log.Warnf(c, err.Error())
-		return nil, err
+		return err
 	}
 
 	fmt.Println("Waiting for git-receive to run.")
 	fmt.Println("Waiting for deploy.")
 	if err := cmd.Wait(); err != nil {
 		err = fmt.Errorf("Failed to run git pre-receive hook: %s (%s)", errbuff.Bytes(), err)
-		log.Errf(c, err.Error())
-		return nil, err
+		return err
 	}
 	if errbuff.Len() > 0 {
-		log.Warnf(c, "Unreported error: %s", errbuff.Bytes())
+		log.Err("Unreported error: %s", errbuff.Bytes())
+		return errors.New(errbuff.String())
 	}
-	log.Infof(c, "Deploy complete.\n")
+	log.Info("Deploy complete.")
 
-	return nil, nil
-}
-
-// cleanRepoName cleans a repository name for a git-sh operation.
-func cleanRepoName(name string) (string, error) {
-	if len(name) == 0 {
-		return name, errors.New("Empty repo name.")
-	}
-	if strings.Contains(name, "..") {
-		return "", errors.New("Cannot change directory in file name.")
-	}
-	name = strings.Replace(name, "'", "", -1)
-	return strings.TrimPrefix(strings.TrimSuffix(name, ".git"), "/"), nil
+	return nil
 }
 
 var createLock sync.Mutex
@@ -169,26 +126,26 @@ var createLock sync.Mutex
 //
 // Returns a bool indicating whether a project was created (true) or already
 // existed (false).
-func createRepo(c cookoo.Context, repoPath string) (bool, error) {
+func createRepo(repoPath string) (bool, error) {
 	createLock.Lock()
 	defer createLock.Unlock()
 
 	fi, err := os.Stat(repoPath)
 	if err == nil && fi.IsDir() {
 		// Nothing to do.
-		log.Infof(c, "Directory %s already exists.", repoPath)
+		log.Debug("Directory %s already exists.", repoPath)
 		return false, nil
 	} else if os.IsNotExist(err) {
-		log.Infof(c, "Creating new directory at %s", repoPath)
+		log.Debug("Creating new directory at %s", repoPath)
 		// Create directory
 		if err := os.MkdirAll(repoPath, 0755); err != nil {
-			log.Warnf(c, "Failed to create repository: %s", err)
+			log.Err("Failed to create repository: %s", err)
 			return false, err
 		}
 		cmd := exec.Command("git", "init", "--bare")
 		cmd.Dir = repoPath
 		if out, err := cmd.CombinedOutput(); err != nil {
-			log.Warnf(c, "git init output: %s", out)
+			log.Info("git init output: %s", out)
 			return false, err
 		}
 
@@ -200,27 +157,17 @@ func createRepo(c cookoo.Context, repoPath string) (bool, error) {
 }
 
 // createPreReceiveHook renders preReceiveHookTpl to repoPath/hooks/pre-receive
-func createPreReceiveHook(c cookoo.Context, gitHome, repoPath string) error {
+func createPreReceiveHook(gitHome, repoPath string) error {
 	// parse & generate the template anew each receive for each new git home
 	var hookByteBuf bytes.Buffer
 	if err := preReceiveHookTpl.Execute(&hookByteBuf, map[string]string{"GitHome": gitHome}); err != nil {
 		return err
 	}
 
 	writePath := filepath.Join(repoPath, "hooks", "pre-receive")
-	log.Debugf(c, "Writing pre-receive hook to %s", writePath)
+	log.Info("Writing pre-receive hook to %s", writePath)
 	if err := ioutil.WriteFile(writePath, hookByteBuf.Bytes(), 0755); err != nil {
 		return fmt.Errorf("Cannot write pre-receive hook to %s (%s)", writePath, err)
 	}
 	return nil
 }
-
-// checkIfAllowed verifies if an application is contained in a list of allowed applications
-func checkIfAllowed(app string, validApps []string) bool {
-	for _, validApp := range validApps {
-		if validApp == app {
-			return true
-		}
-	}
-	return false
-}