compiler_wrapper: disable rusage when goma enabled

This disables rusage logging when Goma is enabled as goma makes the
resulting logs meaningless.

BUG=None
TEST=Updated and ran go tests

Change-Id: If55a820676faa6b40d471db48749d384b7e2c671
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/toolchain-utils/+/2840684
Reviewed-by: George Burgess <gbiv@chromium.org>
Tested-by: Ryan Beltran <ryanbeltran@chromium.org>

2 files changed, 56 insertions, 21 deletions

diff --git a/compiler_wrapper/compiler_wrapper.go b/compiler_wrapper/compiler_wrapper.go
index 8538fd49..9d7b76e5 100644
--- a/compiler_wrapper/compiler_wrapper.go
+++ b/compiler_wrapper/compiler_wrapper.go
@@ -81,6 +81,7 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 	// Disable CCache for rusage logs
 	// Note: Disabling Goma causes timeout related INFRA_FAILUREs in builders
 	allowCCache := !rusageEnabled
+	gomaUsed := false
 
 	workAroundKernelBugWithRetries := false
 	if cfg.isAndroidWrapper {
@@ -90,7 +91,7 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 			mainBuilder.addPreUserArgs(mainBuilder.cfg.clangFlags...)
 			mainBuilder.addPreUserArgs(mainBuilder.cfg.commonFlags...)
 			mainBuilder.addPostUserArgs(mainBuilder.cfg.clangPostFlags...)
-			if _, err := processGomaCccFlags(mainBuilder); err != nil {
+			if gomaUsed, err = processGomaCccFlags(mainBuilder); err != nil {
 				return 0, err
 			}
 			compilerCmd = mainBuilder.build()
@@ -126,24 +127,24 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 					return 0, err
 				}
 			}
-			if err := processGomaCCacheFlags(allowCCache, mainBuilder); err != nil {
+			if gomaUsed, err = processGomaCCacheFlags(allowCCache, mainBuilder); err != nil {
 				return 0, err
 			}
 			compilerCmd = mainBuilder.build()
 		} else {
 			if clangSyntax {
 				allowCCache = false
-				clangCmd, err := calcClangCommand(allowCCache, mainBuilder.clone())
+				_, clangCmd, err := calcClangCommand(allowCCache, mainBuilder.clone())
 				if err != nil {
 					return 0, err
 				}
-				gccCmd, err := calcGccCommand(rusageEnabled, mainBuilder)
+				_, gccCmd, err := calcGccCommand(rusageEnabled, mainBuilder)
 				if err != nil {
 					return 0, err
 				}
 				return checkClangSyntax(env, clangCmd, gccCmd)
 			}
-			compilerCmd, err = calcGccCommand(rusageEnabled, mainBuilder)
+			gomaUsed, compilerCmd, err = calcGccCommand(rusageEnabled, mainBuilder)
 			if err != nil {
 				return 0, err
 			}
@@ -244,10 +245,11 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 		case err != nil:
 			return exitCode, err
 		default:
-			if err := commitRusage(exitCode); err != nil {
-				return exitCode, fmt.Errorf("commiting rusage: %v", err)
+			if !gomaUsed {
+				if err := commitRusage(exitCode); err != nil {
+					return exitCode, fmt.Errorf("commiting rusage: %v", err)
+				}
 			}
-
 			return exitCode, err
 		}
 	}
@@ -266,30 +268,34 @@ func prepareClangCommand(builder *commandBuilder) (err error) {
 	return processClangFlags(builder)
 }
 
-func calcClangCommand(allowCCache bool, builder *commandBuilder) (*command, error) {
+func calcClangCommand(allowCCache bool, builder *commandBuilder) (bool, *command, error) {
 	err := prepareClangCommand(builder)
 	if err != nil {
-		return nil, err
+		return false, nil, err
 	}
-	if err := processGomaCCacheFlags(allowCCache, builder); err != nil {
-		return nil, err
+	gomaUsed, err := processGomaCCacheFlags(allowCCache, builder)
+	if err != nil {
+		return gomaUsed, nil, err
 	}
-	return builder.build(), nil
+	return gomaUsed, builder.build(), nil
 }
 
-func calcGccCommand(enableRusage bool, builder *commandBuilder) (*command, error) {
+func calcGccCommand(enableRusage bool, builder *commandBuilder) (bool, *command, error) {
 	if !builder.cfg.isHostWrapper {
 		processSysrootFlag(builder)
 	}
 	builder.addPreUserArgs(builder.cfg.gccFlags...)
 	calcCommonPreUserArgs(builder)
 	processGccFlags(builder)
+
+	gomaUsed := false
 	if !builder.cfg.isHostWrapper {
-		if err := processGomaCCacheFlags(!enableRusage, builder); err != nil {
-			return nil, err
+		var err error
+		if gomaUsed, err = processGomaCCacheFlags(!enableRusage, builder); err != nil {
+			return gomaUsed, nil, err
 		}
 	}
-	return builder.build(), nil
+	return gomaUsed, builder.build(), nil
 }
 
 func calcCommonPreUserArgs(builder *commandBuilder) {
@@ -303,18 +309,19 @@ func calcCommonPreUserArgs(builder *commandBuilder) {
 	processSanitizerFlags(builder)
 }
 
-func processGomaCCacheFlags(allowCCache bool, builder *commandBuilder) (err error) {
-	gomaccUsed := false
+func processGomaCCacheFlags(allowCCache bool, builder *commandBuilder) (gomaccUsed bool, err error) {
+
+	gomaccUsed = false
 	if !builder.cfg.isHostWrapper {
 		gomaccUsed, err = processGomaCccFlags(builder)
 		if err != nil {
-			return err
+			return gomaccUsed, err
 		}
 	}
 	if !gomaccUsed && allowCCache {
 		processCCacheFlag(builder)
 	}
-	return nil
+	return gomaccUsed, nil
 }
 
 func getAbsWrapperPath(env env, wrapperCmd *command) (string, error) {
diff --git a/compiler_wrapper/compiler_wrapper_test.go b/compiler_wrapper/compiler_wrapper_test.go
index dc2a9dd5..fd59cfe1 100644
--- a/compiler_wrapper/compiler_wrapper_test.go
+++ b/compiler_wrapper/compiler_wrapper_test.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 	"syscall"
@@ -96,6 +97,33 @@ func TestLogMissingCCacheExecError(t *testing.T) {
 	})
 }
 
+func TestGomaDisablesRusage(t *testing.T) {
+	withTestContext(t, func(ctx *testContext) {
+		gomaPath := path.Join(ctx.tempDir, "gomacc")
+		ctx.writeFile(gomaPath, "")
+		ctx.env = []string{"GOMACC_PATH=" + gomaPath}
+		logFileName := filepath.Join(ctx.tempDir, "rusage.log")
+		ctx.env = []string{
+			"TOOLCHAIN_RUSAGE_OUTPUT=" + logFileName,
+			"GOMACC_PATH=" + gomaPath,
+		}
+		cmd := ctx.must(callCompiler(ctx, ctx.cfg, ctx.newCommand(gccX86_64, mainCc)))
+		// Ensure Goma was used
+		if err := verifyPath(cmd, gomaPath); err != nil {
+			t.Fatal(err)
+		}
+		if err := verifyArgOrder(cmd, gccX86_64+".real", mainCc); err != nil {
+			t.Error(err)
+		}
+		// Ensure rusage log was not created
+		if _, err := os.Stat(logFileName); err == nil {
+			t.Errorf("Logfile shouldn't have been created at TOOLCHAIN_RUSAGE_OUTPUT path %q but was", logFileName)
+		} else if !os.IsNotExist(err) {
+			t.Fatalf("error checking for rusage logfile at %q: %v", logFileName, err)
+		}
+	})
+}
+
 func TestLogRusageAndForceDisableWError(t *testing.T) {
 	withTestContext(t, func(ctx *testContext) {
 		logFileName := filepath.Join(ctx.tempDir, "rusage.log")