| // 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 |
| |
| } |