1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279 |
- // Copyright 2018 Google Inc. All rights reserved.
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
- package android
- import (
- "crypto/sha256"
- "fmt"
- "path/filepath"
- "sort"
- "strings"
- "testing"
- "github.com/golang/protobuf/proto"
- "github.com/google/blueprint"
- "github.com/google/blueprint/proptools"
- "android/soong/cmd/sbox/sbox_proto"
- "android/soong/remoteexec"
- "android/soong/response"
- "android/soong/shared"
- )
- const sboxSandboxBaseDir = "__SBOX_SANDBOX_DIR__"
- const sboxOutSubDir = "out"
- const sboxToolsSubDir = "tools"
- const sboxOutDir = sboxSandboxBaseDir + "/" + sboxOutSubDir
- // RuleBuilder provides an alternative to ModuleContext.Rule and ModuleContext.Build to add a command line to the build
- // graph.
- type RuleBuilder struct {
- pctx PackageContext
- ctx BuilderContext
- commands []*RuleBuilderCommand
- installs RuleBuilderInstalls
- temporariesSet map[WritablePath]bool
- restat bool
- sbox bool
- highmem bool
- remoteable RemoteRuleSupports
- rbeParams *remoteexec.REParams
- outDir WritablePath
- sboxTools bool
- sboxInputs bool
- sboxManifestPath WritablePath
- missingDeps []string
- }
- // NewRuleBuilder returns a newly created RuleBuilder.
- func NewRuleBuilder(pctx PackageContext, ctx BuilderContext) *RuleBuilder {
- return &RuleBuilder{
- pctx: pctx,
- ctx: ctx,
- temporariesSet: make(map[WritablePath]bool),
- }
- }
- // RuleBuilderInstall is a tuple of install from and to locations.
- type RuleBuilderInstall struct {
- From Path
- To string
- }
- type RuleBuilderInstalls []RuleBuilderInstall
- // String returns the RuleBuilderInstalls in the form used by $(call copy-many-files) in Make, a space separated
- // list of from:to tuples.
- func (installs RuleBuilderInstalls) String() string {
- sb := strings.Builder{}
- for i, install := range installs {
- if i != 0 {
- sb.WriteRune(' ')
- }
- sb.WriteString(install.From.String())
- sb.WriteRune(':')
- sb.WriteString(install.To)
- }
- return sb.String()
- }
- // MissingDeps adds modules to the list of missing dependencies. If MissingDeps
- // is called with a non-empty input, any call to Build will result in a rule
- // that will print an error listing the missing dependencies and fail.
- // MissingDeps should only be called if Config.AllowMissingDependencies() is
- // true.
- func (r *RuleBuilder) MissingDeps(missingDeps []string) {
- r.missingDeps = append(r.missingDeps, missingDeps...)
- }
- // Restat marks the rule as a restat rule, which will be passed to ModuleContext.Rule in BuildParams.Restat.
- //
- // Restat is not compatible with Sbox()
- func (r *RuleBuilder) Restat() *RuleBuilder {
- if r.sbox {
- panic("Restat() is not compatible with Sbox()")
- }
- r.restat = true
- return r
- }
- // HighMem marks the rule as a high memory rule, which will limit how many run in parallel with other high memory
- // rules.
- func (r *RuleBuilder) HighMem() *RuleBuilder {
- r.highmem = true
- return r
- }
- // Remoteable marks the rule as supporting remote execution.
- func (r *RuleBuilder) Remoteable(supports RemoteRuleSupports) *RuleBuilder {
- r.remoteable = supports
- return r
- }
- // Rewrapper marks the rule as running inside rewrapper using the given params in order to support
- // running on RBE. During RuleBuilder.Build the params will be combined with the inputs, outputs
- // and tools known to RuleBuilder to prepend an appropriate rewrapper command line to the rule's
- // command line.
- func (r *RuleBuilder) Rewrapper(params *remoteexec.REParams) *RuleBuilder {
- if !r.sboxInputs {
- panic(fmt.Errorf("RuleBuilder.Rewrapper must be called after RuleBuilder.SandboxInputs"))
- }
- r.rbeParams = params
- return r
- }
- // Sbox marks the rule as needing to be wrapped by sbox. The outputDir should point to the output
- // directory that sbox will wipe. It should not be written to by any other rule. manifestPath should
- // point to a location where sbox's manifest will be written and must be outside outputDir. sbox
- // will ensure that all outputs have been written, and will discard any output files that were not
- // specified.
- //
- // Sbox is not compatible with Restat()
- func (r *RuleBuilder) Sbox(outputDir WritablePath, manifestPath WritablePath) *RuleBuilder {
- if r.sbox {
- panic("Sbox() may not be called more than once")
- }
- if len(r.commands) > 0 {
- panic("Sbox() may not be called after Command()")
- }
- if r.restat {
- panic("Sbox() is not compatible with Restat()")
- }
- r.sbox = true
- r.outDir = outputDir
- r.sboxManifestPath = manifestPath
- return r
- }
- // SandboxTools enables tool sandboxing for the rule by copying any referenced tools into the
- // sandbox.
- func (r *RuleBuilder) SandboxTools() *RuleBuilder {
- if !r.sbox {
- panic("SandboxTools() must be called after Sbox()")
- }
- if len(r.commands) > 0 {
- panic("SandboxTools() may not be called after Command()")
- }
- r.sboxTools = true
- return r
- }
- // SandboxInputs enables input sandboxing for the rule by copying any referenced inputs into the
- // sandbox. It also implies SandboxTools().
- //
- // Sandboxing inputs requires RuleBuilder to be aware of all references to input paths. Paths
- // that are passed to RuleBuilder outside of the methods that expect inputs, for example
- // FlagWithArg, must use RuleBuilderCommand.PathForInput to translate the path to one that matches
- // the sandbox layout.
- func (r *RuleBuilder) SandboxInputs() *RuleBuilder {
- if !r.sbox {
- panic("SandboxInputs() must be called after Sbox()")
- }
- if len(r.commands) > 0 {
- panic("SandboxInputs() may not be called after Command()")
- }
- r.sboxTools = true
- r.sboxInputs = true
- return r
- }
- // Install associates an output of the rule with an install location, which can be retrieved later using
- // RuleBuilder.Installs.
- func (r *RuleBuilder) Install(from Path, to string) {
- r.installs = append(r.installs, RuleBuilderInstall{from, to})
- }
- // Command returns a new RuleBuilderCommand for the rule. The commands will be ordered in the rule by when they were
- // created by this method. That can be mutated through their methods in any order, as long as the mutations do not
- // race with any call to Build.
- func (r *RuleBuilder) Command() *RuleBuilderCommand {
- command := &RuleBuilderCommand{
- rule: r,
- }
- r.commands = append(r.commands, command)
- return command
- }
- // Temporary marks an output of a command as an intermediate file that will be used as an input to another command
- // in the same rule, and should not be listed in Outputs.
- func (r *RuleBuilder) Temporary(path WritablePath) {
- r.temporariesSet[path] = true
- }
- // DeleteTemporaryFiles adds a command to the rule that deletes any outputs that have been marked using Temporary
- // when the rule runs. DeleteTemporaryFiles should be called after all calls to Temporary.
- func (r *RuleBuilder) DeleteTemporaryFiles() {
- var temporariesList WritablePaths
- for intermediate := range r.temporariesSet {
- temporariesList = append(temporariesList, intermediate)
- }
- sort.Slice(temporariesList, func(i, j int) bool {
- return temporariesList[i].String() < temporariesList[j].String()
- })
- r.Command().Text("rm").Flag("-f").Outputs(temporariesList)
- }
- // Inputs returns the list of paths that were passed to the RuleBuilderCommand methods that take
- // input paths, such as RuleBuilderCommand.Input, RuleBuilderCommand.Implicit, or
- // RuleBuilderCommand.FlagWithInput. Inputs to a command that are also outputs of another command
- // in the same RuleBuilder are filtered out. The list is sorted and duplicates removed.
- func (r *RuleBuilder) Inputs() Paths {
- outputs := r.outputSet()
- depFiles := r.depFileSet()
- inputs := make(map[string]Path)
- for _, c := range r.commands {
- for _, input := range append(c.inputs, c.implicits...) {
- inputStr := input.String()
- if _, isOutput := outputs[inputStr]; !isOutput {
- if _, isDepFile := depFiles[inputStr]; !isDepFile {
- inputs[input.String()] = input
- }
- }
- }
- }
- var inputList Paths
- for _, input := range inputs {
- inputList = append(inputList, input)
- }
- sort.Slice(inputList, func(i, j int) bool {
- return inputList[i].String() < inputList[j].String()
- })
- return inputList
- }
- // OrderOnlys returns the list of paths that were passed to the RuleBuilderCommand.OrderOnly or
- // RuleBuilderCommand.OrderOnlys. The list is sorted and duplicates removed.
- func (r *RuleBuilder) OrderOnlys() Paths {
- orderOnlys := make(map[string]Path)
- for _, c := range r.commands {
- for _, orderOnly := range c.orderOnlys {
- orderOnlys[orderOnly.String()] = orderOnly
- }
- }
- var orderOnlyList Paths
- for _, orderOnly := range orderOnlys {
- orderOnlyList = append(orderOnlyList, orderOnly)
- }
- sort.Slice(orderOnlyList, func(i, j int) bool {
- return orderOnlyList[i].String() < orderOnlyList[j].String()
- })
- return orderOnlyList
- }
- func (r *RuleBuilder) outputSet() map[string]WritablePath {
- outputs := make(map[string]WritablePath)
- for _, c := range r.commands {
- for _, output := range c.outputs {
- outputs[output.String()] = output
- }
- }
- return outputs
- }
- // Outputs returns the list of paths that were passed to the RuleBuilderCommand methods that take
- // output paths, such as RuleBuilderCommand.Output, RuleBuilderCommand.ImplicitOutput, or
- // RuleBuilderCommand.FlagWithInput. The list is sorted and duplicates removed.
- func (r *RuleBuilder) Outputs() WritablePaths {
- outputs := r.outputSet()
- var outputList WritablePaths
- for _, output := range outputs {
- if !r.temporariesSet[output] {
- outputList = append(outputList, output)
- }
- }
- sort.Slice(outputList, func(i, j int) bool {
- return outputList[i].String() < outputList[j].String()
- })
- return outputList
- }
- func (r *RuleBuilder) symlinkOutputSet() map[string]WritablePath {
- symlinkOutputs := make(map[string]WritablePath)
- for _, c := range r.commands {
- for _, symlinkOutput := range c.symlinkOutputs {
- symlinkOutputs[symlinkOutput.String()] = symlinkOutput
- }
- }
- return symlinkOutputs
- }
- // SymlinkOutputs returns the list of paths that the executor (Ninja) would
- // verify, after build edge completion, that:
- //
- // 1) Created output symlinks match the list of paths in this list exactly (no more, no fewer)
- // 2) Created output files are *not* declared in this list.
- //
- // These symlink outputs are expected to be a subset of outputs or implicit
- // outputs, or they would fail validation at build param construction time
- // later, to support other non-rule-builder approaches for constructing
- // statements.
- func (r *RuleBuilder) SymlinkOutputs() WritablePaths {
- symlinkOutputs := r.symlinkOutputSet()
- var symlinkOutputList WritablePaths
- for _, symlinkOutput := range symlinkOutputs {
- symlinkOutputList = append(symlinkOutputList, symlinkOutput)
- }
- sort.Slice(symlinkOutputList, func(i, j int) bool {
- return symlinkOutputList[i].String() < symlinkOutputList[j].String()
- })
- return symlinkOutputList
- }
- func (r *RuleBuilder) depFileSet() map[string]WritablePath {
- depFiles := make(map[string]WritablePath)
- for _, c := range r.commands {
- for _, depFile := range c.depFiles {
- depFiles[depFile.String()] = depFile
- }
- }
- return depFiles
- }
- // DepFiles returns the list of paths that were passed to the RuleBuilderCommand methods that take depfile paths, such
- // as RuleBuilderCommand.DepFile or RuleBuilderCommand.FlagWithDepFile.
- func (r *RuleBuilder) DepFiles() WritablePaths {
- var depFiles WritablePaths
- for _, c := range r.commands {
- for _, depFile := range c.depFiles {
- depFiles = append(depFiles, depFile)
- }
- }
- return depFiles
- }
- // Installs returns the list of tuples passed to Install.
- func (r *RuleBuilder) Installs() RuleBuilderInstalls {
- return append(RuleBuilderInstalls(nil), r.installs...)
- }
- func (r *RuleBuilder) toolsSet() map[string]Path {
- tools := make(map[string]Path)
- for _, c := range r.commands {
- for _, tool := range c.tools {
- tools[tool.String()] = tool
- }
- }
- return tools
- }
- // Tools returns the list of paths that were passed to the RuleBuilderCommand.Tool method. The
- // list is sorted and duplicates removed.
- func (r *RuleBuilder) Tools() Paths {
- toolsSet := r.toolsSet()
- var toolsList Paths
- for _, tool := range toolsSet {
- toolsList = append(toolsList, tool)
- }
- sort.Slice(toolsList, func(i, j int) bool {
- return toolsList[i].String() < toolsList[j].String()
- })
- return toolsList
- }
- // RspFileInputs returns the list of paths that were passed to the RuleBuilderCommand.FlagWithRspFileInputList method.
- func (r *RuleBuilder) RspFileInputs() Paths {
- var rspFileInputs Paths
- for _, c := range r.commands {
- if c.rspFileInputs != nil {
- if rspFileInputs != nil {
- panic("Multiple commands in a rule may not have rsp file inputs")
- }
- rspFileInputs = c.rspFileInputs
- }
- }
- return rspFileInputs
- }
- // RspFile returns the path to the rspfile that was passed to the RuleBuilderCommand.FlagWithRspFileInputList method.
- func (r *RuleBuilder) RspFile() WritablePath {
- var rspFile WritablePath
- for _, c := range r.commands {
- if c.rspFile != nil {
- if rspFile != nil {
- panic("Multiple commands in a rule may not have rsp file inputs")
- }
- rspFile = c.rspFile
- }
- }
- return rspFile
- }
- // Commands returns a slice containing the built command line for each call to RuleBuilder.Command.
- func (r *RuleBuilder) Commands() []string {
- var commands []string
- for _, c := range r.commands {
- commands = append(commands, c.String())
- }
- return commands
- }
- // BuilderContext is a subset of ModuleContext and SingletonContext.
- type BuilderContext interface {
- PathContext
- Rule(PackageContext, string, blueprint.RuleParams, ...string) blueprint.Rule
- Build(PackageContext, BuildParams)
- }
- var _ BuilderContext = ModuleContext(nil)
- var _ BuilderContext = SingletonContext(nil)
- func (r *RuleBuilder) depFileMergerCmd(depFiles WritablePaths) *RuleBuilderCommand {
- return r.Command().
- BuiltTool("dep_fixer").
- Inputs(depFiles.Paths())
- }
- // Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
- // Outputs.
- func (r *RuleBuilder) Build(name string, desc string) {
- name = ninjaNameEscape(name)
- if len(r.missingDeps) > 0 {
- r.ctx.Build(pctx, BuildParams{
- Rule: ErrorRule,
- Outputs: r.Outputs(),
- OrderOnly: r.OrderOnlys(),
- Description: desc,
- Args: map[string]string{
- "error": "missing dependencies: " + strings.Join(r.missingDeps, ", "),
- },
- })
- return
- }
- var depFile WritablePath
- var depFormat blueprint.Deps
- if depFiles := r.DepFiles(); len(depFiles) > 0 {
- depFile = depFiles[0]
- depFormat = blueprint.DepsGCC
- if len(depFiles) > 1 {
- // Add a command locally that merges all depfiles together into the first depfile.
- r.depFileMergerCmd(depFiles)
- if r.sbox {
- // Check for Rel() errors, as all depfiles should be in the output dir. Errors
- // will be reported to the ctx.
- for _, path := range depFiles[1:] {
- Rel(r.ctx, r.outDir.String(), path.String())
- }
- }
- }
- }
- tools := r.Tools()
- commands := r.Commands()
- outputs := r.Outputs()
- inputs := r.Inputs()
- rspFileInputs := r.RspFileInputs()
- rspFilePath := r.RspFile()
- if len(commands) == 0 {
- return
- }
- if len(outputs) == 0 {
- panic("No outputs specified from any Commands")
- }
- commandString := strings.Join(commands, " && ")
- if r.sbox {
- // If running the command inside sbox, write the rule data out to an sbox
- // manifest.textproto.
- manifest := sbox_proto.Manifest{}
- command := sbox_proto.Command{}
- manifest.Commands = append(manifest.Commands, &command)
- command.Command = proto.String(commandString)
- if depFile != nil {
- manifest.OutputDepfile = proto.String(depFile.String())
- }
- // If sandboxing tools is enabled, add copy rules to the manifest to copy each tool
- // into the sbox directory.
- if r.sboxTools {
- for _, tool := range tools {
- command.CopyBefore = append(command.CopyBefore, &sbox_proto.Copy{
- From: proto.String(tool.String()),
- To: proto.String(sboxPathForToolRel(r.ctx, tool)),
- })
- }
- for _, c := range r.commands {
- for _, tool := range c.packagedTools {
- command.CopyBefore = append(command.CopyBefore, &sbox_proto.Copy{
- From: proto.String(tool.srcPath.String()),
- To: proto.String(sboxPathForPackagedToolRel(tool)),
- Executable: proto.Bool(tool.executable),
- })
- tools = append(tools, tool.srcPath)
- }
- }
- }
- // If sandboxing inputs is enabled, add copy rules to the manifest to copy each input
- // into the sbox directory.
- if r.sboxInputs {
- for _, input := range inputs {
- command.CopyBefore = append(command.CopyBefore, &sbox_proto.Copy{
- From: proto.String(input.String()),
- To: proto.String(r.sboxPathForInputRel(input)),
- })
- }
- // If using an rsp file copy it into the sbox directory.
- if rspFilePath != nil {
- command.RspFiles = append(command.RspFiles, &sbox_proto.RspFile{
- File: proto.String(rspFilePath.String()),
- // These have to match the logic in sboxPathForInputRel
- PathMappings: []*sbox_proto.PathMapping{
- {
- From: proto.String(r.outDir.String()),
- To: proto.String(sboxOutSubDir),
- },
- {
- From: proto.String(PathForOutput(r.ctx).String()),
- To: proto.String(sboxOutSubDir),
- },
- },
- })
- }
- command.Chdir = proto.Bool(true)
- }
- // Add copy rules to the manifest to copy each output file from the sbox directory.
- // to the output directory after running the commands.
- sboxOutputs := make([]string, len(outputs))
- for i, output := range outputs {
- rel := Rel(r.ctx, r.outDir.String(), output.String())
- sboxOutputs[i] = filepath.Join(sboxOutDir, rel)
- command.CopyAfter = append(command.CopyAfter, &sbox_proto.Copy{
- From: proto.String(filepath.Join(sboxOutSubDir, rel)),
- To: proto.String(output.String()),
- })
- }
- // Outputs that were marked Temporary will not be checked that they are in the output
- // directory by the loop above, check them here.
- for path := range r.temporariesSet {
- Rel(r.ctx, r.outDir.String(), path.String())
- }
- // Add a hash of the list of input files to the manifest so that the textproto file
- // changes when the list of input files changes and causes the sbox rule that
- // depends on it to rerun.
- command.InputHash = proto.String(hashSrcFiles(inputs))
- // Verify that the manifest textproto is not inside the sbox output directory, otherwise
- // it will get deleted when the sbox rule clears its output directory.
- _, manifestInOutDir := MaybeRel(r.ctx, r.outDir.String(), r.sboxManifestPath.String())
- if manifestInOutDir {
- ReportPathErrorf(r.ctx, "sbox rule %q manifestPath %q must not be in outputDir %q",
- name, r.sboxManifestPath.String(), r.outDir.String())
- }
- // Create a rule to write the manifest as a the textproto.
- WriteFileRule(r.ctx, r.sboxManifestPath, proto.MarshalTextString(&manifest))
- // Generate a new string to use as the command line of the sbox rule. This uses
- // a RuleBuilderCommand as a convenience method of building the command line, then
- // converts it to a string to replace commandString.
- sboxCmd := &RuleBuilderCommand{
- rule: &RuleBuilder{
- ctx: r.ctx,
- },
- }
- sboxCmd.Text("rm -rf").Output(r.outDir)
- sboxCmd.Text("&&")
- sboxCmd.BuiltTool("sbox").
- Flag("--sandbox-path").Text(shared.TempDirForOutDir(PathForOutput(r.ctx).String())).
- Flag("--manifest").Input(r.sboxManifestPath)
- // Replace the command string, and add the sbox tool and manifest textproto to the
- // dependencies of the final sbox rule.
- commandString = sboxCmd.buf.String()
- tools = append(tools, sboxCmd.tools...)
- inputs = append(inputs, sboxCmd.inputs...)
- if r.rbeParams != nil {
- // RBE needs a list of input files to copy to the remote builder. For inputs already
- // listed in an rsp file, pass the rsp file directly to rewrapper. For the rest,
- // create a new rsp file to pass to rewrapper.
- var remoteRspFiles Paths
- var remoteInputs Paths
- remoteInputs = append(remoteInputs, inputs...)
- remoteInputs = append(remoteInputs, tools...)
- if rspFilePath != nil {
- remoteInputs = append(remoteInputs, rspFilePath)
- remoteRspFiles = append(remoteRspFiles, rspFilePath)
- }
- if len(remoteInputs) > 0 {
- inputsListFile := r.sboxManifestPath.ReplaceExtension(r.ctx, "rbe_inputs.list")
- writeRspFileRule(r.ctx, inputsListFile, remoteInputs)
- remoteRspFiles = append(remoteRspFiles, inputsListFile)
- // Add the new rsp file as an extra input to the rule.
- inputs = append(inputs, inputsListFile)
- }
- r.rbeParams.OutputFiles = outputs.Strings()
- r.rbeParams.RSPFiles = remoteRspFiles.Strings()
- rewrapperCommand := r.rbeParams.NoVarTemplate(r.ctx.Config().RBEWrapper())
- commandString = rewrapperCommand + " bash -c '" + strings.ReplaceAll(commandString, `'`, `'\''`) + "'"
- }
- } else {
- // If not using sbox the rule will run the command directly, put the hash of the
- // list of input files in a comment at the end of the command line to ensure ninja
- // reruns the rule when the list of input files changes.
- commandString += " # hash of input list: " + hashSrcFiles(inputs)
- }
- // Ninja doesn't like multiple outputs when depfiles are enabled, move all but the first output to
- // ImplicitOutputs. RuleBuilder doesn't use "$out", so the distinction between Outputs and
- // ImplicitOutputs doesn't matter.
- output := outputs[0]
- implicitOutputs := outputs[1:]
- var rspFile, rspFileContent string
- if rspFilePath != nil {
- rspFile = rspFilePath.String()
- // Use "$in" for rspFileContent to avoid duplicating the list of files in the dependency
- // list and in the contents of the rsp file. Inputs to the rule that are not in the
- // rsp file will be listed in Implicits instead of Inputs so they don't show up in "$in".
- rspFileContent = "$in"
- }
- var pool blueprint.Pool
- if r.ctx.Config().UseGoma() && r.remoteable.Goma {
- // When USE_GOMA=true is set and the rule is supported by goma, allow jobs to run outside the local pool.
- } else if r.ctx.Config().UseRBE() && r.remoteable.RBE {
- // When USE_RBE=true is set and the rule is supported by RBE, use the remotePool.
- pool = remotePool
- } else if r.highmem {
- pool = highmemPool
- } else if r.ctx.Config().UseRemoteBuild() {
- pool = localPool
- }
- r.ctx.Build(r.pctx, BuildParams{
- Rule: r.ctx.Rule(pctx, name, blueprint.RuleParams{
- Command: proptools.NinjaEscape(commandString),
- CommandDeps: proptools.NinjaEscapeList(tools.Strings()),
- Restat: r.restat,
- Rspfile: proptools.NinjaEscape(rspFile),
- RspfileContent: rspFileContent,
- Pool: pool,
- }),
- Inputs: rspFileInputs,
- Implicits: inputs,
- Output: output,
- ImplicitOutputs: implicitOutputs,
- SymlinkOutputs: r.SymlinkOutputs(),
- Depfile: depFile,
- Deps: depFormat,
- Description: desc,
- })
- }
- // RuleBuilderCommand is a builder for a command in a command line. It can be mutated by its methods to add to the
- // command and track dependencies. The methods mutate the RuleBuilderCommand in place, as well as return the
- // RuleBuilderCommand, so they can be used chained or unchained. All methods that add text implicitly add a single
- // space as a separator from the previous method.
- type RuleBuilderCommand struct {
- rule *RuleBuilder
- buf strings.Builder
- inputs Paths
- implicits Paths
- orderOnlys Paths
- outputs WritablePaths
- symlinkOutputs WritablePaths
- depFiles WritablePaths
- tools Paths
- packagedTools []PackagingSpec
- rspFileInputs Paths
- rspFile WritablePath
- }
- func (c *RuleBuilderCommand) addInput(path Path) string {
- c.inputs = append(c.inputs, path)
- return c.PathForInput(path)
- }
- func (c *RuleBuilderCommand) addImplicit(path Path) {
- c.implicits = append(c.implicits, path)
- }
- func (c *RuleBuilderCommand) addOrderOnly(path Path) {
- c.orderOnlys = append(c.orderOnlys, path)
- }
- // PathForInput takes an input path and returns the appropriate path to use on the command line. If
- // sbox was enabled via a call to RuleBuilder.Sbox() and the path was an output path it returns a
- // path with the placeholder prefix used for outputs in sbox. If sbox is not enabled it returns the
- // original path.
- func (c *RuleBuilderCommand) PathForInput(path Path) string {
- if c.rule.sbox {
- rel, inSandbox := c.rule._sboxPathForInputRel(path)
- if inSandbox {
- rel = filepath.Join(sboxSandboxBaseDir, rel)
- }
- return rel
- }
- return path.String()
- }
- // PathsForInputs takes a list of input paths and returns the appropriate paths to use on the
- // command line. If sbox was enabled via a call to RuleBuilder.Sbox() a path was an output path, it
- // returns the path with the placeholder prefix used for outputs in sbox. If sbox is not enabled it
- // returns the original paths.
- func (c *RuleBuilderCommand) PathsForInputs(paths Paths) []string {
- ret := make([]string, len(paths))
- for i, path := range paths {
- ret[i] = c.PathForInput(path)
- }
- return ret
- }
- // PathForOutput takes an output path and returns the appropriate path to use on the command
- // line. If sbox was enabled via a call to RuleBuilder.Sbox(), it returns a path with the
- // placeholder prefix used for outputs in sbox. If sbox is not enabled it returns the
- // original path.
- func (c *RuleBuilderCommand) PathForOutput(path WritablePath) string {
- if c.rule.sbox {
- // Errors will be handled in RuleBuilder.Build where we have a context to report them
- rel, _, _ := maybeRelErr(c.rule.outDir.String(), path.String())
- return filepath.Join(sboxOutDir, rel)
- }
- return path.String()
- }
- // SboxPathForTool takes a path to a tool, which may be an output file or a source file, and returns
- // the corresponding path for the tool in the sbox sandbox. It assumes that sandboxing and tool
- // sandboxing are enabled.
- func SboxPathForTool(ctx BuilderContext, path Path) string {
- return filepath.Join(sboxSandboxBaseDir, sboxPathForToolRel(ctx, path))
- }
- func sboxPathForToolRel(ctx BuilderContext, path Path) string {
- // Errors will be handled in RuleBuilder.Build where we have a context to report them
- relOut, isRelOut, _ := maybeRelErr(PathForOutput(ctx, "host", ctx.Config().PrebuiltOS()).String(), path.String())
- if isRelOut {
- // The tool is in the output directory, it will be copied to __SBOX_OUT_DIR__/tools/out
- return filepath.Join(sboxToolsSubDir, "out", relOut)
- }
- // The tool is in the source directory, it will be copied to __SBOX_OUT_DIR__/tools/src
- return filepath.Join(sboxToolsSubDir, "src", path.String())
- }
- func (r *RuleBuilder) _sboxPathForInputRel(path Path) (rel string, inSandbox bool) {
- // Errors will be handled in RuleBuilder.Build where we have a context to report them
- rel, isRelSboxOut, _ := maybeRelErr(r.outDir.String(), path.String())
- if isRelSboxOut {
- return filepath.Join(sboxOutSubDir, rel), true
- }
- if r.sboxInputs {
- // When sandboxing inputs all inputs have to be copied into the sandbox. Input files that
- // are outputs of other rules could be an arbitrary absolute path if OUT_DIR is set, so they
- // will be copied to relative paths under __SBOX_OUT_DIR__/out.
- rel, isRelOut, _ := maybeRelErr(PathForOutput(r.ctx).String(), path.String())
- if isRelOut {
- return filepath.Join(sboxOutSubDir, rel), true
- }
- }
- return path.String(), false
- }
- func (r *RuleBuilder) sboxPathForInputRel(path Path) string {
- rel, _ := r._sboxPathForInputRel(path)
- return rel
- }
- func (r *RuleBuilder) sboxPathsForInputsRel(paths Paths) []string {
- ret := make([]string, len(paths))
- for i, path := range paths {
- ret[i] = r.sboxPathForInputRel(path)
- }
- return ret
- }
- // SboxPathForPackagedTool takes a PackageSpec for a tool and returns the corresponding path for the
- // tool after copying it into the sandbox. This can be used on the RuleBuilder command line to
- // reference the tool.
- func SboxPathForPackagedTool(spec PackagingSpec) string {
- return filepath.Join(sboxSandboxBaseDir, sboxPathForPackagedToolRel(spec))
- }
- func sboxPathForPackagedToolRel(spec PackagingSpec) string {
- return filepath.Join(sboxToolsSubDir, "out", spec.relPathInPackage)
- }
- // PathForTool takes a path to a tool, which may be an output file or a source file, and returns
- // the corresponding path for the tool in the sbox sandbox if sbox is enabled, or the original path
- // if it is not. This can be used on the RuleBuilder command line to reference the tool.
- func (c *RuleBuilderCommand) PathForTool(path Path) string {
- if c.rule.sbox && c.rule.sboxTools {
- return filepath.Join(sboxSandboxBaseDir, sboxPathForToolRel(c.rule.ctx, path))
- }
- return path.String()
- }
- // PackagedTool adds the specified tool path to the command line. It can only be used with tool
- // sandboxing enabled by SandboxTools(), and will copy the tool into the sandbox.
- func (c *RuleBuilderCommand) PackagedTool(spec PackagingSpec) *RuleBuilderCommand {
- if !c.rule.sboxTools {
- panic("PackagedTool() requires SandboxTools()")
- }
- c.packagedTools = append(c.packagedTools, spec)
- c.Text(sboxPathForPackagedToolRel(spec))
- return c
- }
- // ImplicitPackagedTool copies the specified tool into the sandbox without modifying the command
- // line. It can only be used with tool sandboxing enabled by SandboxTools().
- func (c *RuleBuilderCommand) ImplicitPackagedTool(spec PackagingSpec) *RuleBuilderCommand {
- if !c.rule.sboxTools {
- panic("ImplicitPackagedTool() requires SandboxTools()")
- }
- c.packagedTools = append(c.packagedTools, spec)
- return c
- }
- // ImplicitPackagedTools copies the specified tools into the sandbox without modifying the command
- // line. It can only be used with tool sandboxing enabled by SandboxTools().
- func (c *RuleBuilderCommand) ImplicitPackagedTools(specs []PackagingSpec) *RuleBuilderCommand {
- if !c.rule.sboxTools {
- panic("ImplicitPackagedTools() requires SandboxTools()")
- }
- c.packagedTools = append(c.packagedTools, specs...)
- return c
- }
- // Text adds the specified raw text to the command line. The text should not contain input or output paths or the
- // rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) Text(text string) *RuleBuilderCommand {
- if c.buf.Len() > 0 {
- c.buf.WriteByte(' ')
- }
- c.buf.WriteString(text)
- return c
- }
- // Textf adds the specified formatted text to the command line. The text should not contain input or output paths or
- // the rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) Textf(format string, a ...interface{}) *RuleBuilderCommand {
- return c.Text(fmt.Sprintf(format, a...))
- }
- // Flag adds the specified raw text to the command line. The text should not contain input or output paths or the
- // rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) Flag(flag string) *RuleBuilderCommand {
- return c.Text(flag)
- }
- // OptionalFlag adds the specified raw text to the command line if it is not nil. The text should not contain input or
- // output paths or the rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) OptionalFlag(flag *string) *RuleBuilderCommand {
- if flag != nil {
- c.Text(*flag)
- }
- return c
- }
- // Flags adds the specified raw text to the command line. The text should not contain input or output paths or the
- // rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) Flags(flags []string) *RuleBuilderCommand {
- for _, flag := range flags {
- c.Text(flag)
- }
- return c
- }
- // FlagWithArg adds the specified flag and argument text to the command line, with no separator between them. The flag
- // and argument should not contain input or output paths or the rule will not have them listed in its dependencies or
- // outputs.
- func (c *RuleBuilderCommand) FlagWithArg(flag, arg string) *RuleBuilderCommand {
- return c.Text(flag + arg)
- }
- // FlagForEachArg adds the specified flag joined with each argument to the command line. The result is identical to
- // calling FlagWithArg for argument.
- func (c *RuleBuilderCommand) FlagForEachArg(flag string, args []string) *RuleBuilderCommand {
- for _, arg := range args {
- c.FlagWithArg(flag, arg)
- }
- return c
- }
- // FlagWithList adds the specified flag and list of arguments to the command line, with the arguments joined by sep
- // and no separator between the flag and arguments. The flag and arguments should not contain input or output paths or
- // the rule will not have them listed in its dependencies or outputs.
- func (c *RuleBuilderCommand) FlagWithList(flag string, list []string, sep string) *RuleBuilderCommand {
- return c.Text(flag + strings.Join(list, sep))
- }
- // Tool adds the specified tool path to the command line. The path will be also added to the dependencies returned by
- // RuleBuilder.Tools.
- func (c *RuleBuilderCommand) Tool(path Path) *RuleBuilderCommand {
- c.tools = append(c.tools, path)
- return c.Text(c.PathForTool(path))
- }
- // Tool adds the specified tool path to the dependencies returned by RuleBuilder.Tools.
- func (c *RuleBuilderCommand) ImplicitTool(path Path) *RuleBuilderCommand {
- c.tools = append(c.tools, path)
- return c
- }
- // Tool adds the specified tool path to the dependencies returned by RuleBuilder.Tools.
- func (c *RuleBuilderCommand) ImplicitTools(paths Paths) *RuleBuilderCommand {
- c.tools = append(c.tools, paths...)
- return c
- }
- // BuiltTool adds the specified tool path that was built using a host Soong module to the command line. The path will
- // be also added to the dependencies returned by RuleBuilder.Tools.
- //
- // It is equivalent to:
- // cmd.Tool(ctx.Config().HostToolPath(ctx, tool))
- func (c *RuleBuilderCommand) BuiltTool(tool string) *RuleBuilderCommand {
- return c.Tool(c.rule.ctx.Config().HostToolPath(c.rule.ctx, tool))
- }
- // PrebuiltBuildTool adds the specified tool path from prebuils/build-tools. The path will be also added to the
- // dependencies returned by RuleBuilder.Tools.
- //
- // It is equivalent to:
- // cmd.Tool(ctx.Config().PrebuiltBuildTool(ctx, tool))
- func (c *RuleBuilderCommand) PrebuiltBuildTool(ctx PathContext, tool string) *RuleBuilderCommand {
- return c.Tool(ctx.Config().PrebuiltBuildTool(ctx, tool))
- }
- // Input adds the specified input path to the command line. The path will also be added to the dependencies returned by
- // RuleBuilder.Inputs.
- func (c *RuleBuilderCommand) Input(path Path) *RuleBuilderCommand {
- return c.Text(c.addInput(path))
- }
- // Inputs adds the specified input paths to the command line, separated by spaces. The paths will also be added to the
- // dependencies returned by RuleBuilder.Inputs.
- func (c *RuleBuilderCommand) Inputs(paths Paths) *RuleBuilderCommand {
- for _, path := range paths {
- c.Input(path)
- }
- return c
- }
- // Implicit adds the specified input path to the dependencies returned by RuleBuilder.Inputs without modifying the
- // command line.
- func (c *RuleBuilderCommand) Implicit(path Path) *RuleBuilderCommand {
- c.addImplicit(path)
- return c
- }
- // Implicits adds the specified input paths to the dependencies returned by RuleBuilder.Inputs without modifying the
- // command line.
- func (c *RuleBuilderCommand) Implicits(paths Paths) *RuleBuilderCommand {
- for _, path := range paths {
- c.addImplicit(path)
- }
- return c
- }
- // GetImplicits returns the command's implicit inputs.
- func (c *RuleBuilderCommand) GetImplicits() Paths {
- return c.implicits
- }
- // OrderOnly adds the specified input path to the dependencies returned by RuleBuilder.OrderOnlys
- // without modifying the command line.
- func (c *RuleBuilderCommand) OrderOnly(path Path) *RuleBuilderCommand {
- c.addOrderOnly(path)
- return c
- }
- // OrderOnlys adds the specified input paths to the dependencies returned by RuleBuilder.OrderOnlys
- // without modifying the command line.
- func (c *RuleBuilderCommand) OrderOnlys(paths Paths) *RuleBuilderCommand {
- for _, path := range paths {
- c.addOrderOnly(path)
- }
- return c
- }
- // Output adds the specified output path to the command line. The path will also be added to the outputs returned by
- // RuleBuilder.Outputs.
- func (c *RuleBuilderCommand) Output(path WritablePath) *RuleBuilderCommand {
- c.outputs = append(c.outputs, path)
- return c.Text(c.PathForOutput(path))
- }
- // Outputs adds the specified output paths to the command line, separated by spaces. The paths will also be added to
- // the outputs returned by RuleBuilder.Outputs.
- func (c *RuleBuilderCommand) Outputs(paths WritablePaths) *RuleBuilderCommand {
- for _, path := range paths {
- c.Output(path)
- }
- return c
- }
- // OutputDir adds the output directory to the command line. This is only available when used with RuleBuilder.Sbox,
- // and will be the temporary output directory managed by sbox, not the final one.
- func (c *RuleBuilderCommand) OutputDir() *RuleBuilderCommand {
- if !c.rule.sbox {
- panic("OutputDir only valid with Sbox")
- }
- return c.Text(sboxOutDir)
- }
- // DepFile adds the specified depfile path to the paths returned by RuleBuilder.DepFiles and adds it to the command
- // line, and causes RuleBuilder.Build file to set the depfile flag for ninja. If multiple depfiles are added to
- // commands in a single RuleBuilder then RuleBuilder.Build will add an extra command to merge the depfiles together.
- func (c *RuleBuilderCommand) DepFile(path WritablePath) *RuleBuilderCommand {
- c.depFiles = append(c.depFiles, path)
- return c.Text(c.PathForOutput(path))
- }
- // ImplicitOutput adds the specified output path to the dependencies returned by RuleBuilder.Outputs without modifying
- // the command line.
- func (c *RuleBuilderCommand) ImplicitOutput(path WritablePath) *RuleBuilderCommand {
- c.outputs = append(c.outputs, path)
- return c
- }
- // ImplicitOutputs adds the specified output paths to the dependencies returned by RuleBuilder.Outputs without modifying
- // the command line.
- func (c *RuleBuilderCommand) ImplicitOutputs(paths WritablePaths) *RuleBuilderCommand {
- c.outputs = append(c.outputs, paths...)
- return c
- }
- // ImplicitSymlinkOutput declares the specified path as an implicit output that
- // will be a symlink instead of a regular file. Does not modify the command
- // line.
- func (c *RuleBuilderCommand) ImplicitSymlinkOutput(path WritablePath) *RuleBuilderCommand {
- c.symlinkOutputs = append(c.symlinkOutputs, path)
- return c.ImplicitOutput(path)
- }
- // ImplicitSymlinkOutputs declares the specified paths as implicit outputs that
- // will be a symlinks instead of regular files. Does not modify the command
- // line.
- func (c *RuleBuilderCommand) ImplicitSymlinkOutputs(paths WritablePaths) *RuleBuilderCommand {
- for _, path := range paths {
- c.ImplicitSymlinkOutput(path)
- }
- return c
- }
- // SymlinkOutput declares the specified path as an output that will be a symlink
- // instead of a regular file. Modifies the command line.
- func (c *RuleBuilderCommand) SymlinkOutput(path WritablePath) *RuleBuilderCommand {
- c.symlinkOutputs = append(c.symlinkOutputs, path)
- return c.Output(path)
- }
- // SymlinkOutputsl declares the specified paths as outputs that will be symlinks
- // instead of regular files. Modifies the command line.
- func (c *RuleBuilderCommand) SymlinkOutputs(paths WritablePaths) *RuleBuilderCommand {
- for _, path := range paths {
- c.SymlinkOutput(path)
- }
- return c
- }
- // ImplicitDepFile adds the specified depfile path to the paths returned by RuleBuilder.DepFiles without modifying
- // the command line, and causes RuleBuilder.Build file to set the depfile flag for ninja. If multiple depfiles
- // are added to commands in a single RuleBuilder then RuleBuilder.Build will add an extra command to merge the
- // depfiles together.
- func (c *RuleBuilderCommand) ImplicitDepFile(path WritablePath) *RuleBuilderCommand {
- c.depFiles = append(c.depFiles, path)
- return c
- }
- // FlagWithInput adds the specified flag and input path to the command line, with no separator between them. The path
- // will also be added to the dependencies returned by RuleBuilder.Inputs.
- func (c *RuleBuilderCommand) FlagWithInput(flag string, path Path) *RuleBuilderCommand {
- return c.Text(flag + c.addInput(path))
- }
- // FlagWithInputList adds the specified flag and input paths to the command line, with the inputs joined by sep
- // and no separator between the flag and inputs. The input paths will also be added to the dependencies returned by
- // RuleBuilder.Inputs.
- func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths Paths, sep string) *RuleBuilderCommand {
- strs := make([]string, len(paths))
- for i, path := range paths {
- strs[i] = c.addInput(path)
- }
- return c.FlagWithList(flag, strs, sep)
- }
- // FlagForEachInput adds the specified flag joined with each input path to the command line. The input paths will also
- // be added to the dependencies returned by RuleBuilder.Inputs. The result is identical to calling FlagWithInput for
- // each input path.
- func (c *RuleBuilderCommand) FlagForEachInput(flag string, paths Paths) *RuleBuilderCommand {
- for _, path := range paths {
- c.FlagWithInput(flag, path)
- }
- return c
- }
- // FlagWithOutput adds the specified flag and output path to the command line, with no separator between them. The path
- // will also be added to the outputs returned by RuleBuilder.Outputs.
- func (c *RuleBuilderCommand) FlagWithOutput(flag string, path WritablePath) *RuleBuilderCommand {
- c.outputs = append(c.outputs, path)
- return c.Text(flag + c.PathForOutput(path))
- }
- // FlagWithDepFile adds the specified flag and depfile path to the command line, with no separator between them. The path
- // will also be added to the outputs returned by RuleBuilder.Outputs.
- func (c *RuleBuilderCommand) FlagWithDepFile(flag string, path WritablePath) *RuleBuilderCommand {
- c.depFiles = append(c.depFiles, path)
- return c.Text(flag + c.PathForOutput(path))
- }
- // FlagWithRspFileInputList adds the specified flag and path to an rspfile to the command line, with no separator
- // between them. The paths will be written to the rspfile. If sbox is enabled, the rspfile must
- // be outside the sbox directory.
- func (c *RuleBuilderCommand) FlagWithRspFileInputList(flag string, rspFile WritablePath, paths Paths) *RuleBuilderCommand {
- if c.rspFileInputs != nil {
- panic("FlagWithRspFileInputList cannot be called if rsp file inputs have already been provided")
- }
- // Use an empty slice if paths is nil, the non-nil slice is used as an indicator that the rsp file must be
- // generated.
- if paths == nil {
- paths = Paths{}
- }
- c.rspFileInputs = paths
- c.rspFile = rspFile
- if c.rule.sbox {
- if _, isRel, _ := maybeRelErr(c.rule.outDir.String(), rspFile.String()); isRel {
- panic(fmt.Errorf("FlagWithRspFileInputList rspfile %q must not be inside out dir %q",
- rspFile.String(), c.rule.outDir.String()))
- }
- }
- c.FlagWithArg(flag, c.PathForInput(rspFile))
- return c
- }
- // String returns the command line.
- func (c *RuleBuilderCommand) String() string {
- return c.buf.String()
- }
- // RuleBuilderSboxProtoForTests takes the BuildParams for the manifest passed to RuleBuilder.Sbox()
- // and returns sbox testproto generated by the RuleBuilder.
- func RuleBuilderSboxProtoForTests(t *testing.T, params TestingBuildParams) *sbox_proto.Manifest {
- t.Helper()
- content := ContentFromFileRuleForTests(t, params)
- manifest := sbox_proto.Manifest{}
- err := proto.UnmarshalText(content, &manifest)
- if err != nil {
- t.Fatalf("failed to unmarshal manifest: %s", err.Error())
- }
- return &manifest
- }
- func ninjaNameEscape(s string) string {
- b := []byte(s)
- escaped := false
- for i, c := range b {
- valid := (c >= 'a' && c <= 'z') ||
- (c >= 'A' && c <= 'Z') ||
- (c >= '0' && c <= '9') ||
- (c == '_') ||
- (c == '-') ||
- (c == '.')
- if !valid {
- b[i] = '_'
- escaped = true
- }
- }
- if escaped {
- s = string(b)
- }
- return s
- }
- // hashSrcFiles returns a hash of the list of source files. It is used to ensure the command line
- // or the sbox textproto manifest change even if the input files are not listed on the command line.
- func hashSrcFiles(srcFiles Paths) string {
- h := sha256.New()
- srcFileList := strings.Join(srcFiles.Strings(), "\n")
- h.Write([]byte(srcFileList))
- return fmt.Sprintf("%x", h.Sum(nil))
- }
- // BuilderContextForTesting returns a BuilderContext for the given config that can be used for tests
- // that need to call methods that take a BuilderContext.
- func BuilderContextForTesting(config Config) BuilderContext {
- pathCtx := PathContextForTesting(config)
- return builderContextForTests{
- PathContext: pathCtx,
- }
- }
- type builderContextForTests struct {
- PathContext
- }
- func (builderContextForTests) Rule(PackageContext, string, blueprint.RuleParams, ...string) blueprint.Rule {
- return nil
- }
- func (builderContextForTests) Build(PackageContext, BuildParams) {}
- func writeRspFileRule(ctx BuilderContext, rspFile WritablePath, paths Paths) {
- buf := &strings.Builder{}
- err := response.WriteRspFile(buf, paths.Strings())
- if err != nil {
- // There should never be I/O errors writing to a bytes.Buffer.
- panic(err)
- }
- WriteFileRule(ctx, rspFile, buf.String())
- }
|