Quelle  run.go   Sprache: unbekannt

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

}