github.com/pingcap/failpoint@v0.0.0-20240412033321-fd0796e60f86/failpoint-toolexec/main.go

// Copyright 2024 PingCAP, Inc.
//
// 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 main

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/pingcap/errors"
	"github.com/pingcap/failpoint/code"
	"golang.org/x/mod/modfile"
)

var logger = log.New(os.Stderr, "[failpoint-toolexec]", log.LstdFlags)

func main() {
	if len(os.Args) < 2 {
		return
	}
	goCmd, buildArgs := os.Args[1], os.Args[2:]
	goCmdBase := filepath.Base(goCmd)
	if runtime.GOOS == "windows" {
		goCmdBase = strings.TrimSuffix(goCmd, ".exe")
	}

	if strings.ToLower(goCmdBase) == "compile" {
		if err := injectFailpoint(&buildArgs); err != nil {
			logger.Println("failed to inject failpoint", err)
		}
	}

	cmd := exec.Command(goCmd, buildArgs...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Run(); err != nil {
		logger.Println("failed to run command", err)
	}
}

func injectFailpoint(argsP *[]string) error {
	callersModule, err := findCallersModule()
	if err != nil {
		return err
	}

	// ref https://pkg.go.dev/cmd/compile#hdr-Command_Line
	var module string
	args := *argsP
	for i, arg := range args {
		if arg == "-p" {
			if i+1 < len(args) {
				module = args[i+1]
			}
			break
		}
	}
	if !strings.HasPrefix(module, callersModule) && module != "main" {
		return nil
	}

	fileIndices := make([]int, 0, len(args))
	for i, arg := range args {
		// find the golang source files of the caller's package
		if strings.HasSuffix(arg, ".go") && !inSDKOrMod(arg) {
			fileIndices = append(fileIndices, i)
		}
	}

	needExtraFile := false
	writer := &code.Rewriter{}
	writer.SetAllowNotChecked(true)
	for _, idx := range fileIndices {
		needExtraFile = injectFailpointForFile(writer, &args[idx], module) || needExtraFile
	}
	if needExtraFile {
		newFile := filepath.Join(tmpFolder, module, "failpoint_toolexec_extra.go")
		if err := writeExtraFile(newFile, writer.GetCurrentFile().Name.Name, module); err != nil {
			return err
		}
		*argsP = append(args, newFile)
	}
	return nil
}

// ref https://github.com/golang/go/blob/bdd27c4debfb51fe42df0c0532c1c747777b7a32/src/cmd/go/internal/modload/init.go#L1511
func findCallersModule() (string, error) {
	cwd, err := os.Getwd()
	if err != nil {
		return "", err
	}
	dir := filepath.Clean(cwd)

	// Look for enclosing go.mod.
	for {
		goModPath := filepath.Join(dir, "go.mod")
		if fi, err := os.Stat(goModPath); err == nil && !fi.IsDir() {
			data, err := os.ReadFile(goModPath)
			if err != nil {
				return "", err
			}
			f, err := modfile.ParseLax(goModPath, data, nil)
			if err != nil {
				return "", err
			}
			return f.Module.Mod.Path, err
		}
		d := filepath.Dir(dir)
		if d == dir {
			break
		}
		dir = d
	}
	return "", errors.New("go.mod file not found")
}

var goModCache = os.Getenv("GOMODCACHE")
var goRoot = runtime.GOROOT()

func inSDKOrMod(path string) bool {
	absPath, err := filepath.Abs(path)
	if err != nil {
		logger.Println("failed to get absolute path", err)
		return false
	}

	if goModCache != "" && strings.HasPrefix(absPath, goModCache) {
		return true
	}
	if strings.HasPrefix(absPath, goRoot) {
		return true
	}
	return false
}

var tmpFolder = filepath.Join(os.TempDir(), "failpoint-toolexec")

func injectFailpointForFile(w *code.Rewriter, file *string, module string) bool {
	newFile := filepath.Join(tmpFolder, module, filepath.Base(*file))
	newFileDir := filepath.Dir(newFile)
	if err := os.MkdirAll(newFileDir, 0700); err != nil {
		logger.Println("failed to create temp folder", err)
		return false
	}
	f, err := os.OpenFile(newFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		logger.Println("failed to open temp file", err)
		return false
	}
	defer f.Close()
	w.SetOutput(f)

	if err := w.RewriteFile(*file); err != nil {
		logger.Println("failed to rewrite file", err)
		return false
	}
	if !w.GetRewritten() {
		return false
	}
	*file = newFile
	return true
}

func writeExtraFile(filePath, packageName, module string) error {
	bindingContent := fmt.Sprintf(`
package %s

func %s(name string) string {
	return "%s/" + name
}
`, packageName, code.ExtendPkgName, module)
	return os.WriteFile(filePath, []byte(bindingContent), 0644)
}