WIP(builder): seperate code for various types of builders

Author: smothiki

Makefile

@@ -36,6 +36,18 @@ build:
 	mkdir -p ${BINDIR}/bin
 	docker run --rm -v ${PWD}:/app -w /app golang:1.5.1 make docker-compile
 
+build-bpb:
+	GOOS=linux GOARCH=amd64 CGO_ENABLED=0 godep go build -a -installsuffix cgo -ldflags '-s' -o $(BINARY_DEST_DIR)/builder cli/builder.go || exit 1
+	GOOS=linux GOARCH=amd64 CGO_ENABLED=0 godep go build -a -installsuffix cgo -ldflags '-s' -o $(BINARY_DEST_DIR)/fetcher fetcher/fetcher.go || exit 1
+	@$(call check-static-binary,$(BINARY_DEST_DIR)/builder)
+	@$(call check-static-binary,$(BINARY_DEST_DIR)/fetcher)
+	for i in $(BINARIES); do \
+		GOOS=linux GOARCH=amd64 CGO_ENABLED=0 godep go build -a -installsuffix cgo -ldflags '-s' -o $(BINARY_DEST_DIR)/$$i src/$$i.go || exit 1; \
+	done
+	@for i in $(BINARIES); do \
+		$(call check-static-binary,$(BINARY_DEST_DIR)/$$i); \
+	done
+	docker build -t $(IMAGE) rootfs
 # For cases where build is run inside of a container.
 docker-compile:
 	go build -o ${BINDIR}/bin/boot -a -installsuffix cgo -ldflags ${LDFLAGS} boot.go

api/README.md

@@ -0,0 +1,40 @@
+# Deis Builder
+
+Builder creates Docker images to be run elsewhere on the Deis platform.
+Builder itself also runs in a Docker container.
+
+This Docker image is based on the official
+[alpine:3.1](https://registry.hub.docker.com/_/alpine/) image.
+
+Please add any [issues](https://github.com/deis/deis/issues) you find with this software to
+the [Deis Project](https://github.com/deis/deis).
+
+## Usage
+
+Please consult the [Makefile](Makefile) for current instructions on how to build, test, push,
+install, and start **deis/builder**.
+
+## Environment Variables
+
+* **DEBUG** enables verbose output if set
+* **ETCD_PORT** sets the TCP port on which to connect to the local etcd
+  daemon (default: *4001*)
+* **ETCD_PATH** sets the etcd directory where the builder announces
+  its configuration (default: */deis/builder*)
+* **ETCD_TTL** sets the time-to-live before etcd purges a configuration
+  value, in seconds (default: *10*)
+* **PORT** sets the TCP port on which the builder listens (default: *2222*)
+
+## License
+
+© 2015 Engine Yard, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may
+not use this file except in compliance with the License. You may obtain
+a copy of the License at <http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

api/builder.go

@@ -0,0 +1,78 @@
+// Package builder provides libraries for the Deis builder.
+//
+// The Deis builder is responsible for packaging Docker images for consumers.
+//
+// The builder/cli package contains command line clients for this library.
+package builder
+
+import (
+	"github.com/Masterminds/cookoo"
+	clog "github.com/Masterminds/cookoo/log"
+	"github.com/deis/deis/buildpack/builder/sshd"
+
+	"log"
+	"os"
+)
+
+// Return codes that will be sent to the shell.
+const (
+	StatusOk = iota
+	StatusLocalError
+)
+
+// Run starts the Builder service.
+//
+// The Builder service is responsible for setting up the local container
+// environment and then listening for new builds. The main listening service
+// is SSH. Builder listens for new Git commands and then sends those on to
+// Git.
+//
+// Run returns on of the Status* status code constants.
+func Run(cmd string) 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)
+		return StatusLocalError
+	}
+
+	// Set up the SSH service.
+	ip := os.Getenv("SSH_HOST_IP")
+	if ip == "" {
+		ip = "0.0.0.0"
+	}
+	port := os.Getenv("SSH_HOST_PORT")
+	if port == "" {
+		port = "2223"
+	}
+
+	cxt.Put(sshd.Address, ip+":"+port)
+
+	// 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, cxt); err != nil {
+		clog.Errf(cxt, "SSH server failed: %s", err)
+		return StatusLocalError
+	}
+
+	return StatusOk
+}

api/cli/README.md

@@ -0,0 +1,3 @@
+# The Deis Builder CLI
+
+This code is built by `make` and installed into the `rootfs`.

api/cli/builder.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"os"
+	"runtime"
+
+	"github.com/deis/deis/buildpack/builder"
+)
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	os.Exit(builder.Run("boot"))
+}

api/commands.go

@@ -0,0 +1,57 @@
+package builder
+
+import (
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/Masterminds/cookoo"
+	"github.com/Masterminds/cookoo/log"
+	"github.com/Masterminds/cookoo/safely"
+)
+
+// Sleep delays the execution of the remainder of the chain of commands.
+//
+// Params:
+// 	-duration (time.Duration): Time to sleep.
+//  -message (string): The message to log when entering sleep.
+func Sleep(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	dur := p.Get("duration", 10*time.Millisecond).(time.Duration)
+	msg := p.Get("messages", "Sleeping").(string)
+	log.Info(c, msg)
+	time.Sleep(dur)
+	log.Info(c, "Woke up.")
+	return true, nil
+}
+
+// KillOnExit kills PIDs when the program exits.
+//
+// Otherwise, this blocks until an os.Interrupt or os.Kill is received.
+//
+// Params:
+//  This treats Params as a map of process names (unimportant) to PIDs. It then
+// attempts to kill all of the pids that it receives.
+func KillOnExit(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, os.Interrupt, os.Kill)
+
+	safely.GoDo(c, func() {
+		log.Info(c, "Builder is running.")
+
+		<-sigs
+
+		c.Log("info", "Builder received signal to stop.")
+		pids := p.AsMap()
+		killed := 0
+		for name, pid := range pids {
+			if pid, ok := pid.(int); ok {
+				if proc, err := os.FindProcess(pid); err == nil {
+					log.Infof(c, "Killing %s (pid=%d)", name, pid)
+					proc.Kill()
+					killed++
+				}
+			}
+		}
+	})
+	return nil, nil
+}

api/commands_test.go

@@ -0,0 +1,26 @@
+package builder
+
+import (
+	"testing"
+	"time"
+
+	"github.com/Masterminds/cookoo"
+)
+
+func TestSleep(t *testing.T) {
+	reg, router, cxt := cookoo.Cookoo()
+
+	reg.Route("test", "Test route").
+		Does(Sleep, "res").Using("duration").WithDefault(3 * time.Second)
+
+	start := time.Now()
+	if err := router.HandleRequest("test", cxt, true); err != nil {
+		t.Error(err)
+	}
+
+	end := time.Now()
+	if end.Sub(start) < 3*time.Second {
+		t.Error("expected elapsed time to be 3 seconds.")
+	}
+
+}

api/confd/confd.go

@@ -0,0 +1,96 @@
+// Package confd provides basic Confd support.
+//
+// Right now, this library is highly specific to the needs of the present
+// builder. Because the confd library is not all public, we don't use it directly.
+// Instead, we invoke the CLI.
+package confd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"time"
+
+	"github.com/Masterminds/cookoo"
+	"github.com/Masterminds/cookoo/log"
+	"github.com/Masterminds/cookoo/safely"
+)
+
+// defaultEtcd is the default Etcd host.
+const defaultEtcd = "127.0.0.1:4001"
+
+// RunOnce runs the equivalent of `confd --onetime`.
+//
+// This may run the process repeatedly until either we time out (~20 minutes) or
+// the templates are successfully built.
+//
+// Importantly, this blocks until the run is complete.
+//
+// Params:
+// - node (string): The etcd node to use. (Only etcd is currently supported)
+//
+// Returns:
+// - The []bytes from stdout and stderr when running the program.
+//
+func RunOnce(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	node := p.Get("node", defaultEtcd).(string)
+
+	dargs := []string{"-onetime", "-node", node, "-log-level", "error"}
+
+	log.Info(c, "Building confd templates. This may take a moment.")
+
+	limit := 1200
+	timeout := time.Second * 3
+	var lasterr error
+	start := time.Now()
+	for i := 0; i < limit; i++ {
+		if out, err := exec.Command("confd", dargs...).CombinedOutput(); err == nil {
+			log.Infof(c, "Templates generated for %s on run %d", node, i)
+			return out, nil
+		} else {
+			log.Debugf(c, "Recoverable error: %s", err)
+			log.Debugf(c, "Output: %q", out)
+			lasterr = err
+		}
+
+		time.Sleep(timeout)
+		log.Infof(c, "Re-trying template build. (Elapsed time: %d)", time.Now().Sub(start)/time.Second)
+	}
+
+	return nil, fmt.Errorf("Could not build confd templates before timeout. Last error: %s", lasterr)
+}
+
+// Run starts confd and runs it in the background.
+//
+// If the command fails immediately on startup, an error is immediately
+// returned. But from that point, a goroutine watches the command and
+// reports if the command dies.
+//
+// Params:
+// - node (string): The etcd node to use. (Only etcd is currently supported)
+// - interval (int, default:5): The rebuilding interval.
+//
+// Returns
+//  bool true if this succeeded.
+func Run(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	node := p.Get("node", defaultEtcd).(string)
+	interval := strconv.Itoa(p.Get("interval", 5).(int))
+
+	cmd := exec.Command("confd", "-log-level", "error", "-node", node, "-interval", interval)
+	if err := cmd.Start(); err != nil {
+		return false, err
+	}
+
+	log.Infof(c, "Watching confd.")
+	safely.Go(func() {
+		if err := cmd.Wait(); err != nil {
+			// If confd exits, builder will stop functioning as intended. So
+			// we stop builder and let the environment restart.
+			log.Errf(c, "Stopping builder. confd exited with error: %s", err)
+			os.Exit(37)
+		}
+	})
+
+	return true, nil
+}

api/confd/confd_test.go

@@ -0,0 +1,24 @@
+package confd
+
+import (
+	"testing"
+
+	"github.com/Masterminds/cookoo"
+)
+
+func TestRunOnce(t *testing.T) {
+	reg, _, _ := cookoo.Cookoo()
+
+	reg.Route("test", "Test route").
+		Does(RunOnce, "res").
+		Using("node").WithDefault("localhost:4001")
+}
+func TestRun(t *testing.T) {
+	reg, _, _ := cookoo.Cookoo()
+
+	reg.Route("test", "Test route").
+		Does(Run, "res").
+		Using("node").WithDefault("localhost:4001").
+		Using("interval").WithDefault(200)
+
+}