Golang BuildGraph.TargetOrDie方法代码示例

func addJSONTarget(graph *core.BuildGraph, ret *JSONGraph, label core.BuildLabel, done map[core.BuildLabel]struct{}) {
	if _, present := done[label]; present {
		return
	}
	done[label] = struct{}{}
	if label.IsAllTargets() {
		pkg := graph.PackageOrDie(label.PackageName)
		for _, target := range pkg.Targets {
			addJSONTarget(graph, ret, target.Label, done)
		}
		return
	}
	target := graph.TargetOrDie(label)
	if _, present := ret.Packages[label.PackageName]; present {
		ret.Packages[label.PackageName].Targets[label.Name] = makeJSONTarget(graph, target)
	} else {
		ret.Packages[label.PackageName] = JSONPackage{
			Targets: map[string]JSONTarget{
				label.Name: makeJSONTarget(graph, target),
			},
		}
	}
	for _, dep := range target.Dependencies() {
		addJSONTarget(graph, ret, dep.Label, done)
	}
}

// ReverseDeps For each input label, finds all targets which depend upon it.
func ReverseDeps(graph *core.BuildGraph, labels []core.BuildLabel) {

	uniqueTargets := make(map[core.BuildLabel]struct{})

	for _, label := range labels {
		for _, child := range graph.PackageOrDie(label.PackageName).AllChildren(graph.TargetOrDie(label)) {
			for _, target := range graph.ReverseDependencies(child) {
				if parent := target.Parent(graph); parent != nil {
					uniqueTargets[parent.Label] = struct{}{}
				} else {
					uniqueTargets[target.Label] = struct{}{}
				}
			}
		}
	}
	// Check for anything subincluding this guy too
	for _, pkg := range graph.PackageMap() {
		for _, label := range labels {
			if pkg.HasSubinclude(label) {
				uniqueTargets[core.BuildLabel{PackageName: pkg.Name, Name: "all"}] = struct{}{}
			}
		}
	}

	targets := make(core.BuildLabels, 0, len(uniqueTargets))
	for target := range uniqueTargets {
		targets = append(targets, target)
	}
	sort.Sort(targets)
	for _, target := range targets {
		fmt.Printf("%s\n", target)
	}
}

// Run implements the running part of 'plz run'.
func Run(graph *core.BuildGraph, label core.BuildLabel, args []string) {
	target := graph.TargetOrDie(label)
	if !target.IsBinary {
		log.Fatalf("Target %s cannot be run; it's not marked as binary", label)
	}
	// ReplaceSequences always quotes stuff in case it contains spaces or special characters,
	// that works fine if we interpret it as a shell but not to pass it as an argument here.
	cmd := strings.Trim(build.ReplaceSequences(target, fmt.Sprintf("$(out_exe %s)", target.Label)), "\"")
	// Handle targets where $(exe ...) returns something nontrivial
	splitCmd := strings.Split(cmd, " ")
	if !strings.Contains(splitCmd[0], "/") {
		// Probably it's a java -jar, we need an absolute path to it.
		cmd, err := exec.LookPath(splitCmd[0])
		if err != nil {
			log.Fatalf("Can't find binary %s", splitCmd[0])
		}
		splitCmd[0] = cmd
	}
	args = append(splitCmd, args...)
	log.Info("Running target %s...", strings.Join(args, " "))
	output.SetWindowTitle("plz run: " + strings.Join(args, " "))
	if err := syscall.Exec(splitCmd[0], args, os.Environ()); err != nil {
		log.Fatalf("Error running command %s: %s", strings.Join(args, " "), err)
	}
}

// Calculate the hash of all sources of this rule
func sourceHash(graph *core.BuildGraph, target *core.BuildTarget) ([]byte, error) {
	h := sha1.New()
	for source := range core.IterSources(graph, target) {
		result, err := pathHash(source.Src, false)
		if err != nil {
			return nil, err
		}
		h.Write(result)
	}
	for _, tool := range target.Tools {
		if label := tool.Label(); label != nil {
			// Note that really it would be more correct to hash the outputs of these rules
			// in the same way we calculate a hash of sources for the rule, but that is
			// impractical for some cases (notably npm) where tools can be very large.
			// Instead we assume calculating the target hash is sufficient.
			h.Write(mustTargetHash(core.State, graph.TargetOrDie(*label)))
		} else {
			result, err := pathHash(tool.FullPaths(graph)[0], false)
			if err != nil {
				return nil, err
			}
			h.Write(result)
		}
	}
	return h.Sum(nil), nil
}

// QueryTargetOutputs prints all output files for a set of targets.
func QueryTargetOutputs(graph *core.BuildGraph, labels []core.BuildLabel) {
	for _, label := range labels {
		target := graph.TargetOrDie(label)
		for _, out := range target.Outputs() {
			fmt.Printf("%s\n", path.Join(target.OutDir(), out))
		}
	}
}

// QueryAffectedTargets walks over the build graph and identifies all targets that have a transitive
// dependency on the given set of files.
// Targets are filtered by given include / exclude labels and if 'tests' is true only
// test targets will be returned.
func QueryAffectedTargets(graph *core.BuildGraph, files, include, exclude []string, tests, transitive bool) {
	affectedTargets := make(chan *core.BuildTarget, 100)
	done := make(chan bool)

	filePaths := map[string]bool{}
	for _, file := range files {
		filePaths[file] = true
	}

	// Check all the targets to see if any own one of these files
	go func() {
		for _, target := range graph.AllTargets() {
			for _, source := range target.AllSourcePaths(graph) {
				if _, present := filePaths[source]; present {
					affectedTargets <- target
					break
				}
			}
		}
		done <- true
	}()

	// Check all the packages to see if any are defined by these files.
	// This is pretty pessimistic, we have to just assume the whole package is invalidated.
	// A better approach involves using plz query graph and plz_diff_graphs - see that tool
	// for more explanation.
	go func() {
		invalidatePackage := func(pkg *core.Package) {
			for _, target := range pkg.Targets {
				affectedTargets <- target
			}
		}
		for _, pkg := range graph.PackageMap() {
			if _, present := filePaths[pkg.Filename]; present {
				invalidatePackage(pkg)
			} else {
				for _, subinclude := range pkg.Subincludes {
					for _, source := range graph.TargetOrDie(subinclude).AllSourcePaths(graph) {
						if _, present := filePaths[source]; present {
							invalidatePackage(pkg)
							break
						}
					}
				}
			}
		}
		done <- true
	}()

	go handleAffectedTargets(graph, affectedTargets, done, include, exclude, tests, transitive)

	<-done
	<-done
	close(affectedTargets)
	<-done
}

// QueryTargetInputs prints all inputs for a single target.
func QueryTargetInputs(graph *core.BuildGraph, labels []core.BuildLabel) {
	inputPaths := map[string]bool{}
	for _, label := range labels {
		for sourcePath := range core.IterInputPaths(graph, graph.TargetOrDie(label)) {
			inputPaths[sourcePath] = true
		}
	}

	for path := range inputPaths {
		fmt.Printf("%s\n", path)
	}
}

func querySomePath1(graph *core.BuildGraph, target1 *core.BuildTarget, label2 core.BuildLabel, print bool) bool {
	// Now we do the same for label2.
	if label2.IsAllTargets() {
		for _, target2 := range graph.PackageOrDie(label2.PackageName).Targets {
			if querySomePath2(graph, target1, target2, false) {
				return true
			}
		}
		return false
	}
	return querySomePath2(graph, target1, graph.TargetOrDie(label2), print)
}

// QuerySomePath finds and returns a path between two targets.
// Useful for a "why on earth do I depend on this thing" type query.
func QuerySomePath(graph *core.BuildGraph, label1 core.BuildLabel, label2 core.BuildLabel) {
	// Awkwardly either target can be :all. This is an extremely useful idiom though so despite
	// trickiness is worth supporting.
	// Of course this calculation is also quadratic but it's not very obvious how to avoid that.
	if label1.IsAllTargets() {
		for _, target := range graph.PackageOrDie(label1.PackageName).Targets {
			if querySomePath1(graph, target, label2, false) {
				return
			}
		}
		fmt.Printf("Couldn't find any dependency path between %s and %s\n", label1, label2)
	} else {
		querySomePath1(graph, graph.TargetOrDie(label1), label2, true)
	}
}

// QueryPrint produces a Python call which would (hopefully) regenerate the same build rule if run.
// This is of course not ideal since they were almost certainly created as a java_library
// or some similar wrapper rule, but we've lost that information by now.
func QueryPrint(graph *core.BuildGraph, labels []core.BuildLabel) {
	for _, label := range labels {
		target := graph.TargetOrDie(label)
		fmt.Printf("%s:\n", label)
		if target.IsFilegroup() {
			fmt.Printf("  filegroup(\n")
		} else {
			fmt.Printf("  build_rule(\n")
		}
		fmt.Printf("      name = '%s'\n", target.Label.Name)
		if len(target.Sources) > 0 {
			fmt.Printf("      srcs = [\n")
			for _, src := range target.Sources {
				fmt.Printf("          '%s',\n", src)
			}
			fmt.Printf("      ],\n")
		} else if target.NamedSources != nil {
			fmt.Printf("      srcs = {\n")
			for name, srcs := range target.NamedSources {
				fmt.Printf("          '%s': [\n", name)
				for _, src := range srcs {
					fmt.Printf("              '%s'\n", src)
				}
				fmt.Printf("          ],\n")
			}
			fmt.Printf("      },\n")
		}
		if len(target.DeclaredOutputs()) > 0 && !target.IsFilegroup() {
			fmt.Printf("      outs = [\n")
			for _, out := range target.DeclaredOutputs() {
				fmt.Printf("          '%s',\n", out)
			}
			fmt.Printf("      ],\n")
		}
		stringList("optional_outs", target.OptionalOutputs)
		pythonDict(target.Commands, "cmd")
		if !target.IsFilegroup() {
			fmt.Printf("      cmd = '%s'\n", target.Command)
		}
		pythonDict(target.TestCommands, "test_cmd")
		if target.TestCommand != "" {
			fmt.Printf("      test_cmd = '%s'\n", target.TestCommand)
		}
		pythonBool("binary", target.IsBinary)
		pythonBool("test", target.IsTest)
		pythonBool("needs_transitive_deps", target.NeedsTransitiveDependencies)
		if !target.IsFilegroup() {
			pythonBool("output_is_complete", target.OutputIsComplete)
			if target.BuildingDescription != core.DefaultBuildingDescription {
				fmt.Printf("      building_description = '%s',\n", target.BuildingDescription)
			}
		}
		pythonBool("stamp", target.Stamp)
		if target.ContainerSettings != nil {
			fmt.Printf("      container = {\n")
			fmt.Printf("          'docker_image': '%s',\n", target.ContainerSettings.DockerImage)
			fmt.Printf("          'docker_user': '%s',\n", target.ContainerSettings.DockerUser)
			fmt.Printf("          'docker_run_args': '%s',\n", target.ContainerSettings.DockerRunArgs)
		} else {
			pythonBool("container", target.Containerise)
		}
		pythonBool("no_test_output", target.NoTestOutput)
		pythonBool("test_only", target.TestOnly)
		labelList("deps", excludeLabels(target.DeclaredDependencies(), target.ExportedDependencies(), sourceLabels(target)), target)
		labelList("exported_deps", target.ExportedDependencies(), target)
		if len(target.Tools) > 0 {
			fmt.Printf("      tools = [\n")
			for _, tool := range target.Tools {
				fmt.Printf("          '%s',\n", tool)
			}
			fmt.Printf("      ],\n")
		}
		if len(target.Data) > 0 {
			fmt.Printf("      data = [\n")
			for _, datum := range target.Data {
				fmt.Printf("          '%s',\n", datum)
			}
			fmt.Printf("      ],\n")
		}
		stringList("labels", excludeStrings(target.Labels, target.Requires))
		stringList("hashes", target.Hashes)
		stringList("licences", target.Licences)
		stringList("test_outputs", target.TestOutputs)
		stringList("requires", target.Requires)
		if len(target.Provides) > 0 {
			fmt.Printf("      provides = {\n")
			for k, v := range target.Provides {
				if v.PackageName == target.Label.PackageName {
					fmt.Printf("          '%s': ':%s',\n", k, v.Name)
				} else {
					fmt.Printf("          '%s': '%s',\n", k, v)
				}
			}
			fmt.Printf("      },\n")
		}
		if target.Flakiness > 0 {
			fmt.Printf("      flaky = %d,\n", target.Flakiness)
//.........这里部分代码省略.........