| // 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" |
| "time" |
| |
| "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") |
| ninjaTimeoutStr = flag.String("ninja_timeout", local.DefaultNinjaTimeout, "Default ninja timeout") |
| buildTimeoutStr = flag.String("build_timeout", local.DefaultNinjaBuildTimeout, "Default build timeout") |
| 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") |
| clientServerPtr = flag.Bool("client_server", false, "Run client server mode") |
| 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") |
| projsPtr = flag.Bool("projects", false, "Include project repo data") |
| |
| hostFlags = flag.NewFlagSet("host", flag.ExitOnError) |
| queryFlags = flag.NewFlagSet("query", flag.ExitOnError) |
| pathsFlags = flag.NewFlagSet("paths", flag.ExitOnError) |
| ) |
| |
| // Add profiling data |
| type profTime struct { |
| Description string `json:"description"` |
| DurationSecs float64 `json:"duration"` |
| } |
| |
| 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"` |
| Projects map[string]*app.GitProject `json:"projects,omitempty"` |
| // Profile data |
| Profile []*profTime `json:"profile"` |
| } |
| |
| func main() { |
| startTime := time.Now() |
| ctx := context.Background() |
| rsp := &response{} |
| |
| var addProfileData = func(desc string) { |
| rsp.Profile = append(rsp.Profile, &profTime{Description: desc, DurationSecs: time.Since(startTime).Seconds()}) |
| startTime = time.Now() |
| } |
| flag.Parse() |
| |
| ninjaTimeout, err := time.ParseDuration(*ninjaTimeoutStr) |
| if err != nil { |
| log.Fatalf("Invalid ninja timeout %s", *ninjaTimeoutStr) |
| } |
| |
| buildTimeout, err := time.ParseDuration(*buildTimeoutStr) |
| if err != nil { |
| log.Fatalf("Invalid build timeout %s", *buildTimeoutStr) |
| } |
| |
| subArgs := flag.Args() |
| defBuildTarget := "droid" |
| log.SetFlags(log.LstdFlags | log.Llongfile) |
| |
| ninja := local.NewNinjaCli(*ninjaExcPtr, *ninjaDbPtr, ninjaTimeout, buildTimeout, *clientServerPtr) |
| |
| if *clientServerPtr { |
| ninjaServ := local.NewNinjaServer(*ninjaExcPtr, *ninjaDbPtr) |
| defer ninjaServ.Kill() |
| go func() { |
| |
| ninjaServ.Start(ctx) |
| }() |
| if err := ninja.WaitForServer(ctx, int(ninjaTimeout.Seconds())); err != nil { |
| log.Fatalf("Failed to connect to server") |
| } |
| } |
| rtx := &report.Context{ |
| RepoBase: *repoBasePtr, |
| Repo: &report.RepoMan{}, |
| Build: ninja, |
| Project: local.NewGitCli(), |
| WorkerCount: *workerCountPtr, |
| BuildWorkerCount: *buildWorkerCountPtr, |
| } |
| |
| var subcommand tool |
| var commits repoFlags |
| if len(subArgs) > 0 { |
| 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.Inputs = pathsFlags.Args() |
| |
| default: |
| rsp.Targets = subArgs |
| } |
| } |
| addProfileData("Init") |
| rtx.ResolveProjectMap(ctx, *manifestPtr, *upstreamPtr) |
| addProfileData("Project Map") |
| |
| // Add project to output if requested |
| if *projsPtr == true { |
| rsp.Projects = make(map[string]*app.GitProject) |
| for k, p := range rtx.Info.ProjMap { |
| rsp.Projects[k] = p.GitProj |
| } |
| } |
| |
| // 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...) |
| } |
| addProfileData("Commit Resolution") |
| } |
| |
| // Run any sub tools |
| if subcommand != nil { |
| if err := subcommand.Run(ctx, rtx, rsp); err != nil { |
| log.Fatal(err) |
| } |
| addProfileData(subArgs[0]) |
| } |
| |
| buildErrors := 0 |
| if *buildPtr { |
| // Only support default builder (non server-client) |
| builder := local.NewNinjaCli(local.DefNinjaExc(), *ninjaDbPtr, ninjaTimeout, buildTimeout, false /*clientMode*/) |
| for _, t := range rsp.Targets { |
| log.Printf("Building %s\n", t) |
| res := builder.Build(ctx, t) |
| addProfileData(fmt.Sprintf("Build %s", t)) |
| log.Printf("%s\n", res.Output) |
| if res.Success != true { |
| buildErrors++ |
| } |
| rsp.BuildFiles = append(rsp.BuildFiles, res) |
| } |
| } |
| |
| // Generate report |
| log.Printf("Generating report for targets %s", rsp.Targets) |
| req := &app.ReportRequest{Targets: rsp.Targets} |
| rsp.Report, err = report.RunReport(ctx, rtx, req) |
| addProfileData("Report") |
| 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) |
| } |
| |
| fmt.Fprintln(w, " Run Times") |
| for _, p := range rsp.Profile { |
| fmt.Fprintf(w, " %-30s : %f secs\n", p.Description, p.DurationSecs) |
| } |
| |
| } |
