v811_spc009/build/soong/scripts/build_broken_logs.go

// Copyright 2019 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.

// This is a script that can be used to analyze the results from
// build/soong/build_test.bash and recommend what devices need changes to their
// BUILD_BROKEN_* flags.
//
// To use, download the logs.zip from one or more branches, and extract them
// into subdirectories of the current directory. So for example, I have:
//
//   ./aosp-master/aosp_arm/std_full.log
//   ./aosp-master/aosp_arm64/std_full.log
//   ./aosp-master/...
//   ./internal-master/aosp_arm/std_full.log
//   ./internal-master/aosp_arm64/std_full.log
//   ./internal-master/...
//
// Then I use `go run path/to/build_broken_logs.go *`
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"sort"
	"strings"
)

func main() {
	for _, branch := range os.Args[1:] {
		fmt.Printf("\nBranch %s:\n", branch)
		PrintResults(ParseBranch(branch))
	}
}

type BuildBrokenBehavior int

const (
	DefaultFalse BuildBrokenBehavior = iota
	DefaultTrue
	DefaultDeprecated
)

type Setting struct {
	name     string
	behavior BuildBrokenBehavior
	warnings []string
}

var buildBrokenSettings = []Setting{
	{
		name:     "BUILD_BROKEN_DUP_RULES",
		behavior: DefaultFalse,
		warnings: []string{"overriding commands for target"},
	},
	{
		name:     "BUILD_BROKEN_USES_NETWORK",
		behavior: DefaultDeprecated,
	},
	{
		name:     "BUILD_BROKEN_USES_BUILD_COPY_HEADERS",
		behavior: DefaultTrue,
		warnings: []string{
			"COPY_HEADERS has been deprecated",
			"COPY_HEADERS is deprecated",
		},
	},
}

type Branch struct {
	Settings []Setting
	Logs     []ProductLog
}

type ProductBranch struct {
	Branch string
	Name   string
}

type ProductLog struct {
	ProductBranch
	Log
	Device string
}

type Log struct {
	WarningModuleTypes []string
	ErrorModuleTypes   []string

	BuildBroken map[string]*bool
	HasBroken   map[string]int
}

func Merge(l, l2 Log) Log {
	if l.BuildBroken == nil {
		l.BuildBroken = map[string]*bool{}
	}
	if l.HasBroken == nil {
		l.HasBroken = map[string]int{}
	}

	for n, v := range l.BuildBroken {
		if v == nil {
			l.BuildBroken[n] = l2.BuildBroken[n]
		}
	}
	for n, v := range l2.BuildBroken {
		if _, ok := l.BuildBroken[n]; !ok {
			l.BuildBroken[n] = v
		}
	}

	for n := range l.HasBroken {
		if l.HasBroken[n] < l2.HasBroken[n] {
			l.HasBroken[n] = l2.HasBroken[n]
		}
	}
	for n := range l2.HasBroken {
		if _, ok := l.HasBroken[n]; !ok {
			l.HasBroken[n] = l2.HasBroken[n]
		}
	}

	return l
}

func PrintResults(branch Branch) {
	products := branch.Logs
	devices := map[string]Log{}
	deviceNames := []string{}

	for _, product := range products {
		device := product.Device
		if _, ok := devices[device]; !ok {
			deviceNames = append(deviceNames, device)
		}
		devices[device] = Merge(devices[device], product.Log)
	}

	sort.Strings(deviceNames)

	for _, setting := range branch.Settings {
		printed := false
		n := setting.name

		for _, device := range deviceNames {
			log := devices[device]

			if setting.behavior == DefaultTrue {
				if log.BuildBroken[n] == nil || *log.BuildBroken[n] == false {
					if log.HasBroken[n] > 0 {
						printed = true
						plural := ""
						if log.HasBroken[n] > 1 {
							plural = "s"
						}
						fmt.Printf("  %s needs to set %s := true  (%d instance%s)\n", device, setting.name, log.HasBroken[n], plural)
					}
				} else if log.HasBroken[n] == 0 {
					printed = true
					fmt.Printf("  %s sets %s := true, but does not need it\n", device, setting.name)
				}
			} else if setting.behavior == DefaultFalse {
				if log.BuildBroken[n] == nil {
					// Nothing to be done
				} else if *log.BuildBroken[n] == false {
					printed = true
					fmt.Printf("  %s sets %s := false, which is the default and can be removed\n", device, setting.name)
				} else if log.HasBroken[n] == 0 {
					printed = true
					fmt.Printf("  %s sets %s := true, but does not need it\n", device, setting.name)
				}
			} else if setting.behavior == DefaultDeprecated {
				if log.BuildBroken[n] != nil {
					printed = true
					if log.HasBroken[n] > 0 {
						plural := ""
						if log.HasBroken[n] > 1 {
							plural = "s"
						}
						fmt.Printf("  %s sets %s := %v, which is deprecated, but has %d failure%s\n", device, setting.name, *log.BuildBroken[n], log.HasBroken[n], plural)
					} else {
						fmt.Printf("  %s sets %s := %v, which is deprecated and can be removed\n", device, setting.name, *log.BuildBroken[n])
					}
				}
			}
		}

		if printed {
			fmt.Println()
		}
	}
}

func ParseBranch(name string) Branch {
	products, err := filepath.Glob(filepath.Join(name, "*"))
	if err != nil {
		log.Fatal(err)
	}

	ret := Branch{Logs: []ProductLog{}}
	for _, product := range products {
		product = filepath.Base(product)

		ret.Logs = append(ret.Logs, ParseProduct(ProductBranch{Branch: name, Name: product}))
	}

	ret.Settings = append(ret.Settings, buildBrokenSettings...)
	if len(ret.Logs) > 0 {
		for _, mtype := range ret.Logs[0].WarningModuleTypes {
			if mtype == "BUILD_COPY_HEADERS" || mtype == "" {
				continue
			}
			ret.Settings = append(ret.Settings, Setting{
				name:     "BUILD_BROKEN_USES_" + mtype,
				behavior: DefaultTrue,
				warnings: []string{mtype + " has been deprecated"},
			})
		}
		for _, mtype := range ret.Logs[0].ErrorModuleTypes {
			if mtype == "BUILD_COPY_HEADERS" || mtype == "" {
				continue
			}
			ret.Settings = append(ret.Settings, Setting{
				name:     "BUILD_BROKEN_USES_" + mtype,
				behavior: DefaultFalse,
				warnings: []string{mtype + " has been deprecated"},
			})
		}
	}

	for _, productLog := range ret.Logs {
		ScanProduct(ret.Settings, productLog)
	}
	return ret
}

func ParseProduct(p ProductBranch) ProductLog {
	soongLog, err := ioutil.ReadFile(filepath.Join(p.Branch, p.Name, "soong.log"))
	if err != nil {
		log.Fatal(err)
	}

	ret := ProductLog{
		ProductBranch: p,
		Log: Log{
			BuildBroken: map[string]*bool{},
			HasBroken:   map[string]int{},
		},
	}

	lines := strings.Split(string(soongLog), "\n")
	for _, line := range lines {
		fields := strings.Split(line, " ")
		if len(fields) < 5 {
			continue
		}

		if fields[3] == "TARGET_DEVICE" {
			ret.Device = fields[4]
		}

		if fields[3] == "DEFAULT_WARNING_BUILD_MODULE_TYPES" {
			ret.WarningModuleTypes = fields[4:]
		}
		if fields[3] == "DEFAULT_ERROR_BUILD_MODULE_TYPES" {
			ret.ErrorModuleTypes = fields[4:]
		}

		if strings.HasPrefix(fields[3], "BUILD_BROKEN_") {
			ret.BuildBroken[fields[3]] = ParseBoolPtr(fields[4])
		}
	}

	return ret
}

func ScanProduct(settings []Setting, l ProductLog) {
	stdLog, err := ioutil.ReadFile(filepath.Join(l.Branch, l.Name, "std_full.log"))
	if err != nil {
		log.Fatal(err)
	}
	stdStr := string(stdLog)

	for _, setting := range settings {
		for _, warning := range setting.warnings {
			if strings.Contains(stdStr, warning) {
				l.HasBroken[setting.name] += strings.Count(stdStr, warning)
			}
		}
	}
}

func ParseBoolPtr(str string) *bool {
	var ret *bool
	if str != "" {
		b := str == "true"
		ret = &b
	}
	return ret
}