"verbose log" mixed build bazel cquery commands (52cd1940) · Commits · e / os / android_build_soong

android/bazel_handler.go

+50 −23

Original line number	Diff line number	Diff line
		@@ -167,7 +167,8 @@ type BazelContext interface {
		}

		type bazelRunner interface {
		issueBazelCommand(paths *bazelPaths, runName bazel.RunName, command bazelCommand, extraFlags ...string) (string, string, error)
		createBazelCommand(paths bazelPaths, runName bazel.RunName, command bazelCommand, extraFlags ...string) exec.Cmd
		issueBazelCommand(bazelCmd *exec.Cmd) (output string, errorMessage string, error error)
		}

		type bazelPaths struct {
		@@ -460,16 +461,30 @@ type bazelCommand struct {

		type mockBazelRunner struct {
		bazelCommandResults map[bazelCommand]string
		// use *exec.Cmd as a key to get the bazelCommand, the map will be used in issueBazelCommand()
		// Register createBazelCommand() invocations. Later, an
		// issueBazelCommand() invocation can be mapped to the *exec.Cmd instance
		// and then to the expected result via bazelCommandResults
		tokens map[*exec.Cmd]bazelCommand
		commands []bazelCommand
		extraFlags []string
		}

		func (r mockBazelRunner) issueBazelCommand(_ bazelPaths, _ bazel.RunName,
		command bazelCommand, extraFlags ...string) (string, string, error) {
		func (r mockBazelRunner) createBazelCommand(paths bazelPaths, runName bazel.RunName,
		command bazelCommand, extraFlags ...string) *exec.Cmd {
		r.commands = append(r.commands, command)
		r.extraFlags = append(r.extraFlags, strings.Join(extraFlags, " "))
		if ret, ok := r.bazelCommandResults[command]; ok {
		return ret, "", nil
		cmd := &exec.Cmd{}
		if r.tokens == nil {
		r.tokens = make(map[*exec.Cmd]bazelCommand)
		}
		r.tokens[cmd] = command
		return cmd
		}

		func (r mockBazelRunner) issueBazelCommand(bazelCmd exec.Cmd) (string, string, error) {
		if command, ok := r.tokens[bazelCmd]; ok {
		return r.bazelCommandResults[command], "", nil
		}
		return "", "", nil
		}
		@@ -480,8 +495,20 @@ type builtinBazelRunner struct{}
		// Returns (stdout, stderr, error). The first and second return values are strings
		// containing the stdout and stderr of the run command, and an error is returned if
		// the invocation returned an error code.
		func (r builtinBazelRunner) issueBazelCommand(paths bazelPaths, runName bazel.RunName, command bazelCommand,
		extraFlags ...string) (string, string, error) {

		func (r builtinBazelRunner) issueBazelCommand(bazelCmd exec.Cmd) (string, string, error) {
		stderr := &bytes.Buffer{}
		bazelCmd.Stderr = stderr
		if output, err := bazelCmd.Output(); err != nil {
		return "", string(stderr.Bytes()),
		fmt.Errorf("bazel command failed. command: [%s], env: [%s], error [%s]", bazelCmd, bazelCmd.Env, stderr)
		} else {
		return string(output), string(stderr.Bytes()), nil
		}
		}

		func (r builtinBazelRunner) createBazelCommand(paths bazelPaths, runName bazel.RunName, command bazelCommand,
		extraFlags ...string) *exec.Cmd {
		cmdFlags := []string{
		"--output_base=" + absolutePath(paths.outputBase),
		command.command,
		@@ -525,15 +552,14 @@ func (r builtinBazelRunner) issueBazelCommand(paths bazelPaths, runName bazel.
		"BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1",
		}
		bazelCmd.Env = append(os.Environ(), extraEnv...)
		stderr := &bytes.Buffer{}
		bazelCmd.Stderr = stderr

		if output, err := bazelCmd.Output(); err != nil {
		return "", string(stderr.Bytes()),
		fmt.Errorf("bazel command failed. command: [%s], env: [%s], error [%s]", bazelCmd, bazelCmd.Env, stderr)
		} else {
		return string(output), string(stderr.Bytes()), nil
		return bazelCmd
		}

		func printableCqueryCommand(bazelCmd *exec.Cmd) string {
		outputString := strings.Join(bazelCmd.Env, " ") + " \"" + strings.Join(bazelCmd.Args, "\" \"") + "\""
		return outputString

		}

		func (context *bazelContext) mainBzlFileContents() []byte {
		@@ -838,15 +864,16 @@ func (context *bazelContext) InvokeBazel(config Config) error {

		const buildrootLabel = "@soong_injection//mixed_builds:buildroot"
		cqueryCmd := bazelCommand{"cquery", fmt.Sprintf("deps(%s, 2)", buildrootLabel)}
		cqueryOutput, cqueryErr, err := context.issueBazelCommand(context.paths, bazel.CqueryBuildRootRunName, cqueryCmd,
		cqueryCommandWithFlag := context.createBazelCommand(context.paths, bazel.CqueryBuildRootRunName, cqueryCmd,
		"--output=starlark", "--starlark:file="+absolutePath(cqueryFileRelpath))
		cqueryOutput, cqueryErr, err := context.issueBazelCommand(cqueryCommandWithFlag)
		if err != nil {
		return err
		}
		if err = ioutil.WriteFile(filepath.Join(soongInjectionPath, "cquery.out"), []byte(cqueryOutput), 0666); err != nil {
		cqueryCommandPrint := fmt.Sprintf("cquery command line:\n %s \n\n\n", printableCqueryCommand(cqueryCommandWithFlag))
		if err = ioutil.WriteFile(filepath.Join(soongInjectionPath, "cquery.out"), []byte(cqueryCommandPrint+cqueryOutput), 0666); err != nil {
		return err
		}

		cqueryResults := map[string]string{}
		for _, outputLine := range strings.Split(cqueryOutput, "\n") {
		if strings.Contains(outputLine, ">>") {
		@@ -882,8 +909,8 @@ func (context *bazelContext) InvokeBazel(config Config) error {
		}
		}
		aqueryCmd := bazelCommand{"aquery", fmt.Sprintf("deps(%s)", buildrootLabel)}
		if aqueryOutput, _, err := context.issueBazelCommand(context.paths, bazel.AqueryBuildRootRunName, aqueryCmd,
		extraFlags...); err == nil {
		if aqueryOutput, _, err := context.issueBazelCommand(context.createBazelCommand(context.paths, bazel.AqueryBuildRootRunName, aqueryCmd,
		extraFlags...)); err == nil {
		context.buildStatements, context.depsets, err = bazel.AqueryBuildStatements([]byte(aqueryOutput))
		}
		if err != nil {
		@@ -894,7 +921,7 @@ func (context *bazelContext) InvokeBazel(config Config) error {
		// Bazel build. This is necessary because aquery invocations do not generate this symlink forest,
		// but some of symlinks may be required to resolve source dependencies of the build.
		buildCmd := bazelCommand{"build", "@soong_injection//mixed_builds:phonyroot"}
		if _, _, err = context.issueBazelCommand(context.paths, bazel.BazelBuildPhonyRootRunName, buildCmd); err != nil {
		if _, _, err = context.issueBazelCommand(context.createBazelCommand(context.paths, bazel.BazelBuildPhonyRootRunName, buildCmd)); err != nil {
		return err
		}