Method Run

mod/tigron/internal/com/command.go:169–270

Run starts the command in the background. It may error out immediately if the command fails to start (ErrFailedStarting).

(parentCtx context.Context)

// Run starts the command in the background.
// It may error out immediately if the command fails to start (ErrFailedStarting).
func (gc *Command) Run(parentCtx context.Context) error {
	// Lock
	gc.mutex.Lock()
	defer gc.mutex.Unlock()

	// Protect against dumb calls
	if gc.result != nil {
		return ErrExecAlreadyFinished
	} else if gc.exec != nil {
		return ErrExecAlreadyStarted
	}

	var (
		ctx       context.Context
		ctxCancel context.CancelFunc
		pipes     *stdPipes
		cmd       *exec.Cmd
		err       error
	)

	// Get a timing-out context
	if gc.Timeout == 0 {
		gc.Timeout = defaultTimeout
	}

	ctx, ctxCancel = context.WithTimeout(parentCtx, gc.Timeout)
	gc.startTime = time.Now()

	// Create a contextual command, set the logger
	cmd = gc.buildCommand(ctx)
	// Get a debug-logger from the context
	var (
		log logger.Logger
		ok  bool
	)

	if log, ok = parentCtx.Value(LoggerKey).(logger.Logger); !ok {
		log = nil
	}

	conLog := logger.NewLogger(log).Set("command", cmd.String())
	// FIXME: this is manual silencing of pipe logs (very noisy)
	// It should be possible to enable this with some debug flag.
	// Note that one probably never want this on unless they are actually debugging pipes issues...
	emLog := logger.NewLogger(nil).Set("command", cmd.String())

	gc.exec = &execution{
		context: ctx,
		cancel:  ctxCancel,
		command: cmd,
		log:     conLog,
	}

	// Prepare pipes
	pipes, err = newStdPipes(ctx, emLog, gc.ptyStdout, gc.ptyStderr, gc.ptyStdin, gc.writers)
	if err != nil {
		ctxCancel()