526 lines
13 KiB
Go
526 lines
13 KiB
Go
// 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 main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"android/soong/finder"
|
|
"android/soong/ui/build"
|
|
"android/soong/ui/logger"
|
|
"android/soong/ui/status"
|
|
"android/soong/ui/terminal"
|
|
"android/soong/ui/tracer"
|
|
"android/soong/zip"
|
|
)
|
|
|
|
var numJobs = flag.Int("j", 0, "number of parallel jobs [0=autodetect]")
|
|
|
|
var keepArtifacts = flag.Bool("keep", false, "keep archives of artifacts")
|
|
var incremental = flag.Bool("incremental", false, "run in incremental mode (saving intermediates)")
|
|
|
|
var outDir = flag.String("out", "", "path to store output directories (defaults to tmpdir under $OUT when empty)")
|
|
var alternateResultDir = flag.Bool("dist", false, "write select results to $DIST_DIR (or <out>/dist when empty)")
|
|
|
|
var onlyConfig = flag.Bool("only-config", false, "Only run product config (not Soong or Kati)")
|
|
var onlySoong = flag.Bool("only-soong", false, "Only run product config and Soong (not Kati)")
|
|
|
|
var buildVariant = flag.String("variant", "eng", "build variant to use")
|
|
|
|
var shardCount = flag.Int("shard-count", 1, "split the products into multiple shards (to spread the build onto multiple machines, etc)")
|
|
var shard = flag.Int("shard", 1, "1-indexed shard to execute")
|
|
|
|
var skipProducts multipleStringArg
|
|
var includeProducts multipleStringArg
|
|
|
|
func init() {
|
|
flag.Var(&skipProducts, "skip-products", "comma-separated list of products to skip (known failures, etc)")
|
|
flag.Var(&includeProducts, "products", "comma-separated list of products to build")
|
|
}
|
|
|
|
// multipleStringArg is a flag.Value that takes comma separated lists and converts them to a
|
|
// []string. The argument can be passed multiple times to append more values.
|
|
type multipleStringArg []string
|
|
|
|
func (m *multipleStringArg) String() string {
|
|
return strings.Join(*m, `, `)
|
|
}
|
|
|
|
func (m *multipleStringArg) Set(s string) error {
|
|
*m = append(*m, strings.Split(s, ",")...)
|
|
return nil
|
|
}
|
|
|
|
const errorLeadingLines = 20
|
|
const errorTrailingLines = 20
|
|
|
|
func errMsgFromLog(filename string) string {
|
|
if filename == "" {
|
|
return ""
|
|
}
|
|
|
|
data, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
|
|
lines := strings.Split(strings.TrimSpace(string(data)), "\n")
|
|
if len(lines) > errorLeadingLines+errorTrailingLines+1 {
|
|
lines[errorLeadingLines] = fmt.Sprintf("... skipping %d lines ...",
|
|
len(lines)-errorLeadingLines-errorTrailingLines)
|
|
|
|
lines = append(lines[:errorLeadingLines+1],
|
|
lines[len(lines)-errorTrailingLines:]...)
|
|
}
|
|
var buf strings.Builder
|
|
for _, line := range lines {
|
|
buf.WriteString("> ")
|
|
buf.WriteString(line)
|
|
buf.WriteString("\n")
|
|
}
|
|
return buf.String()
|
|
}
|
|
|
|
// TODO(b/70370883): This tool uses a lot of open files -- over the default
|
|
// soft limit of 1024 on some systems. So bump up to the hard limit until I fix
|
|
// the algorithm.
|
|
func setMaxFiles(log logger.Logger) {
|
|
var limits syscall.Rlimit
|
|
|
|
err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limits)
|
|
if err != nil {
|
|
log.Println("Failed to get file limit:", err)
|
|
return
|
|
}
|
|
|
|
log.Verbosef("Current file limits: %d soft, %d hard", limits.Cur, limits.Max)
|
|
if limits.Cur == limits.Max {
|
|
return
|
|
}
|
|
|
|
limits.Cur = limits.Max
|
|
err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limits)
|
|
if err != nil {
|
|
log.Println("Failed to increase file limit:", err)
|
|
}
|
|
}
|
|
|
|
func inList(str string, list []string) bool {
|
|
for _, other := range list {
|
|
if str == other {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func copyFile(from, to string) error {
|
|
fromFile, err := os.Open(from)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fromFile.Close()
|
|
|
|
toFile, err := os.Create(to)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer toFile.Close()
|
|
|
|
_, err = io.Copy(toFile, fromFile)
|
|
return err
|
|
}
|
|
|
|
type mpContext struct {
|
|
Context context.Context
|
|
Logger logger.Logger
|
|
Status status.ToolStatus
|
|
Tracer tracer.Tracer
|
|
Finder *finder.Finder
|
|
Config build.Config
|
|
|
|
LogsDir string
|
|
}
|
|
|
|
func main() {
|
|
stdio := terminal.StdioImpl{}
|
|
|
|
output := terminal.NewStatusOutput(stdio.Stdout(), "", false,
|
|
build.OsEnvironment().IsEnvTrue("ANDROID_QUIET_BUILD"))
|
|
|
|
log := logger.New(output)
|
|
defer log.Cleanup()
|
|
|
|
flag.Parse()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
trace := tracer.New(log)
|
|
defer trace.Close()
|
|
|
|
stat := &status.Status{}
|
|
defer stat.Finish()
|
|
stat.AddOutput(output)
|
|
|
|
var failures failureCount
|
|
stat.AddOutput(&failures)
|
|
|
|
build.SetupSignals(log, cancel, func() {
|
|
trace.Close()
|
|
log.Cleanup()
|
|
stat.Finish()
|
|
})
|
|
|
|
buildCtx := build.Context{ContextImpl: &build.ContextImpl{
|
|
Context: ctx,
|
|
Logger: log,
|
|
Tracer: trace,
|
|
Writer: output,
|
|
Status: stat,
|
|
}}
|
|
|
|
args := ""
|
|
if *alternateResultDir {
|
|
args = "dist"
|
|
}
|
|
config := build.NewConfig(buildCtx, args)
|
|
if *outDir == "" {
|
|
name := "multiproduct"
|
|
if !*incremental {
|
|
name += "-" + time.Now().Format("20060102150405")
|
|
}
|
|
|
|
*outDir = filepath.Join(config.OutDir(), name)
|
|
|
|
// Ensure the empty files exist in the output directory
|
|
// containing our output directory too. This is mostly for
|
|
// safety, but also triggers the ninja_build file so that our
|
|
// build servers know that they can parse the output as if it
|
|
// was ninja output.
|
|
build.SetupOutDir(buildCtx, config)
|
|
|
|
if err := os.MkdirAll(*outDir, 0777); err != nil {
|
|
log.Fatalf("Failed to create tempdir: %v", err)
|
|
}
|
|
}
|
|
config.Environment().Set("OUT_DIR", *outDir)
|
|
log.Println("Output directory:", *outDir)
|
|
|
|
logsDir := filepath.Join(config.OutDir(), "logs")
|
|
os.MkdirAll(logsDir, 0777)
|
|
|
|
build.SetupOutDir(buildCtx, config)
|
|
|
|
os.MkdirAll(config.LogsDir(), 0777)
|
|
log.SetOutput(filepath.Join(config.LogsDir(), "soong.log"))
|
|
trace.SetOutput(filepath.Join(config.LogsDir(), "build.trace"))
|
|
|
|
var jobs = *numJobs
|
|
if jobs < 1 {
|
|
jobs = runtime.NumCPU() / 4
|
|
|
|
ramGb := int(config.TotalRAM() / 1024 / 1024 / 1024)
|
|
if ramJobs := ramGb / 25; ramGb > 0 && jobs > ramJobs {
|
|
jobs = ramJobs
|
|
}
|
|
|
|
if jobs < 1 {
|
|
jobs = 1
|
|
}
|
|
}
|
|
log.Verbosef("Using %d parallel jobs", jobs)
|
|
|
|
setMaxFiles(log)
|
|
|
|
finder := build.NewSourceFinder(buildCtx, config)
|
|
defer finder.Shutdown()
|
|
|
|
build.FindSources(buildCtx, config, finder)
|
|
|
|
vars, err := build.DumpMakeVars(buildCtx, config, nil, []string{"all_named_products"})
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
var productsList []string
|
|
allProducts := strings.Fields(vars["all_named_products"])
|
|
|
|
if len(includeProducts) > 0 {
|
|
var missingProducts []string
|
|
for _, product := range includeProducts {
|
|
if inList(product, allProducts) {
|
|
productsList = append(productsList, product)
|
|
} else {
|
|
missingProducts = append(missingProducts, product)
|
|
}
|
|
}
|
|
if len(missingProducts) > 0 {
|
|
log.Fatalf("Products don't exist: %s\n", missingProducts)
|
|
}
|
|
} else {
|
|
productsList = allProducts
|
|
}
|
|
|
|
finalProductsList := make([]string, 0, len(productsList))
|
|
skipProduct := func(p string) bool {
|
|
for _, s := range skipProducts {
|
|
if p == s {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
for _, product := range productsList {
|
|
if !skipProduct(product) {
|
|
finalProductsList = append(finalProductsList, product)
|
|
} else {
|
|
log.Verbose("Skipping: ", product)
|
|
}
|
|
}
|
|
|
|
if *shard < 1 {
|
|
log.Fatalf("--shard value must be >= 1, not %d\n", *shard)
|
|
} else if *shardCount < 1 {
|
|
log.Fatalf("--shard-count value must be >= 1, not %d\n", *shardCount)
|
|
} else if *shard > *shardCount {
|
|
log.Fatalf("--shard (%d) must not be greater than --shard-count (%d)\n", *shard,
|
|
*shardCount)
|
|
} else if *shardCount > 1 {
|
|
finalProductsList = splitList(finalProductsList, *shardCount)[*shard-1]
|
|
}
|
|
|
|
log.Verbose("Got product list: ", finalProductsList)
|
|
|
|
s := buildCtx.Status.StartTool()
|
|
s.SetTotalActions(len(finalProductsList))
|
|
|
|
mpCtx := &mpContext{
|
|
Context: ctx,
|
|
Logger: log,
|
|
Status: s,
|
|
Tracer: trace,
|
|
|
|
Finder: finder,
|
|
Config: config,
|
|
|
|
LogsDir: logsDir,
|
|
}
|
|
|
|
products := make(chan string, len(productsList))
|
|
go func() {
|
|
defer close(products)
|
|
for _, product := range finalProductsList {
|
|
products <- product
|
|
}
|
|
}()
|
|
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < jobs; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
for {
|
|
select {
|
|
case product := <-products:
|
|
if product == "" {
|
|
return
|
|
}
|
|
buildProduct(mpCtx, product)
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
if *alternateResultDir {
|
|
args := zip.ZipArgs{
|
|
FileArgs: []zip.FileArg{
|
|
{GlobDir: logsDir, SourcePrefixToStrip: logsDir},
|
|
},
|
|
OutputFilePath: filepath.Join(config.RealDistDir(), "logs.zip"),
|
|
NumParallelJobs: runtime.NumCPU(),
|
|
CompressionLevel: 5,
|
|
}
|
|
if err := zip.Zip(args); err != nil {
|
|
log.Fatalf("Error zipping logs: %v", err)
|
|
}
|
|
}
|
|
|
|
s.Finish()
|
|
|
|
if failures == 1 {
|
|
log.Fatal("1 failure")
|
|
} else if failures > 1 {
|
|
log.Fatalf("%d failures", failures)
|
|
} else {
|
|
fmt.Fprintln(output, "Success")
|
|
}
|
|
}
|
|
|
|
func buildProduct(mpctx *mpContext, product string) {
|
|
var stdLog string
|
|
|
|
outDir := filepath.Join(mpctx.Config.OutDir(), product)
|
|
logsDir := filepath.Join(mpctx.LogsDir, product)
|
|
|
|
if err := os.MkdirAll(outDir, 0777); err != nil {
|
|
mpctx.Logger.Fatalf("Error creating out directory: %v", err)
|
|
}
|
|
if err := os.MkdirAll(logsDir, 0777); err != nil {
|
|
mpctx.Logger.Fatalf("Error creating log directory: %v", err)
|
|
}
|
|
|
|
stdLog = filepath.Join(logsDir, "std.log")
|
|
f, err := os.Create(stdLog)
|
|
if err != nil {
|
|
mpctx.Logger.Fatalf("Error creating std.log: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
log := logger.New(f)
|
|
defer log.Cleanup()
|
|
log.SetOutput(filepath.Join(logsDir, "soong.log"))
|
|
|
|
action := &status.Action{
|
|
Description: product,
|
|
Outputs: []string{product},
|
|
}
|
|
mpctx.Status.StartAction(action)
|
|
defer logger.Recover(func(err error) {
|
|
mpctx.Status.FinishAction(status.ActionResult{
|
|
Action: action,
|
|
Error: err,
|
|
Output: errMsgFromLog(stdLog),
|
|
})
|
|
})
|
|
|
|
ctx := build.Context{ContextImpl: &build.ContextImpl{
|
|
Context: mpctx.Context,
|
|
Logger: log,
|
|
Tracer: mpctx.Tracer,
|
|
Writer: f,
|
|
Thread: mpctx.Tracer.NewThread(product),
|
|
Status: &status.Status{},
|
|
}}
|
|
ctx.Status.AddOutput(terminal.NewStatusOutput(ctx.Writer, "", false,
|
|
build.OsEnvironment().IsEnvTrue("ANDROID_QUIET_BUILD")))
|
|
|
|
args := append([]string(nil), flag.Args()...)
|
|
args = append(args, "--skip-soong-tests")
|
|
config := build.NewConfig(ctx, args...)
|
|
config.Environment().Set("OUT_DIR", outDir)
|
|
if !*keepArtifacts {
|
|
config.Environment().Set("EMPTY_NINJA_FILE", "true")
|
|
}
|
|
build.FindSources(ctx, config, mpctx.Finder)
|
|
config.Lunch(ctx, product, *buildVariant)
|
|
|
|
defer func() {
|
|
if *keepArtifacts {
|
|
args := zip.ZipArgs{
|
|
FileArgs: []zip.FileArg{
|
|
{
|
|
GlobDir: outDir,
|
|
SourcePrefixToStrip: outDir,
|
|
},
|
|
},
|
|
OutputFilePath: filepath.Join(mpctx.Config.OutDir(), product+".zip"),
|
|
NumParallelJobs: runtime.NumCPU(),
|
|
CompressionLevel: 5,
|
|
}
|
|
if err := zip.Zip(args); err != nil {
|
|
log.Fatalf("Error zipping artifacts: %v", err)
|
|
}
|
|
}
|
|
if !*incremental {
|
|
os.RemoveAll(outDir)
|
|
}
|
|
}()
|
|
|
|
buildWhat := build.BuildProductConfig
|
|
if !*onlyConfig {
|
|
buildWhat |= build.BuildSoong
|
|
if !*onlySoong {
|
|
buildWhat |= build.BuildKati
|
|
}
|
|
}
|
|
|
|
before := time.Now()
|
|
build.Build(ctx, config, buildWhat)
|
|
|
|
// Save std_full.log if Kati re-read the makefiles
|
|
if buildWhat&build.BuildKati != 0 {
|
|
if after, err := os.Stat(config.KatiBuildNinjaFile()); err == nil && after.ModTime().After(before) {
|
|
err := copyFile(stdLog, filepath.Join(filepath.Dir(stdLog), "std_full.log"))
|
|
if err != nil {
|
|
log.Fatalf("Error copying log file: %s", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
mpctx.Status.FinishAction(status.ActionResult{
|
|
Action: action,
|
|
})
|
|
}
|
|
|
|
type failureCount int
|
|
|
|
func (f *failureCount) StartAction(action *status.Action, counts status.Counts) {}
|
|
|
|
func (f *failureCount) FinishAction(result status.ActionResult, counts status.Counts) {
|
|
if result.Error != nil {
|
|
*f += 1
|
|
}
|
|
}
|
|
|
|
func (f *failureCount) Message(level status.MsgLevel, message string) {
|
|
if level >= status.ErrorLvl {
|
|
*f += 1
|
|
}
|
|
}
|
|
|
|
func (f *failureCount) Flush() {}
|
|
|
|
func (f *failureCount) Write(p []byte) (int, error) {
|
|
// discard writes
|
|
return len(p), nil
|
|
}
|
|
|
|
func splitList(list []string, shardCount int) (ret [][]string) {
|
|
each := len(list) / shardCount
|
|
extra := len(list) % shardCount
|
|
for i := 0; i < shardCount; i++ {
|
|
count := each
|
|
if extra > 0 {
|
|
count += 1
|
|
extra -= 1
|
|
}
|
|
ret = append(ret, list[:count])
|
|
list = list[count:]
|
|
}
|
|
return
|
|
}
|