Add a Go replacement for our top-level Make wrapper

Right now this mostly just copies what Make is doing in
build/core/ninja.mk and build/core/soong.mk. The only major feature it
adds is a rotating log file with some verbose logging.

There is one major functional difference -- you cannot override random
Make variables during the Make phase anymore. The environment variable
is set, and if Make uses ?= or the equivalent, it can still use those
variables. We already made this change for Kati, which also loads all of
the same code and actually does the build, so it has been half-removed
for a while.

The only "UI" this implements is what I'll call "Make Emulation" mode --
it's expected that current command lines will continue working, and
we'll explore alternate user interfaces later.

We're still using Make as a wrapper, but all it does is call into this
single Go program, it won't even load the product configuration. Once
this is default, we can start moving individual users over to using this
directly (still in Make emulation mode), skipping the Make wrapper.

Ideas for the future:
* Generating trace files showing time spent in Make/Kati/Soong/Ninja
  (also importing ninja traces into the same stream). I had this working
  in a previous version of this patch, but removed it to keep the size
  down and focus on the current features.
* More intelligent SIGALRM handling, once we fully remove the Make
  wrapper (which hides the SIGALRM)
* Reading the experimental binary output stream from Ninja, so that we
  can always save the verbose log even if we're not printing it out to
  the console

Test: USE_SOONG_UI=true m -j blueprint_tools
Change-Id: I884327b9a8ae24499eb6c56f6e1ad26df1cfa4e4

15 files changed, 1773 insertions, 0 deletions

diff --git a/ui/build/Android.bp b/ui/build/Android.bp
new file mode 100644
index 00000000..d6da9507
--- /dev/null
+++ b/ui/build/Android.bp
@@ -0,0 +1,36 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+bootstrap_go_package {
+    name: "soong-ui-build",
+    pkgPath: "android/soong/ui/build",
+    deps: [
+        "soong-ui-logger",
+    ],
+    srcs: [
+        "build.go",
+        "config.go",
+        "context.go",
+        "environment.go",
+        "kati.go",
+        "make.go",
+        "ninja.go",
+        "signal.go",
+        "soong.go",
+        "util.go",
+    ],
+    testSrcs: [
+        "environment_test.go",
+    ],
+}
diff --git a/ui/build/build.go b/ui/build/build.go
new file mode 100644
index 00000000..506ff519
--- /dev/null
+++ b/ui/build/build.go
@@ -0,0 +1,105 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"text/template"
+)
+
+// Ensures the out directory exists, and has the proper files to prevent kati
+// from recursing into it.
+func SetupOutDir(ctx Context, config Config) {
+	ensureEmptyFileExists(ctx, filepath.Join(config.OutDir(), "Android.mk"))
+	ensureEmptyFileExists(ctx, filepath.Join(config.OutDir(), "CleanSpec.mk"))
+	ensureEmptyFileExists(ctx, filepath.Join(config.SoongOutDir(), ".soong.in_make"))
+	// The ninja_build file is used by our buildbots to understand that the output
+	// can be parsed as ninja output.
+	ensureEmptyFileExists(ctx, filepath.Join(config.OutDir(), "ninja_build"))
+}
+
+var combinedBuildNinjaTemplate = template.Must(template.New("combined").Parse(`
+builddir = {{.OutDir}}
+include {{.KatiNinjaFile}}
+include {{.SoongNinjaFile}}
+build {{.CombinedNinjaFile}}: phony {{.SoongNinjaFile}}
+`))
+
+func createCombinedBuildNinjaFile(ctx Context, config Config) {
+	file, err := os.Create(config.CombinedNinjaFile())
+	if err != nil {
+		ctx.Fatalln("Failed to create combined ninja file:", err)
+	}
+	defer file.Close()
+
+	if err := combinedBuildNinjaTemplate.Execute(file, config); err != nil {
+		ctx.Fatalln("Failed to write combined ninja file:", err)
+	}
+}
+
+const (
+	BuildNone          = iota
+	BuildProductConfig = 1 << iota
+	BuildSoong         = 1 << iota
+	BuildKati          = 1 << iota
+	BuildNinja         = 1 << iota
+	BuildAll           = BuildProductConfig | BuildSoong | BuildKati | BuildNinja
+)
+
+// Build the tree. The 'what' argument can be used to chose which components of
+// the build to run.
+func Build(ctx Context, config Config, what int) {
+	ctx.Verboseln("Starting build with args:", config.Arguments())
+	ctx.Verboseln("Environment:", config.Environment().Environ())
+
+	if inList("help", config.Arguments()) {
+		cmd := exec.CommandContext(ctx.Context, "make", "-f", "build/core/help.mk")
+		cmd.Env = config.Environment().Environ()
+		cmd.Stdout = ctx.Stdout()
+		cmd.Stderr = ctx.Stderr()
+		if err := cmd.Run(); err != nil {
+			ctx.Fatalln("Failed to run make:", err)
+		}
+		return
+	}
+
+	SetupOutDir(ctx, config)
+
+	if what&BuildProductConfig != 0 {
+		// Run make for product config
+		runMakeProductConfig(ctx, config)
+	}
+
+	if what&BuildSoong != 0 {
+		// Run Soong
+		runSoongBootstrap(ctx, config)
+		runSoong(ctx, config)
+	}
+
+	if what&BuildKati != 0 {
+		// Run ckati
+		runKati(ctx, config)
+	}
+
+	if what&BuildNinja != 0 {
+		// Write combined ninja file
+		createCombinedBuildNinjaFile(ctx, config)
+
+		// Run ninja
+		runNinja(ctx, config)
+	}
+}
diff --git a/ui/build/config.go b/ui/build/config.go
new file mode 100644
index 00000000..b0a7d7ad
--- /dev/null
+++ b/ui/build/config.go
@@ -0,0 +1,274 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+type Config struct{ *configImpl }
+
+type configImpl struct {
+	// From the environment
+	arguments []string
+	goma      bool
+	environ   *Environment
+
+	// From the arguments
+	parallel  int
+	keepGoing int
+	verbose   bool
+
+	// From the product config
+	katiArgs   []string
+	ninjaArgs  []string
+	katiSuffix string
+}
+
+func NewConfig(ctx Context, args ...string) Config {
+	ret := &configImpl{
+		environ: OsEnvironment(),
+	}
+
+	ret.environ.Unset(
+		// We're already using it
+		"USE_SOONG_UI",
+
+		// We should never use GOROOT/GOPATH from the shell environment
+		"GOROOT",
+		"GOPATH",
+
+		// These should only come from Soong, not the environment.
+		"CLANG",
+		"CLANG_CXX",
+		"CCC_CC",
+		"CCC_CXX",
+
+		// Used by the goma compiler wrapper, but should only be set by
+		// gomacc
+		"GOMACC_PATH",
+	)
+
+	// Tell python not to spam the source tree with .pyc files.
+	ret.environ.Set("PYTHONDONTWRITEBYTECODE", "1")
+
+	// Sane default matching ninja
+	ret.parallel = runtime.NumCPU() + 2
+	ret.keepGoing = 1
+
+	for _, arg := range args {
+		arg = strings.TrimSpace(arg)
+		if arg == "--make-mode" {
+			continue
+		} else if arg == "showcommands" {
+			ret.verbose = true
+			continue
+		}
+		if arg[0] == '-' {
+			var err error
+			if arg[1] == 'j' {
+				// TODO: handle space between j and number
+				// Unnecessary if used with makeparallel
+				ret.parallel, err = strconv.Atoi(arg[2:])
+			} else if arg[1] == 'k' {
+				// TODO: handle space between k and number
+				// Unnecessary if used with makeparallel
+				ret.keepGoing, err = strconv.Atoi(arg[2:])
+			} else {
+				ctx.Fatalln("Unknown option:", arg)
+			}
+			if err != nil {
+				ctx.Fatalln("Argument error:", err, arg)
+			}
+		} else {
+			ret.arguments = append(ret.arguments, arg)
+		}
+	}
+
+	return Config{ret}
+}
+
+// Lunch configures the environment for a specific product similarly to the
+// `lunch` bash function.
+func (c *configImpl) Lunch(ctx Context, product, variant string) {
+	if variant != "eng" && variant != "userdebug" && variant != "user" {
+		ctx.Fatalf("Invalid variant %q. Must be one of 'user', 'userdebug' or 'eng'", variant)
+	}
+
+	c.environ.Set("TARGET_PRODUCT", product)
+	c.environ.Set("TARGET_BUILD_VARIANT", variant)
+	c.environ.Set("TARGET_BUILD_TYPE", "release")
+	c.environ.Unset("TARGET_BUILD_APPS")
+}
+
+// Tapas configures the environment to build one or more unbundled apps,
+// similarly to the `tapas` bash function.
+func (c *configImpl) Tapas(ctx Context, apps []string, arch, variant string) {
+	if len(apps) == 0 {
+		apps = []string{"all"}
+	}
+	if variant == "" {
+		variant = "eng"
+	}
+
+	if variant != "eng" && variant != "userdebug" && variant != "user" {
+		ctx.Fatalf("Invalid variant %q. Must be one of 'user', 'userdebug' or 'eng'", variant)
+	}
+
+	var product string
+	switch arch {
+	case "armv5":
+		product = "generic_armv5"
+	case "arm", "":
+		product = "aosp_arm"
+	case "arm64":
+		product = "aosm_arm64"
+	case "mips":
+		product = "aosp_mips"
+	case "mips64":
+		product = "aosp_mips64"
+	case "x86":
+		product = "aosp_x86"
+	case "x86_64":
+		product = "aosp_x86_64"
+	default:
+		ctx.Fatalf("Invalid architecture: %q", arch)
+	}
+
+	c.environ.Set("TARGET_PRODUCT", product)
+	c.environ.Set("TARGET_BUILD_VARIANT", variant)
+	c.environ.Set("TARGET_BUILD_TYPE", "release")
+	c.environ.Set("TARGET_BUILD_APPS", strings.Join(apps, " "))
+}
+
+func (c *configImpl) Environment() *Environment {
+	return c.environ
+}
+
+func (c *configImpl) Arguments() []string {
+	return c.arguments
+}
+
+func (c *configImpl) OutDir() string {
+	if outDir, ok := c.environ.Get("OUT_DIR"); ok {
+		return outDir
+	}
+	return "out"
+}
+
+func (c *configImpl) NinjaArgs() []string {
+	return c.ninjaArgs
+}
+
+func (c *configImpl) SoongOutDir() string {
+	return filepath.Join(c.OutDir(), "soong")
+}
+
+func (c *configImpl) KatiSuffix() string {
+	if c.katiSuffix != "" {
+		return c.katiSuffix
+	}
+	panic("SetKatiSuffix has not been called")
+}
+
+func (c *configImpl) IsVerbose() bool {
+	return c.verbose
+}
+
+func (c *configImpl) TargetProduct() string {
+	if v, ok := c.environ.Get("TARGET_PRODUCT"); ok {
+		return v
+	}
+	panic("TARGET_PRODUCT is not defined")
+}
+
+func (c *configImpl) KatiArgs() []string {
+	return c.katiArgs
+}
+
+func (c *configImpl) Parallel() int {
+	return c.parallel
+}
+
+func (c *configImpl) UseGoma() bool {
+	if v, ok := c.environ.Get("USE_GOMA"); ok {
+		v = strings.TrimSpace(v)
+		if v != "" && v != "false" {
+			return true
+		}
+	}
+	return false
+}
+
+// RemoteParallel controls how many remote jobs (i.e., commands which contain
+// gomacc) are run in parallel.  Note the paralleism of all other jobs is
+// still limited by Parallel()
+func (c *configImpl) RemoteParallel() int {
+	if v, ok := c.environ.Get("NINJA_REMOTE_NUM_JOBS"); ok {
+		if i, err := strconv.Atoi(v); err == nil {
+			return i
+		}
+	}
+	return 500
+}
+
+func (c *configImpl) SetKatiArgs(args []string) {
+	c.katiArgs = args
+}
+
+func (c *configImpl) SetNinjaArgs(args []string) {
+	c.ninjaArgs = args
+}
+
+func (c *configImpl) SetKatiSuffix(suffix string) {
+	c.katiSuffix = suffix
+}
+
+func (c *configImpl) KatiEnvFile() string {
+	return filepath.Join(c.OutDir(), "env"+c.KatiSuffix()+".sh")
+}
+
+func (c *configImpl) KatiNinjaFile() string {
+	return filepath.Join(c.OutDir(), "build"+c.KatiSuffix()+".ninja")
+}
+
+func (c *configImpl) SoongNinjaFile() string {
+	return filepath.Join(c.SoongOutDir(), "build.ninja")
+}
+
+func (c *configImpl) CombinedNinjaFile() string {
+	return filepath.Join(c.OutDir(), "combined"+c.KatiSuffix()+".ninja")
+}
+
+func (c *configImpl) SoongAndroidMk() string {
+	return filepath.Join(c.SoongOutDir(), "Android-"+c.TargetProduct()+".mk")
+}
+
+func (c *configImpl) SoongMakeVarsMk() string {
+	return filepath.Join(c.SoongOutDir(), "make_vars-"+c.TargetProduct()+".mk")
+}
+
+func (c *configImpl) HostPrebuiltTag() string {
+	if runtime.GOOS == "linux" {
+		return "linux-x86"
+	} else if runtime.GOOS == "darwin" {
+		return "darwin-x86"
+	} else {
+		panic("Unsupported OS")
+	}
+}
diff --git a/ui/build/context.go b/ui/build/context.go
new file mode 100644
index 00000000..59474f53
--- /dev/null
+++ b/ui/build/context.go
@@ -0,0 +1,64 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"context"
+	"io"
+	"os"
+
+	"android/soong/ui/logger"
+)
+
+type StdioInterface interface {
+	Stdin() io.Reader
+	Stdout() io.Writer
+	Stderr() io.Writer
+}
+
+type StdioImpl struct{}
+
+func (StdioImpl) Stdin() io.Reader  { return os.Stdin }
+func (StdioImpl) Stdout() io.Writer { return os.Stdout }
+func (StdioImpl) Stderr() io.Writer { return os.Stderr }
+
+var _ StdioInterface = StdioImpl{}
+
+type customStdio struct {
+	stdin  io.Reader
+	stdout io.Writer
+	stderr io.Writer
+}
+
+func NewCustomStdio(stdin io.Reader, stdout, stderr io.Writer) StdioInterface {
+	return customStdio{stdin, stdout, stderr}
+}
+
+func (c customStdio) Stdin() io.Reader  { return c.stdin }
+func (c customStdio) Stdout() io.Writer { return c.stdout }
+func (c customStdio) Stderr() io.Writer { return c.stderr }
+
+var _ StdioInterface = customStdio{}
+
+// Context combines a context.Context, logger.Logger, and StdIO redirection.
+// These all are agnostic of the current build, and may be used for multiple
+// builds, while the Config objects contain per-build information.
+type Context *ContextImpl
+type ContextImpl struct {
+	context.Context
+	logger.Logger
+
+	StdioInterface
+}
diff --git a/ui/build/environment.go b/ui/build/environment.go
new file mode 100644
index 00000000..baab101b
--- /dev/null
+++ b/ui/build/environment.go
@@ -0,0 +1,152 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+// Environment adds a number of useful manipulation functions to the list of
+// strings returned by os.Environ() and used in exec.Cmd.Env.
+type Environment []string
+
+// OsEnvironment wraps the current environment returned by os.Environ()
+func OsEnvironment() *Environment {
+	env := Environment(os.Environ())
+	return &env
+}
+
+// Get returns the value associated with the key, and whether it exists.
+// It's equivalent to the os.LookupEnv function, but with this copy of the
+// Environment.
+func (e *Environment) Get(key string) (string, bool) {
+	for _, env := range *e {
+		if k, v, ok := decodeKeyValue(env); ok && k == key {
+			return v, true
+		}
+	}
+	return "", false
+}
+
+// Set sets the value associated with the key, overwriting the current value
+// if it exists.
+func (e *Environment) Set(key, value string) {
+	e.Unset(key)
+	*e = append(*e, key+"="+value)
+}
+
+// Unset removes the specified keys from the Environment.
+func (e *Environment) Unset(keys ...string) {
+	out := (*e)[:0]
+	for _, env := range *e {
+		if key, _, ok := decodeKeyValue(env); ok && inList(key, keys) {
+			continue
+		}
+		out = append(out, env)
+	}
+	*e = out
+}
+
+// Environ returns the []string required for exec.Cmd.Env
+func (e *Environment) Environ() []string {
+	return []string(*e)
+}
+
+// Copy returns a copy of the Environment so that independent changes may be made.
+func (e *Environment) Copy() *Environment {
+	ret := Environment(make([]string, len(*e)))
+	for i, v := range *e {
+		ret[i] = v
+	}
+	return &ret
+}
+
+// IsTrue returns whether an environment variable is set to a positive value (1,y,yes,on,true)
+func (e *Environment) IsEnvTrue(key string) bool {
+	if value, ok := e.Get(key); ok {
+		return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
+	}
+	return false
+}
+
+// IsFalse returns whether an environment variable is set to a negative value (0,n,no,off,false)
+func (e *Environment) IsFalse(key string) bool {
+	if value, ok := e.Get(key); ok {
+		return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
+	}
+	return false
+}
+
+// AppendFromKati reads a shell script written by Kati that exports or unsets
+// environment variables, and applies those to the local Environment.
+func (e *Environment) AppendFromKati(filename string) error {
+	file, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	return e.appendFromKati(file)
+}
+
+func (e *Environment) appendFromKati(reader io.Reader) error {
+	scanner := bufio.NewScanner(reader)
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+
+		if len(text) == 0 || text[0] == '#' {
+			continue
+		}
+
+		cmd := strings.SplitN(text, " ", 2)
+		if len(cmd) != 2 {
+			return fmt.Errorf("Unknown kati environment line: %q", text)
+		}
+
+		if cmd[0] == "unset" {
+			str, ok := singleUnquote(cmd[1])
+			if !ok {
+				fmt.Errorf("Failed to unquote kati line: %q", text)
+			}
+			e.Unset(str)
+		} else if cmd[0] == "export" {
+			key, value, ok := decodeKeyValue(cmd[1])
+			if !ok {
+				return fmt.Errorf("Failed to parse export: %v", cmd)
+			}
+
+			key, ok = singleUnquote(key)
+			if !ok {
+				return fmt.Errorf("Failed to unquote kati line: %q", text)
+			}
+			value, ok = singleUnquote(value)
+			if !ok {
+				return fmt.Errorf("Failed to unquote kati line: %q", text)
+			}
+
+			e.Set(key, value)
+		} else {
+			return fmt.Errorf("Unknown kati environment command: %q", text)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/ui/build/environment_test.go b/ui/build/environment_test.go
new file mode 100644
index 00000000..0294dac4
--- /dev/null
+++ b/ui/build/environment_test.go
@@ -0,0 +1,80 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestEnvUnset(t *testing.T) {
+	initial := &Environment{"TEST=1", "TEST2=0"}
+	initial.Unset("TEST")
+	got := initial.Environ()
+	if len(got) != 1 || got[0] != "TEST2=0" {
+		t.Errorf("Expected [TEST2=0], got: %v", got)
+	}
+}
+
+func TestEnvUnsetMissing(t *testing.T) {
+	initial := &Environment{"TEST2=0"}
+	initial.Unset("TEST")
+	got := initial.Environ()
+	if len(got) != 1 || got[0] != "TEST2=0" {
+		t.Errorf("Expected [TEST2=0], got: %v", got)
+	}
+}
+
+func TestEnvSet(t *testing.T) {
+	initial := &Environment{}
+	initial.Set("TEST", "0")
+	got := initial.Environ()
+	if len(got) != 1 || got[0] != "TEST=0" {
+		t.Errorf("Expected [TEST=0], got: %v", got)
+	}
+}
+
+func TestEnvSetDup(t *testing.T) {
+	initial := &Environment{"TEST=1"}
+	initial.Set("TEST", "0")
+	got := initial.Environ()
+	if len(got) != 1 || got[0] != "TEST=0" {
+		t.Errorf("Expected [TEST=0], got: %v", got)
+	}
+}
+
+const testKatiEnvFileContents = `#!/bin/sh
+# Generated by kati unknown
+
+unset 'CLANG'
+export 'BUILD_ID'='NYC'
+`
+
+func TestEnvAppendFromKati(t *testing.T) {
+	initial := &Environment{"CLANG=/usr/bin/clang", "TEST=0"}
+	err := initial.appendFromKati(strings.NewReader(testKatiEnvFileContents))
+	if err != nil {
+		t.Fatalf("Unexpected error from %v", err)
+	}
+
+	got := initial.Environ()
+	expected := []string{"TEST=0", "BUILD_ID=NYC"}
+	if !reflect.DeepEqual(got, expected) {
+		t.Errorf("Environment list does not match")
+		t.Errorf("expected: %v", expected)
+		t.Errorf("     got: %v", got)
+	}
+}
diff --git a/ui/build/kati.go b/ui/build/kati.go
new file mode 100644
index 00000000..6997fbec
--- /dev/null
+++ b/ui/build/kati.go
@@ -0,0 +1,104 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io/ioutil"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+var spaceSlashReplacer = strings.NewReplacer("/", "_", " ", "_")
+
+// genKatiSuffix creates a suffix for kati-generated files so that we can cache
+// them based on their inputs. So this should encode all common changes to Kati
+// inputs. Currently that includes the TARGET_PRODUCT, kati-processed command
+// line arguments, and the directories specified by mm/mmm.
+func genKatiSuffix(ctx Context, config Config) {
+	katiSuffix := "-" + config.TargetProduct()
+	if args := config.KatiArgs(); len(args) > 0 {
+		katiSuffix += "-" + spaceSlashReplacer.Replace(strings.Join(args, "_"))
+	}
+	if oneShot, ok := config.Environment().Get("ONE_SHOT_MAKEFILE"); ok {
+		katiSuffix += "-" + spaceSlashReplacer.Replace(oneShot)
+	}
+
+	// If the suffix is too long, replace it with a md5 hash and write a
+	// file that contains the original suffix.
+	if len(katiSuffix) > 64 {
+		shortSuffix := "-" + fmt.Sprintf("%x", md5.Sum([]byte(katiSuffix)))
+		config.SetKatiSuffix(shortSuffix)
+
+		ctx.Verbosef("Kati ninja suffix too long: %q", katiSuffix)
+		ctx.Verbosef("Replacing with: %q", shortSuffix)
+
+		if err := ioutil.WriteFile(strings.TrimSuffix(config.KatiNinjaFile(), "ninja")+"suf", []byte(katiSuffix), 0777); err != nil {
+			ctx.Println("Error writing suffix file:", err)
+		}
+	} else {
+		config.SetKatiSuffix(katiSuffix)
+	}
+}
+
+func runKati(ctx Context, config Config) {
+	genKatiSuffix(ctx, config)
+
+	executable := "prebuilts/build-tools/" + config.HostPrebuiltTag() + "/bin/ckati"
+	args := []string{
+		"--ninja",
+		"--ninja_dir=" + config.OutDir(),
+		"--ninja_suffix=" + config.KatiSuffix(),
+		"--regen",
+		"--ignore_optional_include=" + filepath.Join(config.OutDir(), "%.P"),
+		"--detect_android_echo",
+	}
+
+	if !config.Environment().IsFalse("KATI_EMULATE_FIND") {
+		args = append(args, "--use_find_emulator")
+	}
+
+	// The argument order could be simplified, but currently this matches
+	// the ordering in Make
+	args = append(args, "-f", "build/core/main.mk")
+
+	args = append(args, config.KatiArgs()...)
+
+	args = append(args,
+		"--gen_all_targets",
+		"BUILDING_WITH_NINJA=true",
+		"SOONG_ANDROID_MK="+config.SoongAndroidMk(),
+		"SOONG_MAKEVARS_MK="+config.SoongMakeVarsMk())
+
+	if config.UseGoma() {
+		args = append(args, "-j"+strconv.Itoa(config.Parallel()))
+	}
+
+	cmd := exec.CommandContext(ctx.Context, executable, args...)
+	cmd.Env = config.Environment().Environ()
+	cmd.Stdout = ctx.Stdout()
+	cmd.Stderr = ctx.Stderr()
+	ctx.Verboseln(cmd.Path, cmd.Args)
+	if err := cmd.Run(); err != nil {
+		if e, ok := err.(*exec.ExitError); ok {
+			ctx.Fatalln("ckati failed with:", e.ProcessState.String())
+		} else {
+			ctx.Fatalln("Failed to run ckati:", err)
+		}
+	}
+}
diff --git a/ui/build/make.go b/ui/build/make.go
new file mode 100644
index 00000000..58805095
--- /dev/null
+++ b/ui/build/make.go
@@ -0,0 +1,160 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// DumpMakeVars can be used to extract the values of Make variables after the
+// product configurations are loaded. This is roughly equivalent to the
+// `get_build_var` bash function.
+//
+// goals can be used to set MAKECMDGOALS, which emulates passing arguments to
+// Make without actually building them. So all the variables based on
+// MAKECMDGOALS can be read.
+//
+// extra_targets adds real arguments to the make command, in case other targets
+// actually need to be run (like the Soong config generator).
+//
+// vars is the list of variables to read. The values will be put in the
+// returned map.
+func DumpMakeVars(ctx Context, config Config, goals, extra_targets, vars []string) (map[string]string, error) {
+	cmd := exec.CommandContext(ctx.Context,
+		"make",
+		"--no-print-directory",
+		"-f", "build/core/config.mk",
+		"dump-many-vars",
+		"CALLED_FROM_SETUP=true",
+		"BUILD_SYSTEM=build/core",
+		"MAKECMDGOALS="+strings.Join(goals, " "),
+		"DUMP_MANY_VARS="+strings.Join(vars, " "),
+		"OUT_DIR="+config.OutDir())
+	cmd.Env = config.Environment().Environ()
+	cmd.Args = append(cmd.Args, extra_targets...)
+	// TODO: error out when Stderr contains any content
+	cmd.Stderr = ctx.Stderr()
+	ctx.Verboseln(cmd.Path, cmd.Args)
+	output, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make(map[string]string, len(vars))
+	for _, line := range strings.Split(string(output), "\n") {
+		if len(line) == 0 {
+			continue
+		}
+
+		if key, value, ok := decodeKeyValue(line); ok {
+			if value, ok = singleUnquote(value); ok {
+				ret[key] = value
+				ctx.Verboseln(key, value)
+			} else {
+				return nil, fmt.Errorf("Failed to parse make line: %q", line)
+			}
+		} else {
+			return nil, fmt.Errorf("Failed to parse make line: %q", line)
+		}
+	}
+
+	return ret, nil
+}
+
+func runMakeProductConfig(ctx Context, config Config) {
+	// Variables to export into the environment of Kati/Ninja
+	exportEnvVars := []string{
+		// So that we can use the correct TARGET_PRODUCT if it's been
+		// modified by PRODUCT-* arguments
+		"TARGET_PRODUCT",
+
+		// compiler wrappers set up by make
+		"CC_WRAPPER",
+		"CXX_WRAPPER",
+
+		// ccache settings
+		"CCACHE_COMPILERCHECK",
+		"CCACHE_SLOPPINESS",
+		"CCACHE_BASEDIR",
+		"CCACHE_CPP2",
+	}
+
+	// Variables to print out in the top banner
+	bannerVars := []string{
+		"PLATFORM_VERSION_CODENAME",
+		"PLATFORM_VERSION",
+		"TARGET_PRODUCT",
+		"TARGET_BUILD_VARIANT",
+		"TARGET_BUILD_TYPE",
+		"TARGET_BUILD_APPS",
+		"TARGET_ARCH",
+		"TARGET_ARCH_VARIANT",
+		"TARGET_CPU_VARIANT",
+		"TARGET_2ND_ARCH",
+		"TARGET_2ND_ARCH_VARIANT",
+		"TARGET_2ND_CPU_VARIANT",
+		"HOST_ARCH",
+		"HOST_2ND_ARCH",
+		"HOST_OS",
+		"HOST_OS_EXTRA",
+		"HOST_CROSS_OS",
+		"HOST_CROSS_ARCH",
+		"HOST_CROSS_2ND_ARCH",
+		"HOST_BUILD_TYPE",
+		"BUILD_ID",
+		"OUT_DIR",
+		"AUX_OS_VARIANT_LIST",
+		"TARGET_BUILD_PDK",
+		"PDK_FUSION_PLATFORM_ZIP",
+	}
+
+	allVars := append(append([]string{
+		// Used to execute Kati and Ninja
+		"NINJA_GOALS",
+		"KATI_GOALS",
+	}, exportEnvVars...), bannerVars...)
+
+	make_vars, err := DumpMakeVars(ctx, config, config.Arguments(), []string{
+		filepath.Join(config.SoongOutDir(), "soong.variables"),
+	}, allVars)
+	if err != nil {
+		ctx.Fatalln("Error dumping make vars:", err)
+	}
+
+	// Print the banner like make does
+	fmt.Fprintln(ctx.Stdout(), "============================================")
+	for _, name := range bannerVars {
+		if make_vars[name] != "" {
+			fmt.Fprintf(ctx.Stdout(), "%s=%s\n", name, make_vars[name])
+		}
+	}
+	fmt.Fprintln(ctx.Stdout(), "============================================")
+
+	// Populate the environment
+	env := config.Environment()
+	for _, name := range exportEnvVars {
+		if make_vars[name] == "" {
+			env.Unset(name)
+		} else {
+			env.Set(name, make_vars[name])
+		}
+	}
+
+	config.SetKatiArgs(strings.Fields(make_vars["KATI_GOALS"]))
+	config.SetNinjaArgs(strings.Fields(make_vars["NINJA_GOALS"]))
+}
diff --git a/ui/build/ninja.go b/ui/build/ninja.go
new file mode 100644
index 00000000..13e1834c
--- /dev/null
+++ b/ui/build/ninja.go
@@ -0,0 +1,78 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+func runNinja(ctx Context, config Config) {
+	executable := "prebuilts/build-tools/" + config.HostPrebuiltTag() + "/bin/ninja"
+	args := []string{
+		"-d", "keepdepfile",
+	}
+
+	args = append(args, config.NinjaArgs()...)
+
+	var parallel int
+	if config.UseGoma() {
+		parallel = config.RemoteParallel()
+	} else {
+		parallel = config.Parallel()
+	}
+	args = append(args, "-j", strconv.Itoa(parallel))
+	if config.keepGoing != 1 {
+		args = append(args, "-k", strconv.Itoa(config.keepGoing))
+	}
+
+	args = append(args, "-f", config.CombinedNinjaFile())
+
+	if config.IsVerbose() {
+		args = append(args, "-v")
+	}
+	args = append(args, "-w", "dupbuild=err")
+
+	env := config.Environment().Copy()
+	env.AppendFromKati(config.KatiEnvFile())
+
+	// Allow both NINJA_ARGS and NINJA_EXTRA_ARGS, since both have been
+	// used in the past to specify extra ninja arguments.
+	if extra, ok := env.Get("NINJA_ARGS"); ok {
+		args = append(args, strings.Fields(extra)...)
+	}
+	if extra, ok := env.Get("NINJA_EXTRA_ARGS"); ok {
+		args = append(args, strings.Fields(extra)...)
+	}
+
+	if _, ok := env.Get("NINJA_STATUS"); !ok {
+		env.Set("NINJA_STATUS", "[%p %f/%t] ")
+	}
+
+	cmd := exec.CommandContext(ctx.Context, executable, args...)
+	cmd.Env = env.Environ()
+	cmd.Stdin = ctx.Stdin()
+	cmd.Stdout = ctx.Stdout()
+	cmd.Stderr = ctx.Stderr()
+	ctx.Verboseln(cmd.Path, cmd.Args)
+	if err := cmd.Run(); err != nil {
+		if e, ok := err.(*exec.ExitError); ok {
+			ctx.Fatalln("ninja failed with:", e.ProcessState.String())
+		} else {
+			ctx.Fatalln("Failed to run ninja:", err)
+		}
+	}
+}
diff --git a/ui/build/signal.go b/ui/build/signal.go
new file mode 100644
index 00000000..3c8c8e11
--- /dev/null
+++ b/ui/build/signal.go
@@ -0,0 +1,60 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"os"
+	"os/signal"
+	"runtime/debug"
+	"syscall"
+
+	"android/soong/ui/logger"
+)
+
+// SetupSignals sets up signal handling to kill our children and allow us to cleanly finish
+// writing our log/trace files.
+//
+// Currently, on the first SIGINT|SIGALARM we call the cancel() function, which is usually
+// the CancelFunc returned by context.WithCancel, which will kill all the commands running
+// within that Context. Usually that's enough, and you'll run through your normal error paths.
+//
+// If another signal comes in after the first one, we'll trigger a panic with full stacktraces
+// from every goroutine so that it's possible to debug what is stuck. Just before the process
+// exits, we'll call the cleanup() function so that you can flush your log files.
+func SetupSignals(log logger.Logger, cancel, cleanup func()) {
+	signals := make(chan os.Signal, 5)
+	// TODO: Handle other signals
+	signal.Notify(signals, os.Interrupt, syscall.SIGALRM)
+	go handleSignals(signals, log, cancel, cleanup)
+}
+
+func handleSignals(signals chan os.Signal, log logger.Logger, cancel, cleanup func()) {
+	defer cleanup()
+
+	var force bool
+
+	for {
+		s := <-signals
+		if force {
+			// So that we can better see what was stuck
+			debug.SetTraceback("all")
+			log.Panicln("Second signal received:", s)
+		} else {
+			log.Println("Got signal:", s)
+			cancel()
+			force = true
+		}
+	}
+}
diff --git a/ui/build/soong.go b/ui/build/soong.go
new file mode 100644
index 00000000..88e4161c
--- /dev/null
+++ b/ui/build/soong.go
@@ -0,0 +1,57 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"os/exec"
+	"path/filepath"
+)
+
+func runSoongBootstrap(ctx Context, config Config) {
+	cmd := exec.CommandContext(ctx.Context, "./bootstrap.bash")
+	env := config.Environment().Copy()
+	env.Set("BUILDDIR", config.SoongOutDir())
+	cmd.Env = env.Environ()
+	cmd.Stdout = ctx.Stdout()
+	cmd.Stderr = ctx.Stderr()
+	ctx.Verboseln(cmd.Path, cmd.Args)
+	if err := cmd.Run(); err != nil {
+		if e, ok := err.(*exec.ExitError); ok {
+			ctx.Fatalln("soong bootstrap failed with:", e.ProcessState.String())
+		} else {
+			ctx.Fatalln("Failed to run soong bootstrap:", err)
+		}
+	}
+}
+
+func runSoong(ctx Context, config Config) {
+	cmd := exec.CommandContext(ctx.Context, filepath.Join(config.SoongOutDir(), "soong"), "-w", "dupbuild=err")
+	if config.IsVerbose() {
+		cmd.Args = append(cmd.Args, "-v")
+	}
+	env := config.Environment().Copy()
+	env.Set("SKIP_NINJA", "true")
+	cmd.Env = env.Environ()
+	cmd.Stdout = ctx.Stdout()
+	cmd.Stderr = ctx.Stderr()
+	ctx.Verboseln(cmd.Path, cmd.Args)
+	if err := cmd.Run(); err != nil {
+		if e, ok := err.(*exec.ExitError); ok {
+			ctx.Fatalln("soong bootstrap failed with:", e.ProcessState.String())
+		} else {
+			ctx.Fatalln("Failed to run soong bootstrap:", err)
+		}
+	}
+}
diff --git a/ui/build/util.go b/ui/build/util.go
new file mode 100644
index 00000000..ad084da6
--- /dev/null
+++ b/ui/build/util.go
@@ -0,0 +1,79 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package build
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// indexList finds the index of a string in a []string
+func indexList(s string, list []string) int {
+	for i, l := range list {
+		if l == s {
+			return i
+		}
+	}
+
+	return -1
+}
+
+// inList determines whether a string is in a []string
+func inList(s string, list []string) bool {
+	return indexList(s, list) != -1
+}
+
+// ensureDirectoriesExist is a shortcut to os.MkdirAll, sending errors to the ctx logger.
+func ensureDirectoriesExist(ctx Context, dirs ...string) {
+	for _, dir := range dirs {
+		err := os.MkdirAll(dir, 0777)
+		if err != nil {
+			ctx.Fatalf("Error creating %s: %q\n", dir, err)
+		}
+	}
+}
+
+// ensureEmptyFileExists ensures that the containing directory exists, and the
+// specified file exists. If it doesn't exist, it will write an empty file.
+func ensureEmptyFileExists(ctx Context, file string) {
+	ensureDirectoriesExist(ctx, filepath.Dir(file))
+	if _, err := os.Stat(file); os.IsNotExist(err) {
+		f, err := os.Create(file)
+		if err != nil {
+			ctx.Fatalf("Error creating %s: %q\n", file, err)
+		}
+		f.Close()
+	} else if err != nil {
+		ctx.Fatalf("Error checking %s: %q\n", file, err)
+	}
+}
+
+// singleUnquote is similar to strconv.Unquote, but can handle multi-character strings inside single quotes.
+func singleUnquote(str string) (string, bool) {
+	if len(str) < 2 || str[0] != '\'' || str[len(str)-1] != '\'' {
+		return "", false
+	}
+	return str[1 : len(str)-1], true
+}
+
+// decodeKeyValue decodes a key=value string
+func decodeKeyValue(str string) (string, string, bool) {
+	idx := strings.IndexRune(str, '=')
+	if idx == -1 {
+		return "", "", false
+	}
+	return str[:idx], str[idx+1:], true
+}
diff --git a/ui/logger/Android.bp b/ui/logger/Android.bp
new file mode 100644
index 00000000..8091ef92
--- /dev/null
+++ b/ui/logger/Android.bp
@@ -0,0 +1,24 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+bootstrap_go_package {
+    name: "soong-ui-logger",
+    pkgPath: "android/soong/ui/logger",
+    srcs: [
+        "logger.go",
+    ],
+    testSrcs: [
+        "logger_test.go",
+    ],
+}
diff --git a/ui/logger/logger.go b/ui/logger/logger.go
new file mode 100644
index 00000000..db7e82ad
--- /dev/null
+++ b/ui/logger/logger.go
@@ -0,0 +1,302 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+// Package logger implements a logging package designed for command line
+// utilities.  It uses the standard 'log' package and function, but splits
+// output between stderr and a rotating log file.
+//
+// In addition to the standard logger functions, Verbose[f|ln] calls only go to
+// the log file by default, unless SetVerbose(true) has been called.
+//
+// The log file also includes extended date/time/source information, which are
+// omitted from the stderr output for better readability.
+//
+// In order to better handle resource cleanup after a Fatal error, the Fatal
+// functions panic instead of calling os.Exit(). To actually do the cleanup,
+// and prevent the printing of the panic, call defer logger.Cleanup() at the
+// beginning of your main function.
+package logger
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+)
+
+type Logger interface {
+	// Print* prints to both stderr and the file log.
+	// Arguments to Print are handled in the manner of fmt.Print.
+	Print(v ...interface{})
+	// Arguments to Printf are handled in the manner of fmt.Printf
+	Printf(format string, v ...interface{})
+	// Arguments to Println are handled in the manner of fmt.Println
+	Println(v ...interface{})
+
+	// Verbose* is equivalent to Print*, but skips stderr unless the
+	// logger has been configured in verbose mode.
+	Verbose(v ...interface{})
+	Verbosef(format string, v ...interface{})
+	Verboseln(v ...interface{})
+
+	// Fatal* is equivalent to Print* followed by a call to panic that
+	// can be converted to an error using Recover, or will be converted
+	// to a call to os.Exit(1) with a deferred call to Cleanup()
+	Fatal(v ...interface{})
+	Fatalf(format string, v ...interface{})
+	Fatalln(v ...interface{})
+
+	// Panic is equivalent to Print* followed by a call to panic.
+	Panic(v ...interface{})
+	Panicf(format string, v ...interface{})
+	Panicln(v ...interface{})
+
+	// Output writes the string to both stderr and the file log.
+	Output(calldepth int, str string) error
+}
+
+// fatalLog is the type used when Fatal[f|ln]
+type fatalLog error
+
+func fileRotation(from, baseName, ext string, cur, max int) error {
+	newName := baseName + "." + strconv.Itoa(cur) + ext
+
+	if _, err := os.Lstat(newName); err == nil {
+		if cur+1 <= max {
+			fileRotation(newName, baseName, ext, cur+1, max)
+		}
+	}
+
+	if err := os.Rename(from, newName); err != nil {
+		return fmt.Errorf("Failed to rotate", from, "to", newName, ".", err)
+	}
+	return nil
+}
+
+// CreateFileWithRotation returns a new os.File using os.Create, renaming any
+// existing files to <filename>.#.<ext>, keeping up to maxCount files.
+// <filename>.1.<ext> is the most recent backup, <filename>.2.<ext> is the
+// second most recent backup, etc.
+//
+// TODO: This function is not guaranteed to be atomic, if there are multiple
+// users attempting to do the same operation, the result is undefined.
+func CreateFileWithRotation(filename string, maxCount int) (*os.File, error) {
+	if _, err := os.Lstat(filename); err == nil {
+		ext := filepath.Ext(filename)
+		basename := filename[:len(filename)-len(ext)]
+		if err = fileRotation(filename, basename, ext, 1, maxCount); err != nil {
+			return nil, err
+		}
+	}
+
+	return os.Create(filename)
+}
+
+// Recover can be used with defer in a GoRoutine to convert a Fatal panics to
+// an error that can be handled.
+func Recover(fn func(err error)) {
+	p := recover()
+
+	if p == nil {
+		return
+	} else if log, ok := p.(fatalLog); ok {
+		fn(error(log))
+	} else {
+		panic(p)
+	}
+}
+
+type stdLogger struct {
+	stderr  *log.Logger
+	verbose bool
+
+	fileLogger *log.Logger
+	mutex      sync.Mutex
+	file       *os.File
+}
+
+var _ Logger = &stdLogger{}
+
+// New creates a new Logger. The out variable sets the destination, commonly
+// os.Stderr, but it may be a buffer for tests, or a separate log file if
+// the user doesn't need to see the output.
+func New(out io.Writer) *stdLogger {
+	return &stdLogger{
+		stderr:     log.New(out, "", log.Ltime),
+		fileLogger: log.New(ioutil.Discard, "", log.Ldate|log.Lmicroseconds|log.Llongfile),
+	}
+}
+
+// SetVerbose controls whether Verbose[f|ln] logs to stderr as well as the
+// file-backed log.
+func (s *stdLogger) SetVerbose(v bool) {
+	s.verbose = v
+}
+
+// SetOutput controls where the file-backed log will be saved. It will keep
+// some number of backups of old log files.
+func (s *stdLogger) SetOutput(path string) {
+	if f, err := CreateFileWithRotation(path, 5); err == nil {
+		s.mutex.Lock()
+		defer s.mutex.Unlock()
+
+		if s.file != nil {
+			s.file.Close()
+		}
+		s.file = f
+		s.fileLogger.SetOutput(f)
+	} else {
+		s.Fatal(err.Error())
+	}
+}
+
+// Close disables logging to the file and closes the file handle.
+func (s *stdLogger) Close() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	if s.file != nil {
+		s.fileLogger.SetOutput(ioutil.Discard)
+		s.file.Close()
+		s.file = nil
+	}
+}
+
+// Cleanup should be used with defer in your main function. It will close the
+// log file and convert any Fatal panics back to os.Exit(1)
+func (s *stdLogger) Cleanup() {
+	fatal := false
+	p := recover()
+
+	if _, ok := p.(fatalLog); ok {
+		fatal = true
+		p = nil
+	} else if p != nil {
+		s.Println(p)
+	}
+
+	s.Close()
+
+	if p != nil {
+		panic(p)
+	} else if fatal {
+		os.Exit(1)
+	}
+}
+
+// Output writes string to both stderr and the file log.
+func (s *stdLogger) Output(calldepth int, str string) error {
+	s.stderr.Output(calldepth+1, str)
+	return s.fileLogger.Output(calldepth+1, str)
+}
+
+// VerboseOutput is equivalent to Output, but only goes to the file log
+// unless SetVerbose(true) has been called.
+func (s *stdLogger) VerboseOutput(calldepth int, str string) error {
+	if s.verbose {
+		s.stderr.Output(calldepth+1, str)
+	}
+	return s.fileLogger.Output(calldepth+1, str)
+}
+
+// Print prints to both stderr and the file log.
+// Arguments are handled in the manner of fmt.Print.
+func (s *stdLogger) Print(v ...interface{}) {
+	output := fmt.Sprint(v...)
+	s.Output(2, output)
+}
+
+// Printf prints to both stderr and the file log.
+// Arguments are handled in the manner of fmt.Printf.
+func (s *stdLogger) Printf(format string, v ...interface{}) {
+	output := fmt.Sprintf(format, v...)
+	s.Output(2, output)
+}
+
+// Println prints to both stderr and the file log.
+// Arguments are handled in the manner of fmt.Println.
+func (s *stdLogger) Println(v ...interface{}) {
+	output := fmt.Sprintln(v...)
+	s.Output(2, output)
+}
+
+// Verbose is equivalent to Print, but only goes to the file log unless
+// SetVerbose(true) has been called.
+func (s *stdLogger) Verbose(v ...interface{}) {
+	output := fmt.Sprint(v...)
+	s.VerboseOutput(2, output)
+}
+
+// Verbosef is equivalent to Printf, but only goes to the file log unless
+// SetVerbose(true) has been called.
+func (s *stdLogger) Verbosef(format string, v ...interface{}) {
+	output := fmt.Sprintf(format, v...)
+	s.VerboseOutput(2, output)
+}
+
+// Verboseln is equivalent to Println, but only goes to the file log unless
+// SetVerbose(true) has been called.
+func (s *stdLogger) Verboseln(v ...interface{}) {
+	output := fmt.Sprintln(v...)
+	s.VerboseOutput(2, output)
+}
+
+// Fatal is equivalent to Print() followed by a call to panic() that
+// Cleanup will convert to a os.Exit(1).
+func (s *stdLogger) Fatal(v ...interface{}) {
+	output := fmt.Sprint(v...)
+	s.Output(2, output)
+	panic(fatalLog(errors.New(output)))
+}
+
+// Fatalf is equivalent to Printf() followed by a call to panic() that
+// Cleanup will convert to a os.Exit(1).
+func (s *stdLogger) Fatalf(format string, v ...interface{}) {
+	output := fmt.Sprintf(format, v...)
+	s.Output(2, output)
+	panic(fatalLog(errors.New(output)))
+}
+
+// Fatalln is equivalent to Println() followed by a call to panic() that
+// Cleanup will convert to a os.Exit(1).
+func (s *stdLogger) Fatalln(v ...interface{}) {
+	output := fmt.Sprintln(v...)
+	s.Output(2, output)
+	panic(fatalLog(errors.New(output)))
+}
+
+// Panic is equivalent to Print() followed by a call to panic().
+func (s *stdLogger) Panic(v ...interface{}) {
+	output := fmt.Sprint(v...)
+	s.Output(2, output)
+	panic(output)
+}
+
+// Panicf is equivalent to Printf() followed by a call to panic().
+func (s *stdLogger) Panicf(format string, v ...interface{}) {
+	output := fmt.Sprintf(format, v...)
+	s.Output(2, output)
+	panic(output)
+}
+
+// Panicln is equivalent to Println() followed by a call to panic().
+func (s *stdLogger) Panicln(v ...interface{}) {
+	output := fmt.Sprintln(v...)
+	s.Output(2, output)
+	panic(output)
+}
diff --git a/ui/logger/logger_test.go b/ui/logger/logger_test.go
new file mode 100644
index 00000000..0f88ab37
--- /dev/null
+++ b/ui/logger/logger_test.go
@@ -0,0 +1,198 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// 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.
+
+package logger
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"syscall"
+	"testing"
+)
+
+func TestCreateFileWithRotation(t *testing.T) {
+	dir, err := ioutil.TempDir("", "test-rotation")
+	if err != nil {
+		t.Fatalf("Failed to get TempDir: %v", err)
+	}
+	defer os.RemoveAll(dir)
+
+	file := filepath.Join(dir, "build.log")
+
+	writeFile := func(name string, data string) {
+		f, err := CreateFileWithRotation(name, 3)
+		if err != nil {
+			t.Fatalf("Failed to create file: %v", err)
+		}
+		if n, err := io.WriteString(f, data); err == nil && n < len(data) {
+			t.Fatalf("Short write")
+		} else if err != nil {
+			t.Fatalf("Failed to write: %v", err)
+		}
+		if err := f.Close(); err != nil {
+			t.Fatalf("Failed to close: %v", err)
+		}
+	}
+
+	writeFile(file, "a")
+	writeFile(file, "b")
+	writeFile(file, "c")
+	writeFile(file, "d")
+	writeFile(file, "e")
+
+	d, err := os.Open(dir)
+	if err != nil {
+		t.Fatalf("Failed to open dir: %v", err)
+	}
+	names, err := d.Readdirnames(0)
+	if err != nil {
+		t.Fatalf("Failed to read dir: %v", err)
+	}
+	sort.Strings(names)
+	expected := []string{"build.1.log", "build.2.log", "build.3.log", "build.log"}
+	if !reflect.DeepEqual(names, expected) {
+		t.Errorf("File list does not match.")
+		t.Errorf("     got: %v", names)
+		t.Errorf("expected: %v", expected)
+		t.FailNow()
+	}
+
+	expectFileContents := func(name, expected string) {
+		data, err := ioutil.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Errorf("Error reading file: %v", err)
+			return
+		}
+		str := string(data)
+		if str != expected {
+			t.Errorf("Contents of %v does not match.", name)
+			t.Errorf("     got: %v", data)
+			t.Errorf("expected: %v", expected)
+		}
+	}
+
+	expectFileContents("build.log", "e")
+	expectFileContents("build.1.log", "d")
+	expectFileContents("build.2.log", "c")
+	expectFileContents("build.3.log", "b")
+}
+
+func TestPanic(t *testing.T) {
+	if os.Getenv("ACTUALLY_PANIC") == "1" {
+		panicValue := "foo"
+		log := New(&bytes.Buffer{})
+
+		defer func() {
+			p := recover()
+
+			if p == panicValue {
+				os.Exit(42)
+			} else {
+				fmt.Fprintln(os.Stderr, "Expected %q, got %v", panicValue, p)
+				os.Exit(3)
+			}
+		}()
+		defer log.Cleanup()
+
+		log.Panic(panicValue)
+		os.Exit(2)
+		return
+	}
+
+	// Run this in an external process so that we don't pollute stderr
+	cmd := exec.Command(os.Args[0], "-test.run=TestPanic")
+	cmd.Env = append(os.Environ(), "ACTUALLY_PANIC=1")
+	err := cmd.Run()
+	if e, ok := err.(*exec.ExitError); ok && e.Sys().(syscall.WaitStatus).ExitStatus() == 42 {
+		return
+	}
+	t.Errorf("Expected process to exit with status 42, got %v", err)
+}
+
+func TestFatal(t *testing.T) {
+	if os.Getenv("ACTUALLY_FATAL") == "1" {
+		log := New(&bytes.Buffer{})
+		defer func() {
+			// Shouldn't get here
+			os.Exit(3)
+		}()
+		defer log.Cleanup()
+		log.Fatal("Test")
+		os.Exit(0)
+		return
+	}
+
+	cmd := exec.Command(os.Args[0], "-test.run=TestFatal")
+	cmd.Env = append(os.Environ(), "ACTUALLY_FATAL=1")
+	err := cmd.Run()
+	if e, ok := err.(*exec.ExitError); ok && e.Sys().(syscall.WaitStatus).ExitStatus() == 1 {
+		return
+	}
+	t.Errorf("Expected process to exit with status 1, got %v", err)
+}
+
+func TestNonFatal(t *testing.T) {
+	if os.Getenv("ACTUAL_TEST") == "1" {
+		log := New(&bytes.Buffer{})
+		defer log.Cleanup()
+		log.Println("Test")
+		return
+	}
+
+	cmd := exec.Command(os.Args[0], "-test.run=TestNonFatal")
+	cmd.Env = append(os.Environ(), "ACTUAL_TEST=1")
+	err := cmd.Run()
+	if e, ok := err.(*exec.ExitError); ok || (ok && !e.Success()) {
+		t.Errorf("Expected process to exit cleanly, got %v", err)
+	}
+}
+
+func TestRecoverFatal(t *testing.T) {
+	log := New(&bytes.Buffer{})
+	defer func() {
+		if p := recover(); p != nil {
+			t.Errorf("Unexpected panic: %#v", p)
+		}
+	}()
+	defer Recover(func(err error) {
+		if err.Error() != "Test" {
+			t.Errorf("Expected %q, but got %q", "Test", err.Error())
+		}
+	})
+	log.Fatal("Test")
+	t.Errorf("Should not get here")
+}
+
+func TestRecoverNonFatal(t *testing.T) {
+	log := New(&bytes.Buffer{})
+	defer func() {
+		if p := recover(); p == nil {
+			t.Errorf("Panic not thrown")
+		} else if p != "Test" {
+			t.Errorf("Expected %q, but got %#v", "Test", p)
+		}
+	}()
+	defer Recover(func(err error) {
+		t.Errorf("Recover function should not be called")
+	})
+	log.Panic("Test")
+	t.Errorf("Should not get here")
+}