Snap for 8782634 from 23719d629f9b126aacc17bd4348950dff16fa22f to sdk-release
Change-Id: I6dd5055439f91de2903731ecf501edfe4b9d01d4
diff --git a/OWNERS b/OWNERS
index bccf671..0c6370d 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,4 +1,5 @@
kiyoungkim@google.com
-danielnorman@google.com
+deyaoren@google.com
haamed@google.com
+jgalmes@google.com
rseymour@google.com
\ No newline at end of file
diff --git a/build/treble_build/README.md b/build/treble_build/README.md
new file mode 100644
index 0000000..1e36bf2
--- /dev/null
+++ b/build/treble_build/README.md
@@ -0,0 +1,38 @@
+# treble_build
+
+## Description
+Set of tools to run against the Android source tree and build graph.
+In order to run the application it must be built via **m treble_build**
+this will also create the needed build graph that the tool uses.
+
+## Basic Commands
+- treble_build -h
+- treble_build [host, paths, query] [target...]
+
+
+### host
+treble_build host
+
+Report the projects required to build the host tools.
+
+### paths
+treble_build [-build] paths [-1] -repo project:sha [-repo project:sha...]
+
+For a given set of commits (project:sha), get the corresponding source
+files. Translate the source files into a set of build outputs using the
+path (-1) or paths command. If the build flag is given build the build
+target closest to the source files.
+
+### query
+treble_build query -repo project:sha [-repo project:sha...]
+
+For a given set of commits (project:sha), get the corresponding source
+files. Translate the source files into a set of inputs and outputs.
+
+### report
+By default a report is generated for all above commands, extra targets can
+be included in the report by adding to the end of the command line.
+
+See treble_build -h for options controlling report data.
+
+
diff --git a/build/treble_build/app/Android.bp b/build/treble_build/app/Android.bp
new file mode 100644
index 0000000..4906202
--- /dev/null
+++ b/build/treble_build/app/Android.bp
@@ -0,0 +1,34 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "tools_treble_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ default_applicable_licenses: ["tools_treble_license"],
+}
+
+bootstrap_go_package {
+ name: "treble_report_app",
+ srcs: [
+ "git.go",
+ "build.go",
+ "repo.go",
+ "report.go",
+ ],
+ pkgPath: "tools/treble/build/report/app",
+ pluginFor: ["soong_build"],
+}
diff --git a/build/treble_build/app/build.go b/build/treble_build/app/build.go
new file mode 100644
index 0000000..8b78e23
--- /dev/null
+++ b/build/treble_build/app/build.go
@@ -0,0 +1,60 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 app
+
+// Query
+type BuildQuery struct {
+ Target string `json:"target"`
+ Inputs []string `json:"inputs"`
+ Outputs []string `json:"outputs"`
+}
+
+// Input
+type BuildInput struct {
+ Target string `json:"target"`
+ Files []string `json:"files"`
+}
+
+// Commands
+type BuildCommand struct {
+ Target string `json:"target"`
+ Cmds []string `json:"cmds"`
+}
+
+// Path
+type BuildPath struct {
+ Target string `json:"target"`
+ Dependency string `json:"dependency"`
+ Paths []string `json:paths"`
+}
+
+// Build target
+type BuildTarget struct {
+ Name string `json:"name"` // Target name
+ Steps int `json:"build_steps"` // Number of steps to build target
+ FileCount int `json:"files"` // Number of input files for a target
+ Projects map[string]*GitProject `json:"projects"` // Inputs projects/files of a target
+}
+
+// Build command result
+type BuildCmdResult struct {
+ Name string `json:"name"`
+ Output []string `json:"output"`
+ Success bool `json:"success"`
+}
+
+// Build dependencies
+type BuildDeps struct {
+ Targets map[string][]string `json:"targets"`
+}
diff --git a/build/treble_build/app/git.go b/build/treble_build/app/git.go
new file mode 100644
index 0000000..7cd21a4
--- /dev/null
+++ b/build/treble_build/app/git.go
@@ -0,0 +1,73 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 app
+
+// GIT diff
+type GitDiff struct {
+ AddedLines int `json:"added_lines"`
+ DeletedLines int `json:"deleted_lines"`
+ BinaryDiff bool `json:"binary_diff"`
+}
+
+// GIT tree object (files,dirs...)
+type GitTreeObj struct {
+ Permissions string `json:"permissions"`
+ Type string `json:"type"`
+ Sha string `json:"sha"`
+ Filename string `json:"filename"`
+ BranchDiff *GitDiff `json:"branch_diff"`
+}
+
+// GitProject
+type GitProject struct {
+ RepoDir string `json:"repo_dir"` // Relative directory within repo
+ WorkDir string `json:"working_dir"` // Working directory
+ GitDir string `json:"git_dir"` // GIT directory
+ Remote string `json:"remote"` // Remote Name
+ RemoteUrl string `json:"remote_url"` // Remote URL
+ Revision string `json:"revision"` // Revision (SHA)
+ Files map[string]*GitTreeObj `json:"files"` // Files within the project
+}
+
+type GitCommitFileType int
+
+const (
+ GitFileAdded GitCommitFileType = iota
+ GitFileModified
+ GitFileRemoved
+)
+
+type GitCommitFile struct {
+ Filename string `json:"filename"`
+ Type GitCommitFileType `json:"type"`
+}
+
+// Git commit
+type GitCommit struct {
+ Sha string `json:"sha"`
+ Files []GitCommitFile `json:"files"`
+}
+
+func (t GitCommitFileType) String() string {
+ switch t {
+ case GitFileModified:
+ return "M"
+ case GitFileAdded:
+ return "A"
+ case GitFileRemoved:
+ return "R"
+ }
+ return ""
+}
diff --git a/build/treble_build/app/repo.go b/build/treble_build/app/repo.go
new file mode 100644
index 0000000..f1903f2
--- /dev/null
+++ b/build/treble_build/app/repo.go
@@ -0,0 +1,55 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 app
+
+import (
+ "encoding/xml"
+ "io/ioutil"
+)
+
+type RepoRemote struct {
+ Name string `xml:"name,attr"`
+ Revision string `xml:"fetch,attr"`
+}
+type RepoDefault struct {
+ Remote string `xml:"remote,attr"`
+ Revision string `xml:"revision,attr"`
+}
+type RepoProject struct {
+ Groups string `xml:"groups,attr"`
+ Name string `xml:"name,attr"`
+ Revision string `xml:"revision,attr"`
+ Path string `xml:"path,attr"`
+ Remote *string `xml:"remote,attr"`
+}
+type RepoManifest struct {
+ XMLName xml.Name `xml:"manifest"`
+ Remotes []RepoRemote `xml:"remote"`
+ Default RepoDefault `xml:"default"`
+ Projects []RepoProject `xml:"project"`
+}
+
+// Parse a repo manifest file
+func ParseXml(filename string) (*RepoManifest, error) {
+ data, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ v := &RepoManifest{}
+ err = xml.Unmarshal(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ return v, nil
+}
diff --git a/build/treble_build/app/report.go b/build/treble_build/app/report.go
new file mode 100644
index 0000000..bc9c7ab
--- /dev/null
+++ b/build/treble_build/app/report.go
@@ -0,0 +1,50 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 app
+
+// Report request structure
+type ReportRequest struct {
+ Targets []string `json:"targets"` // Targets
+}
+
+// Report response data
+type Report struct {
+ Targets map[string]*BuildTarget `json:"targets"` // Build target data
+}
+
+// Host tool report response data
+type HostReport struct {
+ Path string `json:"path"` // Path to find host tools
+ SymLinks int `json:"sym_links"` // Number of symlinks found
+ Targets []string `json:"targets"` // Target for tools found
+}
+
+// Project level commit
+type ProjectCommit struct {
+ Project string `json:"project"` // Project
+ Revision string `json:"revision"` // Revision
+}
+
+// Query request
+type QueryRequest struct {
+ Files []string `json:"files"` // Files to resolve
+}
+
+// Output response
+type QueryResponse struct {
+ InputFiles []string `json:"input_files"` // Input files found
+ OutputFiles []string `json:"output_files"` // Output files found
+ UnknownFiles []string `json:"unknown_files,omitempty"` // Unknown files
+}
diff --git a/build/treble_build/cmd/Android.bp b/build/treble_build/cmd/Android.bp
new file mode 100644
index 0000000..ec83692
--- /dev/null
+++ b/build/treble_build/cmd/Android.bp
@@ -0,0 +1,37 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "tools_treble_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ default_applicable_licenses: ["tools_treble_license"],
+}
+
+blueprint_go_binary {
+ name: "treble_build",
+ srcs: [
+ "host.go",
+ "main.go",
+ "paths.go",
+ "query.go",
+ ],
+ deps: [
+ "treble_report_app",
+ "treble_report_module",
+ "treble_report_local",
+ ],
+}
diff --git a/build/treble_build/cmd/host.go b/build/treble_build/cmd/host.go
new file mode 100644
index 0000000..0b8e65f
--- /dev/null
+++ b/build/treble_build/cmd/host.go
@@ -0,0 +1,75 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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"
+ "fmt"
+ "io"
+ "path/filepath"
+
+ "tools/treble/build/report/report"
+)
+
+type hostReport struct {
+ toolPath string
+}
+
+// Determine host tools
+func (h *hostReport) Run(ctx context.Context, rtx *report.Context, rsp *response) error {
+ var err error
+ rsp.Host, err = report.ResolveHostTools(ctx, h.toolPath)
+ if err != nil {
+ return err
+ }
+ rsp.Targets = append(rsp.Targets, rsp.Host.Targets...)
+ return nil
+}
+
+func (h *hostReport) PrintText(w io.Writer, rsp *response, verbose bool) {
+ if rsp.Host != nil {
+ // Get the unique number of inputs
+ hostSourceFileMap := make(map[string]bool)
+ hostSourceProjectMap := make(map[string]bool)
+
+ for _, t := range rsp.Host.Targets {
+ // Find target in report
+ if bt, exists := rsp.Report.Targets[t]; exists {
+ for name, proj := range bt.Projects {
+ hostSourceProjectMap[name] = true
+ for f := range proj.Files {
+ hostSourceFileMap[filepath.Join(name, f)] = true
+ }
+ }
+ // Remove the target from being printed
+ delete(rsp.Report.Targets, t)
+ }
+ }
+
+ fmt.Fprintln(w, " Host Tools")
+ fmt.Fprintf(w, " %-20s : %s\n", "Directory", rsp.Host.Path)
+ fmt.Fprintf(w, " %-20s : %d\n", "Tools", len(rsp.Host.Targets))
+ fmt.Fprintf(w, " %-20s : %d\n", "Prebuilts", rsp.Host.SymLinks)
+ fmt.Fprintf(w, " %-20s : %d\n", "Inputs", len(hostSourceFileMap))
+ fmt.Fprintf(w, " %-20s : %d\n", "Projects", len(hostSourceProjectMap))
+
+ if verbose {
+ for proj, _ := range hostSourceProjectMap {
+ fmt.Fprintf(w, " %s\n", proj)
+ }
+ }
+ }
+
+}
diff --git a/build/treble_build/cmd/main.go b/build/treble_build/cmd/main.go
new file mode 100644
index 0000000..0264ff3
--- /dev/null
+++ b/build/treble_build/cmd/main.go
@@ -0,0 +1,297 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 (
+ "bufio"
+ "context"
+ "encoding/json"
+ "errors"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "runtime"
+ "strings"
+
+ "tools/treble/build/report/app"
+ "tools/treble/build/report/local"
+ "tools/treble/build/report/report"
+)
+
+type Build interface {
+ Build(ctx context.Context, target string) *app.BuildCmdResult
+}
+
+type tool interface {
+ Run(ctx context.Context, rtx *report.Context, rsp *response) error
+ PrintText(w io.Writer, rsp *response, verbose bool)
+}
+type repoFlags []app.ProjectCommit
+
+func (r *repoFlags) Set(value string) error {
+ commit := app.ProjectCommit{}
+ items := strings.Split(value, ":")
+ if len(items) > 2 {
+ return (errors.New("Invalid repo value expected (proj:sha) format"))
+ }
+ commit.Project = items[0]
+ if len(items) > 1 {
+ commit.Revision = items[1]
+ }
+ *r = append(*r, commit)
+ return nil
+}
+func (r *repoFlags) String() string {
+ items := []string{}
+ for _, fl := range *r {
+ items = append(items, fmt.Sprintf("%s:%s", fl.Project, fl.Revision))
+ }
+ return strings.Join(items, " ")
+}
+
+var (
+ // Common flags
+ ninjaDbPtr = flag.String("ninja", local.DefNinjaDb(), "Set the .ninja file to use when building metrics")
+ ninjaExcPtr = flag.String("ninja_cmd", local.DefNinjaExc(), "Set the ninja executable")
+ manifestPtr = flag.String("manifest", local.DefManifest(), "Set the location of the manifest file")
+ upstreamPtr = flag.String("upstream", "", "Upstream branch to compare files against")
+ repoBasePtr = flag.String("repo_base", local.DefRepoBase(), "Set the repo base directory")
+ workerCountPtr = flag.Int("worker_count", runtime.NumCPU(), "Number of worker routines")
+ buildWorkerCountPtr = flag.Int("build_worker_count", local.MaxNinjaCliWorkers, "Number of build worker routines")
+ buildPtr = flag.Bool("build", false, "Build targets")
+ jsonPtr = flag.Bool("json", false, "Print json data")
+ verbosePtr = flag.Bool("v", false, "Print verbose text data")
+ outputPtr = flag.String("o", "", "Output to file")
+
+ hostFlags = flag.NewFlagSet("host", flag.ExitOnError)
+ queryFlags = flag.NewFlagSet("query", flag.ExitOnError)
+ pathsFlags = flag.NewFlagSet("paths", flag.ExitOnError)
+)
+
+type commit struct {
+ Project app.ProjectCommit `json:"project"`
+ Commit *app.GitCommit `json:"commit"`
+}
+
+// Use one structure for output for now
+type response struct {
+ Commits []commit `json:"commits,omitempty"`
+ Inputs []string `json:"files,omitempty"`
+ BuildFiles []*app.BuildCmdResult `json:"build_files,omitempty"`
+ Targets []string `json:"targets,omitempty"`
+ Report *app.Report `json:"report,omitempty"`
+
+ // Subcommand data
+ Query *app.QueryResponse `json:"query,omitempty"`
+ Paths []*app.BuildPath `json:"build_paths,omitempty"`
+ Host *app.HostReport `json:"host,omitempty"`
+}
+
+func main() {
+ ctx := context.Background()
+ rsp := &response{}
+
+ flag.Parse()
+
+ subArgs := flag.Args()
+ if len(subArgs) < 1 {
+ // Nothing to do
+ return
+ }
+ defBuildTarget := "droid"
+ log.SetFlags(log.LstdFlags | log.Llongfile)
+
+ ninja := local.NewNinjaCli(*ninjaExcPtr, *ninjaDbPtr)
+ rtx := &report.Context{
+ RepoBase: *repoBasePtr,
+ Repo: &report.RepoMan{},
+ Build: ninja,
+ Project: local.NewGitCli(),
+ WorkerCount: *workerCountPtr,
+ BuildWorkerCount: *buildWorkerCountPtr,
+ }
+
+ var subcommand tool
+ var commits repoFlags
+
+ switch subArgs[0] {
+ case "host":
+ hostToolPathPtr := hostFlags.String("hostbin", local.DefHostBinPath(), "Set the output directory for host tools")
+ hostFlags.Parse(subArgs[1:])
+
+ subcommand = &hostReport{toolPath: *hostToolPathPtr}
+ rsp.Targets = hostFlags.Args()
+
+ case "query":
+ queryFlags.Var(&commits, "repo", "Repo:SHA to query")
+ queryFlags.Parse(subArgs[1:])
+ subcommand = &queryReport{}
+ rsp.Targets = queryFlags.Args()
+
+ case "paths":
+ pathsFlags.Var(&commits, "repo", "Repo:SHA to build")
+ singlePathPtr := pathsFlags.Bool("1", false, "Get single path to output target")
+ pathsFlags.Parse(subArgs[1:])
+
+ subcommand = &pathsReport{build_target: defBuildTarget, single: *singlePathPtr}
+
+ rsp.Targets = pathsFlags.Args()
+
+ default:
+ rsp.Targets = subArgs
+ }
+
+ rtx.ResolveProjectMap(ctx, *manifestPtr, *upstreamPtr)
+ // Resolve any commits
+ if len(commits) > 0 {
+ log.Printf("Resolving %s", commits.String())
+ for _, c := range commits {
+ commit := commit{Project: c}
+ info, files, err := report.ResolveCommit(ctx, rtx, &c)
+ if err != nil {
+ log.Fatalf("Failed to resolve commit %s:%s", c.Project, c.Revision)
+ }
+ commit.Commit = info
+ rsp.Commits = append(rsp.Commits, commit)
+
+ // Add files to list of inputs
+ rsp.Inputs = append(rsp.Inputs, files...)
+ }
+ }
+
+ // Run any sub tools
+ if subcommand != nil {
+ if err := subcommand.Run(ctx, rtx, rsp); err != nil {
+ log.Fatal(err)
+ }
+ }
+
+ buildErrors := 0
+ if *buildPtr {
+ for _, t := range rsp.Targets {
+ log.Printf("Building %s\n", t)
+ res := ninja.Build(ctx, t)
+ log.Printf("%s\n", res.Output)
+ if res.Success != true {
+ buildErrors++
+ }
+ rsp.BuildFiles = append(rsp.BuildFiles, res)
+ }
+ }
+
+ // Generate report
+ var err error
+ log.Printf("Generating report for targets %s", rsp.Targets)
+ req := &app.ReportRequest{Targets: rsp.Targets}
+ rsp.Report, err = report.RunReport(ctx, rtx, req)
+ if err != nil {
+ log.Fatal(fmt.Sprintf("Report failure <%s>", err))
+ }
+
+ if *jsonPtr {
+ b, _ := json.MarshalIndent(rsp, "", "\t")
+ if *outputPtr == "" {
+ os.Stdout.Write(b)
+ } else {
+ os.WriteFile(*outputPtr, b, 0644)
+ }
+ } else {
+ if *outputPtr == "" {
+ printTextReport(os.Stdout, subcommand, rsp, *verbosePtr)
+ } else {
+ file, err := os.Create(*outputPtr)
+ if err != nil {
+ log.Fatalf("Failed to create output file %s (%s)", *outputPtr, err)
+ }
+ w := bufio.NewWriter(file)
+ printTextReport(w, subcommand, rsp, *verbosePtr)
+ w.Flush()
+ }
+
+ }
+
+ if buildErrors > 0 {
+ log.Fatal(fmt.Sprintf("Failed to build %d targets", buildErrors))
+ }
+}
+
+func printTextReport(w io.Writer, subcommand tool, rsp *response, verbose bool) {
+ fmt.Fprintln(w, "Metric Report")
+ if subcommand != nil {
+ subcommand.PrintText(w, rsp, verbose)
+ }
+
+ if len(rsp.Commits) > 0 {
+ fmt.Fprintln(w, "")
+ fmt.Fprintln(w, " Commit Results")
+ for _, c := range rsp.Commits {
+ fmt.Fprintf(w, " %-120s : %s\n", c.Project.Project, c.Project.Revision)
+ fmt.Fprintf(w, " SHA : %s\n", c.Commit.Sha)
+ fmt.Fprintf(w, " Files : \n")
+ for _, f := range c.Commit.Files {
+ fmt.Fprintf(w, " %s %s\n", f.Type.String(), f.Filename)
+ }
+ }
+ }
+ if len(rsp.BuildFiles) > 0 {
+ fmt.Fprintln(w, "")
+ fmt.Fprintln(w, " Build Files")
+ for _, b := range rsp.BuildFiles {
+ fmt.Fprintf(w, " %-120s : %t \n", b.Name, b.Success)
+ }
+ }
+
+ targetPrint := func(target *app.BuildTarget) {
+ fmt.Fprintf(w, " %-20s : %s\n", "Name", target.Name)
+ fmt.Fprintf(w, " %-20s : %d\n", "Build Steps", target.Steps)
+ fmt.Fprintf(w, " %-20s \n", "Inputs")
+ fmt.Fprintf(w, " %-20s : %d\n", "Files", target.FileCount)
+ fmt.Fprintf(w, " %-20s : %d\n", "Projects", len(target.Projects))
+ fmt.Fprintln(w)
+ for name, proj := range target.Projects {
+ forkCount := 0
+ for _, file := range proj.Files {
+ if file.BranchDiff != nil {
+ forkCount++
+ }
+ }
+ fmt.Fprintf(w, " %-120s : %d ", name, len(proj.Files))
+ if forkCount != 0 {
+ fmt.Fprintf(w, " (%d)\n", forkCount)
+ } else {
+ fmt.Fprintf(w, " \n")
+ }
+
+ if verbose {
+ for _, file := range proj.Files {
+ var fork string
+ if file.BranchDiff != nil {
+ fork = fmt.Sprintf("(%d+ %d-)", file.BranchDiff.AddedLines, file.BranchDiff.DeletedLines)
+ }
+ fmt.Fprintf(w, " %-20s %s\n", fork, file.Filename)
+ }
+
+ }
+ }
+
+ }
+ fmt.Fprintln(w, " Targets")
+ for _, t := range rsp.Report.Targets {
+ targetPrint(t)
+ }
+
+}
diff --git a/build/treble_build/cmd/paths.go b/build/treble_build/cmd/paths.go
new file mode 100644
index 0000000..4c28d4f
--- /dev/null
+++ b/build/treble_build/cmd/paths.go
@@ -0,0 +1,64 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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"
+ "fmt"
+ "io"
+ "log"
+
+ "tools/treble/build/report/report"
+)
+
+type pathsReport struct {
+ build_target string // Target used to filter build request
+ single bool // Get single path
+}
+
+func (p pathsReport) Run(ctx context.Context, rtx *report.Context, rsp *response) error {
+
+ log.Printf("Resolving paths for %s (single : %v)\n", rsp.Inputs, p.single)
+ rsp.Paths = report.RunPaths(ctx, rtx, p.build_target, p.single, rsp.Inputs)
+
+ // The path is returned in an array in the form [build_target, path_stop1,...,path_stopN,source_file]
+ // Choose the closest build target (path_stopN) to the source file to build to reduce the amount that
+ // is built.
+ const buildPathIndex = 2
+ build_targets := make(map[string]bool)
+ for _, path := range rsp.Paths {
+ // Default to build closest build target
+ if len(path.Paths) > buildPathIndex {
+ build_targets[path.Paths[len(path.Paths)-buildPathIndex]] = true
+ }
+ }
+ for b := range build_targets {
+ rsp.Targets = append(rsp.Targets, b)
+ }
+
+ return nil
+}
+
+func (h *pathsReport) PrintText(w io.Writer, rsp *response, verbose bool) {
+ if len(rsp.Paths) > 0 {
+ fmt.Fprintln(w, " Paths")
+ for _, p := range rsp.Paths {
+ // Provide path from target to dependency with the
+ // path length, since target and dependency are in the
+ // path subtract them out from length
+ fmt.Fprintf(w, " %s..(%d)..%-s\n", p.Target, len(p.Paths)-2, p.Dependency)
+ }
+ }
+}
diff --git a/build/treble_build/cmd/query.go b/build/treble_build/cmd/query.go
new file mode 100644
index 0000000..e4c7f0f
--- /dev/null
+++ b/build/treble_build/cmd/query.go
@@ -0,0 +1,44 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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"
+ "io"
+ "log"
+
+ "tools/treble/build/report/app"
+ "tools/treble/build/report/report"
+)
+
+// Command arguments
+type queryReport struct {
+}
+
+// Run query
+func (o queryReport) Run(ctx context.Context, rtx *report.Context, rsp *response) error {
+ var err error
+ log.Printf("Querying files %s\n", rsp.Inputs)
+ req := &app.QueryRequest{Files: rsp.Inputs}
+ rsp.Query, err = report.RunQuery(ctx, rtx, req)
+ if err != nil {
+ return err
+ }
+
+ return nil
+
+}
+func (h *queryReport) PrintText(w io.Writer, rsp *response, verbose bool) {
+}
diff --git a/build/treble_build/local/Android.bp b/build/treble_build/local/Android.bp
new file mode 100644
index 0000000..685f885
--- /dev/null
+++ b/build/treble_build/local/Android.bp
@@ -0,0 +1,41 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "tools_treble_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ default_applicable_licenses: ["tools_treble_license"],
+}
+
+bootstrap_go_package {
+ name: "treble_report_local",
+ srcs: [
+ "cmd.go",
+ "defaults.go",
+ "git.go",
+ "ninja.go",
+ ],
+ deps: [
+ "treble_report_app",
+ ],
+ testSrcs: [
+ "git_test.go",
+ "ninja_test.go",
+ ],
+ pkgPath: "tools/treble/build/report/local",
+ pluginFor: ["soong_build"],
+}
diff --git a/build/treble_build/local/cmd.go b/build/treble_build/local/cmd.go
new file mode 100644
index 0000000..3fc24c8
--- /dev/null
+++ b/build/treble_build/local/cmd.go
@@ -0,0 +1,98 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 local
+
+import (
+ "bufio"
+ "bytes"
+ "context"
+ "errors"
+ "io"
+ "os/exec"
+ "time"
+)
+
+// Run the input command via pipe with given arguments, stdout of the pipe is passed to input parser
+// argument.
+func runPipe(ctx context.Context, timeout time.Duration, cmdName string, args []string, parser func(r io.Reader)) (err error, stdErr string) {
+ ctx, cancel := context.WithTimeout(ctx, timeout)
+ defer cancel()
+
+ cmd := exec.CommandContext(ctx, cmdName, args[0:]...)
+ errorBuf := bytes.Buffer{}
+ cmd.Stderr = &errorBuf
+ stdout, err := cmd.StdoutPipe()
+ if err != nil {
+ return err, errorBuf.String()
+ }
+
+ if err = cmd.Start(); err != nil {
+ return err, errorBuf.String()
+ }
+ parser(stdout)
+ if err = cmd.Wait(); err != nil {
+ return err, errorBuf.String()
+ }
+ return nil, ""
+}
+
+// Run input command, stdout is passed via out parameter to user, if error the stderr is provided via
+// stdErr string to the user.
+func run(ctx context.Context, timeout time.Duration, cmdName string, args []string) (out *bytes.Buffer, err error, stdErr string) {
+ ctx, cancel := context.WithTimeout(ctx, timeout)
+ defer cancel()
+
+ cmd := exec.CommandContext(ctx, cmdName, args[0:]...)
+ errorBuf := bytes.Buffer{}
+ outputBuf := bytes.Buffer{}
+ cmd.Stderr = &errorBuf
+ cmd.Stdout = &outputBuf
+ if err = cmd.Run(); err != nil {
+ return nil, err, errorBuf.String()
+ }
+
+ return &outputBuf, nil, ""
+}
+
+// lineScanner
+//
+// Map output lines to strings, with expected number of
+// lines
+type lineScanner struct {
+ Lines []string
+}
+
+// Parse into lines
+func (l *lineScanner) Parse(s *bufio.Scanner) error {
+ i := 0
+ for s.Scan() {
+ if i < len(l.Lines) {
+ l.Lines[i] = s.Text()
+ } else {
+ i++
+ break
+ }
+ i++
+ }
+ if i != len(l.Lines) {
+ return errors.New("cmd: incorrect number of lines")
+ }
+ return nil
+}
+
+func newLineScanner(numLines int) *lineScanner {
+ out := &lineScanner{Lines: make([]string, numLines)}
+ return (out)
+}
diff --git a/build/treble_build/local/defaults.go b/build/treble_build/local/defaults.go
new file mode 100644
index 0000000..53befe4
--- /dev/null
+++ b/build/treble_build/local/defaults.go
@@ -0,0 +1,43 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 local
+
+import (
+ "os"
+ "path/filepath"
+)
+
+func DefNinjaDb() string {
+ dbs, _ := filepath.Glob("out/combined-*.ninja")
+ def_db := ""
+ if len(dbs) > 0 {
+ def_db = dbs[0]
+ }
+ return def_db
+}
+
+func DefNinjaExc() string {
+ return "prebuilts/build-tools/linux-x86/bin/ninja"
+}
+func DefManifest() string {
+ return ".repo/manifests/default.xml"
+}
+func DefHostBinPath() string {
+ return "out/host/linux-x86/bin"
+}
+func DefRepoBase() string {
+ ret, _ := os.Getwd()
+ return ret
+}
diff --git a/build/treble_build/local/git.go b/build/treble_build/local/git.go
new file mode 100644
index 0000000..2793042
--- /dev/null
+++ b/build/treble_build/local/git.go
@@ -0,0 +1,248 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 local
+
+//
+// Command line implementation of Git interface
+//
+
+import (
+ "bufio"
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+
+ "tools/treble/build/report/app"
+)
+
+// Separate out the executable to allow tests to override the results
+type gitExec interface {
+ ProjectInfo(ctx context.Context, gitDir, workDir string) (out *bytes.Buffer, err error)
+ RemoteUrl(ctx context.Context, gitDir, workDir, remote string) (*bytes.Buffer, error)
+ Tree(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error)
+ CommitInfo(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error)
+ DiffBranches(ctx context.Context, gitDir, workDir, upstream, sha string) (*bytes.Buffer, error)
+}
+
+type gitCli struct {
+ git gitExec // Git executable
+}
+
+// Create GIT project based on input parameters
+func (cli gitCli) Project(ctx context.Context, path, gitDir, remote, revision string) (*app.GitProject, error) {
+ workDir := path
+ // Set defaults
+ if remote == "" {
+ remote = "origin"
+ }
+ if gitDir == "" {
+ gitDir = ".git"
+ }
+
+ if raw, err := cli.git.ProjectInfo(ctx, gitDir, workDir); err == nil {
+ topLevel, projRevision, err := parseProjectInfo(raw)
+ if err == nil {
+ // Update work dir to use absolute path
+ workDir = topLevel
+ if revision == "" {
+ revision = projRevision
+ }
+ }
+ }
+ // Create project to use to run commands
+ out := &app.GitProject{
+ RepoDir: path,
+ WorkDir: workDir,
+ GitDir: gitDir,
+ Remote: remote,
+ Revision: revision,
+ Files: make(map[string]*app.GitTreeObj)}
+
+ // Remote URL
+ if raw, err := cli.git.RemoteUrl(ctx, gitDir, workDir, remote); err == nil {
+ url, err := parseRemoteUrl(raw)
+ if err == nil {
+ out.RemoteUrl = url
+ }
+ }
+
+ return out, nil
+}
+
+// Get all files in the repository if, upstream branch is provided mark which files differ from upstream
+func (cli gitCli) PopulateFiles(ctx context.Context, proj *app.GitProject, upstream string) error {
+ if raw, err := cli.git.Tree(ctx, proj.GitDir, proj.WorkDir, proj.Revision); err == nil {
+ lsFiles, err := parseLsTree(raw)
+ if err == nil {
+ for _, file := range lsFiles {
+ proj.Files[file.Filename] = file
+ }
+ }
+ if upstream != "" {
+
+ if diff, err := cli.git.DiffBranches(ctx, proj.GitDir, proj.WorkDir, upstream, proj.Revision); err == nil {
+ if diffFiles, err := parseBranchDiff(diff); err == nil {
+ for f, d := range diffFiles {
+ if file, exists := proj.Files[f]; exists {
+ file.BranchDiff = d
+ }
+ }
+ }
+ }
+
+ }
+ }
+ return nil
+}
+
+// Get the commit information associated with the input sha
+func (cli gitCli) CommitInfo(ctx context.Context, proj *app.GitProject, sha string) (*app.GitCommit, error) {
+ if sha == "" {
+ sha = "HEAD"
+ }
+ raw, err := cli.git.CommitInfo(ctx, proj.GitDir, proj.WorkDir, sha)
+
+ if err != nil {
+ return nil, err
+ }
+ return parseCommitInfo(raw)
+}
+
+// parse rev-parse
+func parseProjectInfo(data *bytes.Buffer) (topLevel string, revision string, err error) {
+ s := bufio.NewScanner(data)
+ scanner := newLineScanner(2)
+ if err = scanner.Parse(s); err != nil {
+ return "", "", err
+ }
+ return scanner.Lines[0], scanner.Lines[1], nil
+
+}
+
+// parse remote get-url
+func parseRemoteUrl(data *bytes.Buffer) (url string, err error) {
+ s := bufio.NewScanner(data)
+ scanner := newLineScanner(1)
+ if err = scanner.Parse(s); err != nil {
+ return "", err
+ }
+ return scanner.Lines[0], nil
+
+}
+
+// parse ls-tree
+func parseLsTree(data *bytes.Buffer) ([]*app.GitTreeObj, error) {
+ out := []*app.GitTreeObj{}
+ s := bufio.NewScanner(data)
+ for s.Scan() {
+ obj := &app.GitTreeObj{}
+ // TODO
+ // Filename could contain a <space> as quotepath is turned off, truncating the name here
+ fmt.Sscanf(s.Text(), "%s %s %s %s", &obj.Permissions, &obj.Type, &obj.Sha, &obj.Filename)
+ out = append(out, obj)
+ }
+ return out, nil
+}
+
+// parse branch diff (diff --num-stat)
+func parseBranchDiff(data *bytes.Buffer) (map[string]*app.GitDiff, error) {
+ out := make(map[string]*app.GitDiff)
+ s := bufio.NewScanner(data)
+ for s.Scan() {
+ d := &app.GitDiff{}
+ var fname, added, deleted string
+ _, err := fmt.Sscanf(s.Text(), "%s %s %s", &added, &deleted, &fname)
+ if err == nil {
+ if added == "-" || deleted == "-" {
+ d.BinaryDiff = true
+ } else {
+ d.AddedLines, _ = strconv.Atoi(added)
+ d.DeletedLines, _ = strconv.Atoi(deleted)
+ }
+ }
+ out[fname] = d
+ }
+ return out, nil
+}
+
+// parse commit diff-tree
+func parseCommitInfo(data *bytes.Buffer) (*app.GitCommit, error) {
+ out := &app.GitCommit{Files: []app.GitCommitFile{}}
+ s := bufio.NewScanner(data)
+ first := true
+ for s.Scan() {
+ if first {
+ out.Sha = s.Text()
+ } else {
+ file := app.GitCommitFile{}
+ t := ""
+ fmt.Sscanf(s.Text(), "%s %s", &t, &file.Filename)
+ switch t {
+ case "M":
+ file.Type = app.GitFileModified
+ case "A":
+ file.Type = app.GitFileAdded
+ case "R":
+ file.Type = app.GitFileRemoved
+ }
+ out.Files = append(out.Files, file)
+ }
+ first = false
+ }
+ return out, nil
+}
+
+// Command line git
+type gitCmd struct {
+ cmd string // GIT executable
+ timeout time.Duration // Timeout for commands
+}
+
+// Run git command in working directory
+func (git *gitCmd) runDirCmd(ctx context.Context, gitDir string, workDir string, args []string) (*bytes.Buffer, error) {
+ gitArgs := append([]string{"--git-dir", gitDir, "-C", workDir}, args...)
+ out, err, _ := run(ctx, git.timeout, git.cmd, gitArgs)
+ if err != nil {
+ return nil, errors.New(fmt.Sprintf("Failed to run %s %s [error %s]", git.cmd, strings.Join(gitArgs, " ")))
+ }
+ return out, nil
+}
+
+func (git *gitCmd) ProjectInfo(ctx context.Context, gitDir, workDir string) (*bytes.Buffer, error) {
+ return git.runDirCmd(ctx, gitDir, workDir, []string{"rev-parse", "--show-toplevel", "HEAD"})
+}
+func (git *gitCmd) RemoteUrl(ctx context.Context, gitDir, workDir, remote string) (*bytes.Buffer, error) {
+ return git.runDirCmd(ctx, gitDir, workDir, []string{"remote", "get-url", remote})
+}
+func (git *gitCmd) Tree(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error) {
+ cmdArgs := []string{"-c", "core.quotepath=off", "ls-tree", "--full-name", revision, "-r", "-t"}
+ return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
+}
+func (git *gitCmd) CommitInfo(ctx context.Context, gitDir, workDir, sha string) (*bytes.Buffer, error) {
+ cmdArgs := []string{"diff-tree", "-r", "-m", "--name-status", "--root", sha}
+ return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
+}
+func (git *gitCmd) DiffBranches(ctx context.Context, gitDir, workDir, upstream, sha string) (*bytes.Buffer, error) {
+ cmdArgs := []string{"diff", "--numstat", fmt.Sprintf("%s...%s", upstream, sha)}
+ return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
+}
+func NewGitCli() *gitCli {
+ cli := &gitCli{git: &gitCmd{cmd: "git", timeout: 100000 * time.Millisecond}}
+ return cli
+}
diff --git a/build/treble_build/local/git_test.go b/build/treble_build/local/git_test.go
new file mode 100644
index 0000000..d5345ae
--- /dev/null
+++ b/build/treble_build/local/git_test.go
@@ -0,0 +1,169 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 local
+
+import (
+ "bytes"
+ "context"
+ "reflect"
+ "testing"
+
+ "tools/treble/build/report/app"
+)
+
+// Test cases for local GIT.
+type TestCmd struct {
+ err error
+ text string
+}
+type gitTestCli struct {
+ revParse *TestCmd
+ remoteUrl *TestCmd
+ tree *TestCmd
+ commit *TestCmd
+ diffBranch *TestCmd
+}
+
+func (g *gitTestCli) ProjectInfo(ctx context.Context, gitDir, workDir string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(g.revParse.text), g.revParse.err
+}
+func (g *gitTestCli) RemoteUrl(ctx context.Context, gitDir, workDir, remote string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(g.remoteUrl.text), g.remoteUrl.err
+}
+func (g *gitTestCli) Tree(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(g.tree.text), g.tree.err
+}
+func (g *gitTestCli) CommitInfo(ctx context.Context, gitDir, workDir, sha string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(g.commit.text), g.tree.err
+}
+func (g *gitTestCli) DiffBranches(ctx context.Context, gitDir, workDir, upstream, sha string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(g.diffBranch.text), g.tree.err
+}
+
+func Test_git(t *testing.T) {
+
+ type projectTest struct {
+ revCmd *TestCmd
+ remoteCmd *TestCmd
+ treeCmd *TestCmd
+ res *app.GitProject
+ }
+
+ type commitTest struct {
+ sha string
+ cmd *TestCmd
+ res *app.GitCommit
+ }
+
+ tests := []struct {
+ path string
+ gitDir string
+ remote string
+ revision string
+ getFiles bool
+ project projectTest
+ commit commitTest
+ }{
+ {
+ path: "work/dir",
+ gitDir: "",
+ remote: "origin",
+ revision: "sha_revision",
+ getFiles: true,
+ project: projectTest{
+ revCmd: &TestCmd{text: "/abs/path/to/work/dir\nsha_revision\n", err: nil},
+ remoteCmd: &TestCmd{text: "http://url/workdir", err: nil},
+ treeCmd: &TestCmd{text: "", err: nil},
+ res: &app.GitProject{
+ RepoDir: "work/dir",
+ WorkDir: "/abs/path/to/work/dir",
+ GitDir: ".git",
+ Remote: "origin",
+ RemoteUrl: "http://url/workdir",
+ Revision: "sha_revision",
+ Files: make(map[string]*app.GitTreeObj)},
+ },
+ // Test empty commit
+ commit: commitTest{
+ sha: "commit_sha",
+ cmd: &TestCmd{text: "commit_sha", err: nil},
+ res: &app.GitCommit{Sha: "commit_sha", Files: []app.GitCommitFile{}},
+ },
+ },
+ {
+ path: "work/dir",
+ gitDir: "",
+ remote: "origin",
+ revision: "sha_revision",
+ getFiles: true,
+ project: projectTest{
+ revCmd: &TestCmd{text: "/abs/path/to/work/dir\nsha_revision\n", err: nil},
+ remoteCmd: &TestCmd{text: "http://url/workdir", err: nil},
+ treeCmd: &TestCmd{text: "100644 blob 0000000000000000000000000000000000000001 file.1\n", err: nil},
+ res: &app.GitProject{
+ RepoDir: "work/dir",
+ WorkDir: "/abs/path/to/work/dir",
+ GitDir: ".git",
+ Remote: "origin",
+ RemoteUrl: "http://url/workdir",
+ Revision: "sha_revision",
+ Files: map[string]*app.GitTreeObj{"file.1": &app.GitTreeObj{Permissions: "100644", Type: "blob",
+ Sha: "0000000000000000000000000000000000000001", Filename: "file.1"}}},
+ },
+ commit: commitTest{
+ sha: "HEAD",
+ cmd: &TestCmd{text: "sha_for_head\nR removed.1\nA added.1\nM modified.1\n", err: nil},
+ res: &app.GitCommit{
+ Sha: "sha_for_head",
+ Files: []app.GitCommitFile{
+ {Filename: "removed.1", Type: app.GitFileRemoved},
+ {Filename: "added.1", Type: app.GitFileAdded},
+ {Filename: "modified.1", Type: app.GitFileModified},
+ },
+ },
+ },
+ },
+ }
+ for _, test := range tests {
+ git := &gitCli{git: &gitTestCli{
+ revParse: test.project.revCmd,
+ remoteUrl: test.project.remoteCmd,
+ tree: test.project.treeCmd,
+ commit: test.commit.cmd,
+ }}
+
+ proj, err := git.Project(nil, test.path, test.gitDir, test.remote, test.revision)
+ if err != nil {
+ t.Fatal("Failed to parse project")
+ }
+ if test.getFiles {
+ _ = git.PopulateFiles(nil, proj, "")
+ }
+ if !reflect.DeepEqual(*proj, *test.project.res) {
+ t.Errorf("Project = %+v; want %+v", *proj, *test.project.res)
+ }
+ if test.commit.cmd != nil {
+ c, err := git.CommitInfo(nil, proj, test.commit.sha)
+ if err != nil {
+ t.Errorf("Failed to get; %v", test)
+ } else {
+ if !reflect.DeepEqual(*c, *test.commit.res) {
+ t.Errorf("Commit = %v; want %v", c, *test.commit.res)
+ }
+ }
+ }
+ }
+
+}
diff --git a/build/treble_build/local/ninja.go b/build/treble_build/local/ninja.go
new file mode 100644
index 0000000..012bcc7
--- /dev/null
+++ b/build/treble_build/local/ninja.go
@@ -0,0 +1,291 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 local
+
+import (
+ "bufio"
+ "bytes"
+ "context"
+ "io"
+ "io/ioutil"
+ "strings"
+ "time"
+
+ "tools/treble/build/report/app"
+)
+
+// Performance degrades running multiple CLIs
+const MaxNinjaCliWorkers = 4
+
+// Separate out the executable to allow tests to override the results
+type ninjaExec interface {
+ Command(ctx context.Context, target string) (*bytes.Buffer, error)
+ Input(ctx context.Context, target string) (*bytes.Buffer, error)
+ Query(ctx context.Context, target string) (*bytes.Buffer, error)
+ Path(ctx context.Context, target string, dependency string) (*bytes.Buffer, error)
+ Paths(ctx context.Context, target string, dependency string) (*bytes.Buffer, error)
+ Deps(ctx context.Context) (*bytes.Buffer, error)
+ Build(ctx context.Context, target string) (*bytes.Buffer, error)
+}
+
+// Parse data
+
+// Add all lines to a given array removing any leading whitespace
+func linesToArray(s *bufio.Scanner, arr *[]string) {
+ for s.Scan() {
+ line := strings.TrimSpace(s.Text())
+ *arr = append(*arr, line)
+ }
+}
+
+// parse -t commands
+func parseCommand(target string, data *bytes.Buffer) (*app.BuildCommand, error) {
+ out := &app.BuildCommand{Target: target, Cmds: []string{}}
+ s := bufio.NewScanner(data)
+ // This tool returns all the commands needed to build a target.
+ // When running against a target like droid the default capacity
+ // will be overrun. Extend the capacity here.
+ const capacity = 1024 * 1024
+ buf := make([]byte, capacity)
+ s.Buffer(buf, capacity)
+ linesToArray(s, &out.Cmds)
+ return out, nil
+}
+
+// parse -t inputs
+func parseInput(target string, data *bytes.Buffer) (*app.BuildInput, error) {
+ out := &app.BuildInput{Target: target, Files: []string{}}
+ s := bufio.NewScanner(data)
+ linesToArray(s, &out.Files)
+ return out, nil
+}
+
+// parse -t query
+func parseQuery(target string, data *bytes.Buffer) (*app.BuildQuery, error) {
+ out := &app.BuildQuery{Target: target, Inputs: []string{}, Outputs: []string{}}
+ const (
+ unknown = iota
+ inputs
+ outputs
+ )
+ state := unknown
+ s := bufio.NewScanner(data)
+ for s.Scan() {
+ line := strings.TrimSpace(s.Text())
+ if strings.HasPrefix(line, "input:") {
+ state = inputs
+ } else if strings.HasPrefix(line, "outputs:") {
+ state = outputs
+ } else {
+ switch state {
+ case inputs:
+ out.Inputs = append(out.Inputs, line)
+ case outputs:
+ out.Outputs = append(out.Outputs, line)
+ }
+ }
+ }
+ return out, nil
+}
+
+// parse -t path
+func parsePath(target string, dependency string, data *bytes.Buffer) (*app.BuildPath, error) {
+ out := &app.BuildPath{Target: target, Dependency: dependency, Paths: []string{}}
+ s := bufio.NewScanner(data)
+ linesToArray(s, &out.Paths)
+ return out, nil
+}
+
+// parse -t paths
+func parsePaths(target string, dependency string, data *bytes.Buffer) ([]*app.BuildPath, error) {
+ out := []*app.BuildPath{}
+ s := bufio.NewScanner(data)
+ for s.Scan() {
+ path := strings.Fields(s.Text())
+ out = append(out, &app.BuildPath{Target: target, Dependency: dependency, Paths: path})
+ }
+ return out, nil
+}
+
+// parse build output
+func parseBuild(target string, data *bytes.Buffer, success bool) *app.BuildCmdResult {
+ out := &app.BuildCmdResult{Name: target, Output: []string{}}
+ s := bufio.NewScanner(data)
+ out.Success = success
+ linesToArray(s, &out.Output)
+ return out
+}
+
+// parse deps command
+func parseDeps(data *bytes.Buffer) (*app.BuildDeps, error) {
+ out := &app.BuildDeps{Targets: make(map[string][]string)}
+ s := bufio.NewScanner(data)
+ curTarget := ""
+ var deps []string
+ for s.Scan() {
+ line := strings.TrimSpace(s.Text())
+ // Check if it's a new target
+ tokens := strings.Split(line, ":")
+ if len(tokens) > 1 {
+ if curTarget != "" {
+ out.Targets[curTarget] = deps
+ }
+ deps = []string{}
+ curTarget = tokens[0]
+ } else if line != "" {
+ deps = append(deps, line)
+ }
+
+ }
+ if curTarget != "" {
+ out.Targets[curTarget] = deps
+ }
+ return out, nil
+}
+
+//
+// Command line interface to ninja binary.
+//
+// This file implements the ninja.Ninja interface by querying
+// the build graph via the ninja binary. The mapping between
+// the interface and the binary are as follows:
+// Command() -t commands
+// Input() -t inputs
+// Query() -t query
+// Path() -t path
+// Paths() -t paths
+// Deps() -t deps
+//
+//
+
+type ninjaCmd struct {
+ cmd string
+ db string
+
+ timeout time.Duration
+ buildTimeout time.Duration
+}
+
+func (n *ninjaCmd) runTool(ctx context.Context, tool string, targets []string) (out *bytes.Buffer, err error) {
+ args := append([]string{
+ "-f", n.db,
+ "-t", tool}, targets...)
+ data := []byte{}
+ err, _ = runPipe(ctx, n.timeout, n.cmd, args, func(r io.Reader) {
+ data, _ = ioutil.ReadAll(r)
+ })
+ return bytes.NewBuffer(data), err
+
+}
+func (n *ninjaCmd) Command(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "commands", []string{target})
+}
+func (n *ninjaCmd) Input(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "inputs", []string{target})
+}
+func (n *ninjaCmd) Query(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "query", []string{target})
+}
+func (n *ninjaCmd) Path(ctx context.Context, target string, dependency string) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "path", []string{target, dependency})
+}
+func (n *ninjaCmd) Paths(ctx context.Context, target string, dependency string) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "paths", []string{target, dependency})
+}
+func (n *ninjaCmd) Deps(ctx context.Context) (*bytes.Buffer, error) {
+ return n.runTool(ctx, "deps", []string{})
+}
+
+func (n *ninjaCmd) Build(ctx context.Context, target string) (*bytes.Buffer, error) {
+
+ args := append([]string{
+ "-f", n.db,
+ target})
+ data := []byte{}
+ err, _ := runPipe(ctx, n.buildTimeout, n.cmd, args, func(r io.Reader) {
+ data, _ = ioutil.ReadAll(r)
+ })
+
+ return bytes.NewBuffer(data), err
+}
+
+type ninjaCli struct {
+ n ninjaExec
+}
+
+// ninja -t commands
+func (cli *ninjaCli) Command(ctx context.Context, target string) (*app.BuildCommand, error) {
+ raw, err := cli.n.Command(ctx, target)
+ if err != nil {
+ return nil, err
+ }
+ return parseCommand(target, raw)
+}
+
+// ninja -t inputs
+func (cli *ninjaCli) Input(ctx context.Context, target string) (*app.BuildInput, error) {
+ raw, err := cli.n.Input(ctx, target)
+ if err != nil {
+ return nil, err
+ }
+ return parseInput(target, raw)
+}
+
+// ninja -t query
+func (cli *ninjaCli) Query(ctx context.Context, target string) (*app.BuildQuery, error) {
+ raw, err := cli.n.Query(ctx, target)
+ if err != nil {
+ return nil, err
+ }
+ return parseQuery(target, raw)
+}
+
+// ninja -t path
+func (cli *ninjaCli) Path(ctx context.Context, target string, dependency string) (*app.BuildPath, error) {
+ raw, err := cli.n.Path(ctx, target, dependency)
+ if err != nil {
+ return nil, err
+ }
+ return parsePath(target, dependency, raw)
+}
+
+// ninja -t paths
+func (cli *ninjaCli) Paths(ctx context.Context, target string, dependency string) ([]*app.BuildPath, error) {
+ raw, err := cli.n.Paths(ctx, target, dependency)
+ if err != nil {
+ return nil, err
+ }
+ return parsePaths(target, dependency, raw)
+}
+
+// ninja -t deps
+func (cli *ninjaCli) Deps(ctx context.Context) (*app.BuildDeps, error) {
+ raw, err := cli.n.Deps(ctx)
+ if err != nil {
+ return nil, err
+ }
+ return parseDeps(raw)
+}
+
+// Build given target
+func (cli *ninjaCli) Build(ctx context.Context, target string) *app.BuildCmdResult {
+ raw, err := cli.n.Build(ctx, target)
+ return parseBuild(target, raw, err == nil)
+
+}
+func NewNinjaCli(cmd string, db string) *ninjaCli {
+ cli := &ninjaCli{n: &ninjaCmd{cmd: cmd, db: db, timeout: 100000 * time.Millisecond, buildTimeout: 300000 * time.Millisecond}}
+ return cli
+}
diff --git a/build/treble_build/local/ninja_test.go b/build/treble_build/local/ninja_test.go
new file mode 100644
index 0000000..40e2043
--- /dev/null
+++ b/build/treble_build/local/ninja_test.go
@@ -0,0 +1,216 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 local
+
+import (
+ "bytes"
+ "context"
+ "reflect"
+ "testing"
+
+ "tools/treble/build/report/app"
+)
+
+type ninjaTest struct {
+ command *TestCmd
+ input *TestCmd
+ query *TestCmd
+ path *TestCmd
+ paths *TestCmd
+ deps *TestCmd
+ build *TestCmd
+}
+
+func (n *ninjaTest) Command(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.command.text), n.command.err
+}
+func (n *ninjaTest) Input(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.input.text), n.input.err
+}
+func (n *ninjaTest) Query(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.query.text), n.query.err
+}
+func (n *ninjaTest) Path(ctx context.Context, target string, dependency string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.path.text), n.path.err
+}
+func (n *ninjaTest) Paths(ctx context.Context, target string, dependency string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.paths.text), n.paths.err
+}
+func (n *ninjaTest) Deps(ctx context.Context) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.deps.text), n.deps.err
+}
+func (n *ninjaTest) Build(ctx context.Context, target string) (*bytes.Buffer, error) {
+ return bytes.NewBufferString(n.build.text), n.build.err
+}
+
+func Test_ninja(t *testing.T) {
+ type commandTest struct {
+ cmd *TestCmd
+ res *app.BuildCommand
+ }
+ type queryTest struct {
+ cmd *TestCmd
+ res *app.BuildQuery
+ }
+ type inputTest struct {
+ cmd *TestCmd
+ res *app.BuildInput
+ }
+ type pathTest struct {
+ cmd *TestCmd
+ res *app.BuildPath
+ }
+ type pathsTest struct {
+ cmd *TestCmd
+ res []*app.BuildPath
+ }
+ type depsTest struct {
+ cmd *TestCmd
+ res *app.BuildDeps
+ }
+ type buildTest struct {
+ cmd *TestCmd
+ res *app.BuildCmdResult
+ }
+ tests := []struct {
+ target string
+ dependency string
+ command commandTest
+ query queryTest
+ input inputTest
+ path pathTest
+ paths pathsTest
+ deps depsTest
+ build buildTest
+ }{
+ {
+ target: "test",
+ dependency: "dependency",
+ command: commandTest{
+ cmd: &TestCmd{text: " cmd1\ncmd2\n cmd3\n", err: nil},
+ res: &app.BuildCommand{Target: "test", Cmds: []string{"cmd1", "cmd2", "cmd3"}}},
+ query: queryTest{
+ cmd: &TestCmd{text: "input:\ninfile\noutputs:\noutfile\n", err: nil},
+ res: &app.BuildQuery{Target: "test", Inputs: []string{"infile"}, Outputs: []string{"outfile"}}},
+ input: inputTest{
+ cmd: &TestCmd{text: "file1\nfile2\nfile3\nfile4\nfile5\n", err: nil},
+ res: &app.BuildInput{Target: "test", Files: []string{"file1", "file2", "file3", "file4", "file5"}},
+ },
+ path: pathTest{
+ cmd: &TestCmd{text: "test\nmid1\nmid2\nmid3\ndependency\n", err: nil},
+ res: &app.BuildPath{Target: "test", Dependency: "dependency",
+ Paths: []string{"test", "mid1", "mid2", "mid3", "dependency"}},
+ },
+ paths: pathsTest{
+ cmd: &TestCmd{text: "test mid1 mid2 mid3 dependency\ntest mid4 dependency\n", err: nil},
+ res: []*app.BuildPath{
+ &app.BuildPath{Target: "test", Dependency: "dependency", Paths: []string{"test", "mid1", "mid2", "mid3", "dependency"}},
+ &app.BuildPath{Target: "test", Dependency: "dependency", Paths: []string{"test", "mid4", "dependency"}},
+ },
+ },
+ deps: depsTest{
+ cmd: &TestCmd{text: "some/build/library.so: #deps1\n dependentFile1.S\n dependentFile2.S\nsome/build/library2.so: #deps1\n dependentFile1.S\n dependentFile3.S\n"},
+ res: &app.BuildDeps{Targets: map[string][]string{
+ "some/build/library.so": []string{"dependentFile1.S", "dependentFile2.S"},
+ "some/build/library2.so": []string{"dependentFile1.S", "dependentFile3.S"},
+ },
+ },
+ },
+ build: buildTest{
+ cmd: &TestCmd{text: "", err: nil},
+ res: &app.BuildCmdResult{Name: "test", Output: []string{}, Success: true}},
+ },
+ }
+ for _, test := range tests {
+
+ exec := &ninjaTest{
+ command: test.command.cmd,
+ query: test.query.cmd,
+ input: test.input.cmd,
+ path: test.path.cmd,
+ paths: test.paths.cmd,
+ deps: test.deps.cmd,
+ build: test.build.cmd,
+ }
+ n := &ninjaCli{n: exec}
+
+ if test.command.cmd != nil {
+ if res, err := n.Command(nil, test.target); err != nil {
+ t.Errorf("Command error %s", err)
+ } else {
+ if !reflect.DeepEqual(*res, *test.command.res) {
+ t.Errorf("Command result %v; want %v", *res, *test.command.res)
+ }
+ }
+ }
+ if test.query.cmd != nil {
+ if res, err := n.Query(nil, test.target); err != nil {
+ t.Errorf("Query error %s", err)
+ } else {
+ if !reflect.DeepEqual(*res, *test.query.res) {
+ t.Errorf("Query result %v; want %v", *res, *test.query.res)
+ }
+ }
+
+ }
+ if test.input.cmd != nil {
+ if res, err := n.Input(nil, test.target); err != nil {
+ t.Errorf("Input error %s", err)
+ } else {
+ if !reflect.DeepEqual(*res, *test.input.res) {
+ t.Errorf("Input result %v; want %v", *res, *test.input.res)
+ }
+ }
+
+ }
+ if test.path.cmd != nil {
+ if res, err := n.Path(nil, test.target, test.dependency); err != nil {
+ t.Errorf("Path error %s", err)
+ } else {
+ if !reflect.DeepEqual(*res, *test.path.res) {
+ t.Errorf("Path result %v; want %v", *res, *test.path.res)
+ }
+ }
+
+ }
+ if test.paths.cmd != nil {
+ if res, err := n.Paths(nil, test.target, test.dependency); err != nil {
+ t.Errorf("Paths error %s", err)
+ } else {
+ if !reflect.DeepEqual(res, test.paths.res) {
+ t.Errorf("Paths result %v; want %v", res, test.paths.res)
+ }
+ }
+
+ }
+ if test.deps.cmd != nil {
+ if res, err := n.Deps(nil); err != nil {
+ t.Errorf("Deps error %s", err)
+ } else {
+ if !reflect.DeepEqual(res, test.deps.res) {
+ t.Errorf("Deps result %v; want %v", res, test.deps.res)
+ }
+ }
+
+ }
+ if test.build.cmd != nil {
+ res := n.Build(nil, test.target)
+ if !reflect.DeepEqual(*res, *test.build.res) {
+ t.Errorf("Build result %+v; want %+v", *res, *test.build.res)
+ }
+
+ }
+ }
+}
diff --git a/build/treble_build/report/Android.bp b/build/treble_build/report/Android.bp
new file mode 100644
index 0000000..32ffea4
--- /dev/null
+++ b/build/treble_build/report/Android.bp
@@ -0,0 +1,39 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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 {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "tools_treble_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ default_applicable_licenses: ["tools_treble_license"],
+}
+
+bootstrap_go_package {
+ name: "treble_report_module",
+ srcs: [
+ "dependencies.go",
+ "build.go",
+ "projects.go",
+ "run.go",
+ "types.go",
+ ],
+ testSrcs: [
+ "report_test.go",
+ ],
+ deps: ["treble_report_app"],
+ pkgPath: "tools/treble/build/report/report",
+ pluginFor: ["soong_build"],
+}
diff --git a/build/treble_build/report/build.go b/build/treble_build/report/build.go
new file mode 100644
index 0000000..cc0c9bf
--- /dev/null
+++ b/build/treble_build/report/build.go
@@ -0,0 +1,182 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "context"
+ "fmt"
+ "sync"
+
+ "tools/treble/build/report/app"
+)
+
+// Channel data structures, include explicit error field to reply to each input
+type buildTargetData struct {
+ input *app.BuildInput
+ buildSteps int
+ error bool
+}
+type buildSourceData struct {
+ source string
+ query *app.BuildQuery
+ error bool
+}
+type buildPathData struct {
+ filename string
+ path *app.BuildPath
+ error bool
+}
+
+//
+// create build target from using repo data
+//
+func createBuildTarget(ctx context.Context, rtx *Context, buildTarget *buildTargetData) *app.BuildTarget {
+ out := &app.BuildTarget{Name: buildTarget.input.Target,
+ Steps: buildTarget.buildSteps,
+ Projects: make(map[string]*app.GitProject),
+ FileCount: len(buildTarget.input.Files),
+ }
+
+ for _, f := range buildTarget.input.Files {
+ proj, buildFile := lookupProjectFile(ctx, rtx, f)
+ if buildFile != nil {
+ if buildProj, exists := out.Projects[proj.Name]; exists {
+ buildProj.Files[buildFile.Filename] = buildFile
+ } else {
+ out.Projects[proj.Name] =
+ &app.GitProject{
+ RepoDir: proj.GitProj.RepoDir,
+ WorkDir: proj.GitProj.WorkDir,
+ GitDir: proj.GitProj.GitDir,
+ Remote: proj.GitProj.Remote,
+ RemoteUrl: proj.GitProj.RemoteUrl,
+ Revision: proj.GitProj.Revision,
+ Files: map[string]*app.GitTreeObj{buildFile.Filename: buildFile}}
+ }
+ }
+ }
+ return (out)
+}
+
+// Setup routines to resolve target names to app.BuildInput objects
+func targetResolvers(ctx context.Context, rtx *Context) (chan string, chan *buildTargetData) {
+ var wg sync.WaitGroup
+ inChan := make(chan string)
+ outChan := make(chan *buildTargetData)
+ for i := 0; i < rtx.BuildWorkerCount; i++ {
+ wg.Add(1)
+ go func() {
+ for targetName := range inChan {
+ var buildSteps int
+ cmds, err := rtx.Build.Command(ctx, targetName)
+ if err == nil {
+ buildSteps = len(cmds.Cmds)
+ }
+ input, err := rtx.Build.Input(ctx, targetName)
+ if input == nil {
+ fmt.Printf("Failed to get input %s (%s)\n", targetName, err)
+ } else {
+ outChan <- &buildTargetData{input: input, buildSteps: buildSteps, error: err != nil}
+ }
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ wg.Wait()
+ close(outChan)
+ }()
+
+ return inChan, outChan
+}
+
+//
+// Setup routines to resolve build input targets to BuildTarget
+func resolveBuildInputs(ctx context.Context, rtx *Context, inChan chan *buildTargetData) chan *app.BuildTarget {
+ var wg sync.WaitGroup
+ outChan := make(chan *app.BuildTarget)
+ for i := 0; i < rtx.BuildWorkerCount; i++ {
+ wg.Add(1)
+ go func() {
+ for buildTarget := range inChan {
+ outChan <- createBuildTarget(ctx, rtx, buildTarget)
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ wg.Wait()
+ close(outChan)
+ }()
+ return outChan
+}
+
+// Setup routines to resolve source file to query
+func queryResolvers(ctx context.Context, rtx *Context) (chan string, chan *buildSourceData) {
+ var wg sync.WaitGroup
+ inChan := make(chan string)
+ outChan := make(chan *buildSourceData)
+ for i := 0; i < rtx.BuildWorkerCount; i++ {
+ wg.Add(1)
+ go func() {
+ for srcName := range inChan {
+ query, err := rtx.Build.Query(ctx, srcName)
+ outChan <- &buildSourceData{source: srcName, query: query, error: err != nil}
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ wg.Wait()
+ close(outChan)
+ }()
+
+ return inChan, outChan
+}
+
+// Setup routines to resolve paths
+func pathsResolvers(ctx context.Context, rtx *Context, target string, singlePath bool) (chan string, chan *buildPathData) {
+ var wg sync.WaitGroup
+ inChan := make(chan string)
+ outChan := make(chan *buildPathData)
+ for i := 0; i < rtx.BuildWorkerCount; i++ {
+ wg.Add(1)
+ go func() {
+ for dep := range inChan {
+ if singlePath {
+ path, err := rtx.Build.Path(ctx, target, dep)
+ outChan <- &buildPathData{filename: dep, path: path, error: err != nil}
+ } else {
+ paths, err := rtx.Build.Paths(ctx, target, dep)
+ if err != nil {
+ outChan <- &buildPathData{filename: dep, path: nil, error: true}
+ } else {
+ for _, path := range paths {
+
+ outChan <- &buildPathData{filename: dep, path: path, error: false}
+ }
+ }
+ }
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ wg.Wait()
+ close(outChan)
+ }()
+
+ return inChan, outChan
+}
diff --git a/build/treble_build/report/dependencies.go b/build/treble_build/report/dependencies.go
new file mode 100644
index 0000000..f2b21b5
--- /dev/null
+++ b/build/treble_build/report/dependencies.go
@@ -0,0 +1,40 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "context"
+
+ "tools/treble/build/report/app"
+)
+
+type BuildDependencies interface {
+ Command(ctx context.Context, target string) (*app.BuildCommand, error)
+ Input(ctx context.Context, target string) (*app.BuildInput, error)
+ Query(ctx context.Context, target string) (*app.BuildQuery, error)
+ Path(ctx context.Context, target string, dependency string) (*app.BuildPath, error)
+ Paths(ctx context.Context, target string, dependency string) ([]*app.BuildPath, error)
+ Deps(ctx context.Context) (*app.BuildDeps, error)
+}
+
+type ProjectDependencies interface {
+ Project(ctx context.Context, path string, gitDir string, remote string, revision string) (*app.GitProject, error)
+ PopulateFiles(ctx context.Context, proj *app.GitProject, upstream string) error
+ CommitInfo(ctx context.Context, proj *app.GitProject, sha string) (*app.GitCommit, error)
+}
+
+type RepoDependencies interface {
+ Manifest(filename string) (*app.RepoManifest, error)
+}
diff --git a/build/treble_build/report/projects.go b/build/treble_build/report/projects.go
new file mode 100644
index 0000000..eaec5bf
--- /dev/null
+++ b/build/treble_build/report/projects.go
@@ -0,0 +1,178 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+ "sync"
+
+ "tools/treble/build/report/app"
+)
+
+//
+// Repo and project related functions
+//
+type project struct {
+ Name string // Name
+ GitProj *app.GitProject // Git project data
+}
+
+var unknownProject = &project{Name: "unknown", GitProj: &app.GitProject{}}
+
+// Convert repo project to project with source files and revision
+// information
+func resolveProject(ctx context.Context, repoProj *app.RepoProject, remote *app.RepoRemote, proj ProjectDependencies, getFiles bool, upstreamBranch string) *project {
+
+ path := repoProj.Path
+ if path == "" {
+ path = repoProj.Name
+ }
+ gitDir := ""
+ if strings.HasPrefix(path, "overlays/") {
+ // Assume two levels of overlay path (overlay/XYZ)
+ path = strings.Join(strings.Split(path, "/")[2:], "/")
+ // The overlays .git symbolic links are not mapped correctly
+ // into the jails. Resolve them here, inside the nsjail the
+ // absolute path for all git repos will be in the form of
+ // /src/.git/
+ symlink, _ := os.Readlink(filepath.Join(path, ".git"))
+ parts := strings.Split(symlink, "/")
+ repostart := 0
+ for ; repostart < len(parts); repostart++ {
+ if parts[repostart] != ".." {
+ if repostart > 1 {
+ repostart--
+ parts[repostart] = "/src"
+ }
+ break
+ }
+ }
+ gitDir = filepath.Join(parts[repostart:]...)
+
+ }
+ gitProj, err := proj.Project(ctx, path, gitDir, remote.Name, repoProj.Revision)
+ if err != nil {
+ return nil
+ }
+ out := &project{Name: repoProj.Name, GitProj: gitProj}
+ if getFiles {
+ _ = proj.PopulateFiles(ctx, gitProj, upstreamBranch)
+ }
+ return out
+}
+
+// Get the build file for a given filename, this is a two step lookup.
+// First find the project associated with the file via the file cache,
+// then resolve the file via the project found.
+//
+// Most files will be relative paths from the repo workspace
+func lookupProjectFile(ctx context.Context, rtx *Context, filename string) (*project, *app.GitTreeObj) {
+ if proj, exists := rtx.Info.FileCache[filename]; exists {
+ repoName := (filename)[len(proj.GitProj.RepoDir)+1:]
+ if gitObj, exists := proj.GitProj.Files[repoName]; exists {
+ return proj, gitObj
+ }
+ return proj, nil
+ } else {
+ // Try resolving any symlinks
+ if realpath, err := filepath.EvalSymlinks(filename); err == nil {
+ if realpath != filename {
+ return lookupProjectFile(ctx, rtx, realpath)
+ }
+ }
+
+ if strings.HasPrefix(filename, rtx.RepoBase) {
+ // Some dependencies pick up the full path try stripping out
+ relpath := (filename)[len(rtx.RepoBase):]
+ return lookupProjectFile(ctx, rtx, relpath)
+ }
+ }
+ return unknownProject, &app.GitTreeObj{Filename: filename, Sha: ""}
+}
+
+// Create a mapping of projects from the input source manifest
+func resolveProjectMap(ctx context.Context, rtx *Context, manifestFile string, getFiles bool, upstreamBranch string) *ProjectInfo {
+ // Parse the manifest file
+ manifest, err := rtx.Repo.Manifest(manifestFile)
+ if err != nil {
+ return nil
+ }
+ info := &ProjectInfo{}
+ // Create map of remotes
+ remotes := make(map[string]*app.RepoRemote)
+ var defRemotePtr *app.RepoRemote
+ for i, _ := range manifest.Remotes {
+ remotes[manifest.Remotes[i].Name] = &manifest.Remotes[i]
+ }
+
+ defRemotePtr, exists := remotes[manifest.Default.Remote]
+ if !exists {
+ fmt.Printf("Failed to find default remote")
+ }
+ info.FileCache = make(map[string]*project)
+ info.ProjMap = make(map[string]*project)
+
+ var wg sync.WaitGroup
+ projChan := make(chan *project)
+ repoChan := make(chan *app.RepoProject)
+
+ for i := 0; i < rtx.WorkerCount; i++ {
+ wg.Add(1)
+ go func() {
+ for repoProj := range repoChan {
+ remotePtr := defRemotePtr
+ if manifest.Projects[i].Remote != nil {
+ remotePtr = remotes[*manifest.Projects[i].Remote]
+ }
+ proj := resolveProject(ctx, repoProj, remotePtr, rtx.Project, getFiles, upstreamBranch)
+ if proj != nil {
+ projChan <- proj
+ } else {
+ projChan <- &project{Name: repoProj.Name}
+ }
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ wg.Wait()
+ close(projChan)
+ }()
+ go func() {
+ for i, _ := range manifest.Projects {
+ repoChan <- &manifest.Projects[i]
+ }
+ close(repoChan)
+ }()
+ for r := range projChan {
+ if r.GitProj != nil {
+ info.ProjMap[r.Name] = r
+ if len(r.GitProj.Files) > 0 {
+ for n := range r.GitProj.Files {
+ info.FileCache[filepath.Join(r.GitProj.RepoDir, n)] = r
+ }
+
+ }
+
+ } else {
+ fmt.Printf("Failed to resolve %s\n", r.Name)
+ }
+ }
+ return info
+}
diff --git a/build/treble_build/report/report_test.go b/build/treble_build/report/report_test.go
new file mode 100644
index 0000000..7aa3891
--- /dev/null
+++ b/build/treble_build/report/report_test.go
@@ -0,0 +1,266 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "testing"
+
+ "tools/treble/build/report/app"
+)
+
+type reportTest struct {
+ manifest *app.RepoManifest
+ commands map[string]*app.BuildCommand
+ inputs map[string]*app.BuildInput
+ queries map[string]*app.BuildQuery
+ paths map[string]map[string]*app.BuildPath
+ multipaths map[string]map[string][]*app.BuildPath
+ projects map[string]*app.GitProject
+ commits map[*app.GitProject]map[string]*app.GitCommit
+
+ deps *app.BuildDeps
+ projectCommits map[string]int
+}
+
+func (r *reportTest) Manifest(filename string) (*app.RepoManifest, error) {
+ var err error
+ out := r.manifest
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No manifest named %s", filename))
+ }
+ return r.manifest, err
+}
+func (r *reportTest) Command(ctx context.Context, target string) (*app.BuildCommand, error) {
+ var err error
+ out := r.commands[target]
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No command for target %s", target))
+ }
+ return out, err
+}
+
+func (r *reportTest) Input(ctx context.Context, target string) (*app.BuildInput, error) {
+ var err error
+ out := r.inputs[target]
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No inputs for target %s", target))
+ }
+ return out, err
+}
+
+func (r *reportTest) Query(ctx context.Context, target string) (*app.BuildQuery, error) {
+ var err error
+ out := r.queries[target]
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No queries for target %s", target))
+ }
+ return out, err
+}
+
+func (r *reportTest) Path(ctx context.Context, target string, dependency string) (*app.BuildPath, error) {
+ return r.paths[target][dependency], nil
+}
+
+func (r *reportTest) Paths(ctx context.Context, target string, dependency string) ([]*app.BuildPath, error) {
+ return r.multipaths[target][dependency], nil
+}
+
+func (r *reportTest) Deps(ctx context.Context) (*app.BuildDeps, error) {
+ return r.deps, nil
+}
+func (r *reportTest) Project(ctx context.Context, path string, gitDir string, remote string, revision string) (*app.GitProject, error) {
+ var err error
+ out := r.projects[path]
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No projects for target %s", path))
+ }
+ return out, err
+}
+func (r *reportTest) PopulateFiles(ctx context.Context, proj *app.GitProject, upstream string) error {
+ return nil
+}
+func (r *reportTest) CommitInfo(ctx context.Context, proj *app.GitProject, sha string) (*app.GitCommit, error) {
+ var err error
+ out := r.commits[proj][sha]
+ if out == nil {
+ err = errors.New(fmt.Sprintf("No commit for sha %s", sha))
+ }
+ return out, err
+}
+
+// Helper routine used in test function to create array of unique names
+func createStrings(name string, count int) []string {
+ var out []string
+ for i := 0; i < count; i++ {
+ out = append(out, name+strconv.Itoa(i))
+ }
+ return out
+}
+
+// Project names used in tests
+func projName(i int) string {
+ return "proj." + strconv.Itoa(i)
+}
+
+func fileName(i int) (filename string, sha string) {
+ iString := strconv.Itoa(i)
+ return "source." + iString, "sha." + iString
+}
+func createFile(i int) *app.GitTreeObj {
+ fname, sha := fileName(i)
+ return &app.GitTreeObj{Permissions: "100644", Type: "blob", Filename: fname, Sha: sha}
+}
+func createProject(name string) *app.GitProject {
+ return &app.GitProject{
+ RepoDir: name, WorkDir: name, GitDir: ".git", Remote: "origin",
+ RemoteUrl: "origin_url", Revision: name + "_sha",
+ Files: make(map[string]*app.GitTreeObj)}
+
+}
+
+// Create basic test data for given inputs
+func createTest(projCount int, fileCount int) *reportTest {
+ test := &reportTest{
+ manifest: &app.RepoManifest{
+ Remotes: []app.RepoRemote{{Name: "remote1", Revision: "revision_1"}},
+ Default: app.RepoDefault{Remote: "remote1", Revision: "revision_2"},
+ Projects: []app.RepoProject{},
+ },
+ commands: map[string]*app.BuildCommand{},
+ inputs: map[string]*app.BuildInput{},
+ queries: map[string]*app.BuildQuery{},
+ projects: map[string]*app.GitProject{},
+ commits: map[*app.GitProject]map[string]*app.GitCommit{},
+ }
+
+ // Create projects with files
+ for i := 0; i <= projCount; i++ {
+ name := projName(i)
+
+ proj := createProject(name)
+
+ for i := 0; i <= fileCount; i++ {
+ treeObj := createFile(i)
+ proj.Files[treeObj.Filename] = treeObj
+
+ }
+ test.projects[name] = proj
+ test.manifest.Projects = append(test.manifest.Projects,
+ app.RepoProject{Groups: "group", Name: name, Revision: "sha", Path: name})
+
+ }
+ return test
+}
+
+func Test_report(t *testing.T) {
+
+ test := createTest(10, 20)
+
+ // Test cases will specify input file by project and file index
+ type inputFile struct {
+ proj int
+ file int
+ }
+
+ targetDefs := []struct {
+ name string // Target name
+ cmds int // Number of build steps
+ inputTargets int // Number of input targets
+ outputTargets int // Number of output targets
+ inputFiles []inputFile // Input files for target
+ }{
+ {
+ name: "target",
+ cmds: 7,
+ inputTargets: 4,
+ outputTargets: 7,
+ inputFiles: []inputFile{{proj: 0, file: 1}, {proj: 1, file: 0}},
+ },
+ {
+ name: "target2",
+ cmds: 0,
+ inputTargets: 0,
+ outputTargets: 0,
+ inputFiles: []inputFile{{proj: 0, file: 1}, {proj: 0, file: 2}, {proj: 1, file: 0}},
+ },
+ {
+ name: "null_target",
+ cmds: 0,
+ inputTargets: 0,
+ outputTargets: 0,
+ inputFiles: []inputFile{},
+ },
+ }
+
+ // Create target data based on definitions
+ var targets []string
+
+ // Build expected output while creating the targets
+ resTargets := make(map[string]*app.BuildTarget)
+
+ for _, target := range targetDefs {
+
+ res := &app.BuildTarget{Name: target.name,
+ Steps: target.cmds,
+ FileCount: len(target.inputFiles),
+ Projects: make(map[string]*app.GitProject),
+ }
+
+ // Add files to the build target
+ var inputFiles []string
+ for _, in := range target.inputFiles {
+ // Get project by name
+ pName := projName(in.proj)
+ bf := createFile(in.file)
+ p := test.projects[pName]
+
+ inputFiles = append(inputFiles,
+ fmt.Sprintf("%s/%s", p.WorkDir, bf.Filename))
+
+ if _, exists := res.Projects[pName]; !exists {
+ res.Projects[pName] = createProject(pName)
+ }
+ res.Projects[pName].Files[bf.Filename] = bf
+ }
+
+ // Create test data
+ test.commands[target.name] = &app.BuildCommand{Target: target.name, Cmds: createStrings("cmd.", target.cmds)}
+ test.inputs[target.name] = &app.BuildInput{Target: target.name, Files: inputFiles}
+ test.queries[target.name] = &app.BuildQuery{
+ Target: target.name,
+ Inputs: createStrings("target.in.", target.inputTargets),
+ Outputs: createStrings("target.out.", target.outputTargets)}
+
+ targets = append(targets, target.name)
+ resTargets[res.Name] = res
+ }
+
+ rtx := &Context{RepoBase: "/src", Repo: test, Build: test, Project: test, WorkerCount: 1, BuildWorkerCount: 1}
+ rtx.ResolveProjectMap(nil, "test_file", "")
+ req := &app.ReportRequest{Targets: targets}
+ rsp, err := RunReport(nil, rtx, req)
+ if err != nil {
+ t.Errorf("Failed to run report for request %+v", req)
+ } else {
+ if !reflect.DeepEqual(rsp.Targets, resTargets) {
+ t.Errorf("Got targets %+v, expected %+v", rsp.Targets, resTargets)
+ }
+ }
+}
diff --git a/build/treble_build/report/run.go b/build/treble_build/report/run.go
new file mode 100644
index 0000000..fd03088
--- /dev/null
+++ b/build/treble_build/report/run.go
@@ -0,0 +1,191 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io/fs"
+ "path/filepath"
+
+ "tools/treble/build/report/app"
+)
+
+// Find all binary executables under the given directory along with the number
+// of symlinks
+//
+func binaryExecutables(ctx context.Context, dir string, recursive bool) ([]string, int, error) {
+ var files []string
+ numSymLinks := 0
+ err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+ if err != nil {
+ return err
+ }
+ if !d.IsDir() {
+ if info, err := d.Info(); err == nil {
+ if info.Mode()&0111 != 0 {
+ files = append(files, path)
+ }
+ if d.Type()&fs.ModeSymlink != 0 {
+ numSymLinks++
+ }
+ }
+ } else {
+ if !recursive {
+ if path != dir {
+ return filepath.SkipDir
+ }
+ }
+ }
+ return nil
+ })
+
+ return files, numSymLinks, err
+}
+
+// Resolve the manifest
+func (rtx *Context) ResolveProjectMap(ctx context.Context, manifest string, upstreamBranch string) {
+ if rtx.Info == nil {
+ rtx.Info = resolveProjectMap(ctx, rtx, manifest, true, upstreamBranch)
+ }
+}
+
+// Find host tools
+func ResolveHostTools(ctx context.Context, hostToolPath string) (*app.HostReport, error) {
+ out := &app.HostReport{Path: hostToolPath}
+ out.Targets, out.SymLinks, _ = binaryExecutables(ctx, hostToolPath, true)
+ return out, nil
+}
+
+// Run reports
+
+//
+// Run report request
+//
+// Setup routines to:
+// - resolve the manifest projects
+// - resolve build queries
+//
+// Once the manifest projects have been resolved the build
+// queries can be fully resolved
+//
+func RunReport(ctx context.Context, rtx *Context, req *app.ReportRequest) (*app.Report, error) {
+ inChan, targetCh := targetResolvers(ctx, rtx)
+ go func() {
+ for i, _ := range req.Targets {
+ inChan <- req.Targets[i]
+ }
+ close(inChan)
+ }()
+
+ // Resolve the build inputs into build target projects
+ buildTargetChan := resolveBuildInputs(ctx, rtx, targetCh)
+
+ out := &app.Report{Targets: make(map[string]*app.BuildTarget)}
+ for bt := range buildTargetChan {
+ out.Targets[bt.Name] = bt
+ }
+
+ return out, nil
+}
+
+// Resolve commit into git commit info
+func ResolveCommit(ctx context.Context, rtx *Context, commit *app.ProjectCommit) (*app.GitCommit, []string, error) {
+ if proj, exists := rtx.Info.ProjMap[commit.Project]; exists {
+ info, err := rtx.Project.CommitInfo(ctx, proj.GitProj, commit.Revision)
+ files := []string{}
+ if err == nil {
+ for _, f := range info.Files {
+ if f.Type != app.GitFileRemoved {
+ files = append(files, filepath.Join(proj.GitProj.RepoDir, f.Filename))
+ }
+ }
+ }
+ return info, files, err
+ }
+ return nil, nil, errors.New(fmt.Sprintf("Unknown project %s", commit.Project))
+
+}
+
+// Run query report based on the input request.
+//
+// For each input file query the target and
+// create a set of the inputs and outputs associated
+// with all the input files.
+//
+//
+func RunQuery(ctx context.Context, rtx *Context, req *app.QueryRequest) (*app.QueryResponse, error) {
+ inChan, queryCh := queryResolvers(ctx, rtx)
+
+ go func() {
+ // Convert source files to outputs
+ for _, target := range req.Files {
+ inChan <- target
+ }
+ close(inChan)
+ }()
+
+ inFiles := make(map[string]bool)
+ outFiles := make(map[string]bool)
+ unknownSrcFiles := make(map[string]bool)
+ for result := range queryCh {
+ if result.error {
+ unknownSrcFiles[result.source] = true
+ } else {
+ for _, outFile := range result.query.Outputs {
+ outFiles[outFile] = true
+ }
+ for _, inFile := range result.query.Inputs {
+ inFiles[inFile] = true
+ }
+
+ }
+ }
+
+ out := &app.QueryResponse{}
+ for k, _ := range outFiles {
+ out.OutputFiles = append(out.OutputFiles, k)
+ }
+ for k, _ := range inFiles {
+ out.InputFiles = append(out.InputFiles, k)
+ }
+ for k, _ := range unknownSrcFiles {
+ out.UnknownFiles = append(out.UnknownFiles, k)
+ }
+
+ return out, nil
+}
+
+// Get paths
+func RunPaths(ctx context.Context, rtx *Context, target string, singlePath bool, files []string) []*app.BuildPath {
+ out := []*app.BuildPath{}
+ inChan, pathCh := pathsResolvers(ctx, rtx, target, singlePath)
+ // Convert source files to outputs
+ go func() {
+ for _, f := range files {
+ inChan <- f
+ }
+ close(inChan)
+ }()
+
+ for result := range pathCh {
+ if !result.error {
+ out = append(out, result.path)
+ }
+ }
+ return out
+
+}
diff --git a/build/treble_build/report/types.go b/build/treble_build/report/types.go
new file mode 100644
index 0000000..8610d43
--- /dev/null
+++ b/build/treble_build/report/types.go
@@ -0,0 +1,45 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 report
+
+import (
+ "tools/treble/build/report/app"
+)
+
+type RepoMan struct {
+}
+
+func (r *RepoMan) Manifest(filename string) (*app.RepoManifest, error) {
+ return app.ParseXml(filename)
+}
+
+// Project information containing a map of projects, this also contains a
+// map between a source file and the project it belongs to
+// allowing a quicker lookup of source file to project
+type ProjectInfo struct {
+ ProjMap map[string]*project // Map project name to project
+ FileCache map[string]*project // Map source files to project
+}
+
+// Report context
+type Context struct {
+ RepoBase string // Absolute path to repo base
+ Repo RepoDependencies // Repo interface
+ Build BuildDependencies // Build interface
+ Project ProjectDependencies // Project interface
+ WorkerCount int // Number of worker threads
+ BuildWorkerCount int // Number of build worker threads
+ Info *ProjectInfo // Project information
+}
diff --git a/gki/repack_gki.py b/gki/repack_gki.py
index 90b632e..19c11cb 100644
--- a/gki/repack_gki.py
+++ b/gki/repack_gki.py
@@ -17,13 +17,14 @@
help='JSON keyfile containing credentials. '
'(Default: Use default credential file)')
parser.add_argument(
- '--ramdisk_build_id',
- required=True,
- help='Download from the specified build.')
+ '--bootimg_build_id', help='Download from the specified build.')
parser.add_argument(
- '--ramdisk_target',
- required=True,
- help='Name of the ramdisk target from the ramdisk branch.')
+ '--ramdisk_build_id', help='DEPRECATED. Use --bootimg_build_id instead.')
+ parser.add_argument(
+ '--bootimg_target',
+ help='Name of the bootimg target from the bootimg branch.')
+ parser.add_argument(
+ '--ramdisk_target', help='DEPRECATED. Use --bootimg_target instead.')
parser.add_argument(
'--kernel_build_id',
required=True,
@@ -50,15 +51,18 @@
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
+ bootimg_build_id = args.bootimg_build_id or args.ramdisk_build_id
+ bootimg_target = args.bootimg_target or args.ramdisk_target
+
with tempfile.TemporaryDirectory() as tmp_bootimg_dir, \
tempfile.TemporaryDirectory() as tmp_kernel_dir:
# Fetch boot images.
repack_gki_lib.fetch_bootimg(
client=client,
out_dir=tmp_bootimg_dir,
- build_id=args.ramdisk_build_id,
+ build_id=bootimg_build_id,
kernel_version=args.kernel_version,
- target=args.ramdisk_target,
+ target=bootimg_target,
)
# Fetch kernel artifacts.
@@ -84,6 +88,7 @@
copy_kernel_file(kernel_dir, 'System.map')
copy_kernel_file(kernel_dir, 'abi_symbollist')
copy_kernel_file(kernel_dir, 'vmlinux')
+ copy_kernel_file(kernel_dir, 'vmlinux.symvers')
copy_kernel_file(kernel_dir, 'Image',
'kernel-{}'.format(args.kernel_version))
copy_kernel_file(kernel_dir, 'Image.lz4',
@@ -99,6 +104,8 @@
'kernel-{}-lz4-allsyms'.format(args.kernel_version))
copy_kernel_file(kernel_debug_dir, 'Image.gz',
'kernel-{}-gz-allsyms'.format(args.kernel_version))
+ copy_kernel_file(kernel_debug_dir, 'vmlinux', 'vmlinux-allsyms')
+ copy_kernel_file(kernel_debug_dir, 'vmlinux.symvers', 'vmlinux.symvers-allsyms')
# Repack individual boot images using the fetched kernel artifacts,
# then save to the out dir.
@@ -113,24 +120,20 @@
args.kernel_version)
shutil.copy(img_zip_path, args.out_dir)
- # Replace kernels within the target_files.zip and save to the out dir.
- # TODO(b/209035444): GSI target_files does not yet include a 5.15 boot.img.
- if args.kernel_version != '5.15':
- target_files_zip_name = [
- f for f in os.listdir(tmp_bootimg_dir) if '-target_files-' in f
- ][0]
- target_files_zip_path = os.path.join(tmp_bootimg_dir, target_files_zip_name)
- repack_gki_lib.replace_target_files_zip_kernels(target_files_zip_path,
- kernel_out_dir,
- args.kernel_version)
- shutil.copy(target_files_zip_path, args.out_dir)
+ target_files_zip_name = [
+ f for f in os.listdir(tmp_bootimg_dir) if '-target_files-' in f
+ ][0]
+ target_files_zip_path = os.path.join(tmp_bootimg_dir, target_files_zip_name)
+ repack_gki_lib.replace_target_files_zip_kernels(target_files_zip_path,
+ kernel_out_dir,
+ args.kernel_version)
+ shutil.copy(target_files_zip_path, args.out_dir)
- # Copy otatools.zip from the ramdisk build, used for GKI signing.
+ # Copy otatools.zip from the bootimg build, used for GKI signing.
shutil.copy(os.path.join(tmp_bootimg_dir, 'otatools.zip'), args.out_dir)
# Write prebuilt-info.txt using the prebuilt artifact build IDs.
data = {
- 'ramdisk-build-id': int(args.ramdisk_build_id),
'kernel-build-id': int(args.kernel_build_id),
}
with open(os.path.join(kernel_out_dir, 'prebuilt-info.txt'), 'w') as f:
diff --git a/gki/repack_gki_lib.py b/gki/repack_gki_lib.py
index 9051a65..ccabb94 100644
--- a/gki/repack_gki_lib.py
+++ b/gki/repack_gki_lib.py
@@ -13,7 +13,7 @@
client=client,
build_id=build_id,
target=target,
- pattern=r'(gsi_.*-img-.*\.zip|gsi_.*-target_files-.*\.zip|boot-debug-{version}.*\.img|boot-test-harness-{version}.*\.img|otatools.zip)'
+ pattern=r'(gki_.*-img-.*\.zip|gki_.*-target_files-.*\.zip|otatools.zip)'
.format(version=kernel_version),
out_dir=out_dir)
@@ -29,13 +29,13 @@
client=client,
build_id=build_id,
target=kernel_target,
- pattern=r'(Image|Image.lz4|System\.map|abi_symbollist|vmlinux)',
+ pattern=r'(Image|Image.lz4|System\.map|abi_symbollist|vmlinux|vmlinux.symvers)',
out_dir=kernel_dir)
fetcher_lib.fetch_artifacts(
client=client,
build_id=build_id,
target=kernel_debug_target,
- pattern=r'(Image|Image.lz4|System\.map|abi-generated.xml|abi-full-generated.xml)',
+ pattern=r'(Image|Image.lz4|System\.map|abi-generated.xml|abi-full-generated.xml|vmlinux|vymlinx.symvers)',
out_dir=kernel_debug_dir)
print('Compressing kernels')
@@ -107,10 +107,6 @@
def repack_img_zip(img_zip_path, kernel_dir, kernel_debug_dir, kernel_version):
"""Repacks boot images within an img.zip archive."""
with tempfile.TemporaryDirectory() as unzip_dir:
- # TODO(b/209035444): 5.15 GSI boot.img is not yet available, so reuse 5.10 boot.img
- # which should have an identical ramdisk.
- if kernel_version == '5.15':
- kernel_version = '5.10'
pattern = 'boot-{}*'.format(kernel_version)
print('Unzipping %s to repack bootimgs' % img_zip_path)
cmd = [
