gocommand

Documentation

Overview

Package gocommand is a helper for calling the go command.

Index

• Variables
• func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error)
• func GoVersionString(ctx context.Context, inv Invocation, r *Runner) (string, error)
• func HandleHangingGoCommand(proc *os.Process)
• type Invocation
• type ModuleJSON
  • func VendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, *ModuleJSON, error)
• type Runner
  • func (runner *Runner) Run(ctx context.Context, inv Invocation) (*bytes.Buffer, error)
  • func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) error
  • func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error)

Variables

var DebugHangingGoCommands = false

DebugHangingGoCommands may be set by tests to enable additional instrumentation (including panics) for debugging hanging Go commands.

See golang/go#54461 for details.

Functions

func GoVersion

func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error)

GoVersion reports the minor version number of the highest release tag built into the go command on the PATH.

Note that this may be higher than the version of the go tool used to build this application, and thus the versions of the standard go/{scanner,parser,ast,types} packages that are linked into it. In that case, callers should either downgrade to the version of go used to build the application, or report an error that the application is too old to use the go command on the PATH.

func GoVersionString

func GoVersionString(ctx context.Context, inv Invocation, r *Runner) (string, error)

GoVersionString reports the go version string as shown in `go version` command output. When `go version` outputs in non-standard form, this returns an empty string.

func HandleHangingGoCommand

func HandleHangingGoCommand(proc *os.Process)

Types

type Invocation

type Invocation struct {
	Verb       string
	Args       []string
	BuildFlags []string

	// If ModFlag is set, the go command is invoked with -mod=ModFlag.
	ModFlag string

	// If ModFile is set, the go command is invoked with -modfile=ModFile.
	ModFile string

	// If Overlay is set, the go command is invoked with -overlay=Overlay.
	Overlay string

	// If CleanEnv is set, the invocation will run only with the environment
	// in Env, not starting with os.Environ.
	CleanEnv   bool
	Env        []string
	WorkingDir string
	Logf       func(format string, args ...interface{})
}

An Invocation represents a call to the go command.

type ModuleJSON

type ModuleJSON struct {
	Path      string      // module path
	Version   string      // module version
	Versions  []string    // available module versions (with -versions)
	Replace   *ModuleJSON // replaced by this module
	Time      *time.Time  // time version was created
	Update    *ModuleJSON // available update, if any (with -u)
	Main      bool        // is this the main module?
	Indirect  bool        // is this module only an indirect dependency of main module?
	Dir       string      // directory holding files for this module, if any
	GoMod     string      // path to go.mod file used when loading this module, if any
	GoVersion string      // go version used in module
}

ModuleJSON holds information about a module.

func VendorEnabled

func VendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, *ModuleJSON, error)

VendorEnabled reports whether vendoring is enabled. It takes a *Runner to execute Go commands with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields, of which only Verb and Args are modified to run the appropriate Go command. Inspired by setDefaultBuildMod in modload/init.go

type Runner

type Runner struct {
	// contains filtered or unexported fields
}

An Runner will run go command invocations and serialize them if it sees a concurrency error.

func (*Runner) Run

func (runner *Runner) Run(ctx context.Context, inv Invocation) (*bytes.Buffer, error)

Run is a convenience wrapper around RunRaw. It returns only stdout and a "friendly" error.

func (*Runner) RunPiped

func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) error

RunPiped runs the invocation serially, always waiting for any concurrent invocations to complete first.

func (*Runner) RunRaw

func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error)

RunRaw runs the invocation, serializing requests only if they fight over go.mod changes.