native_process.go

package acpruntime

import (
	"context"
	"errors"
	"io"
	"os/exec"
	"sync"
	"syscall"
	"time"
)

// nativeProcessWait retains the one owned Wait result across cleanup retries.
type nativeProcessWait struct {
	mu         sync.Mutex
	cmd        *exec.Cmd
	scope      NativeProcessScope
	once       sync.Once
	done       chan struct{}
	err        error
	stopped    bool
	custodyErr error
}

func stopNativeProcess(ctx context.Context, cmd *exec.Cmd, stdin io.Closer, wait *nativeProcessWait) error {
	wait.mu.Lock()
	defer wait.mu.Unlock()
	if wait.stopped {
		return wait.custodyErr
	}
	if cmd == nil {
		cmd = wait.cmd
	}
	if stdin != nil {
		_ = stdin.Close()
	}
	if cmd != nil && cmd.Process != nil {
		wait.once.Do(func() {
			wait.done = make(chan struct{})
			go func() { wait.err = cmd.Wait(); close(wait.done) }()
		})
	}
	if wait.scope != nil {
		if err := wait.scope.Stop(ctx); err != nil {
			return wrapError(ErrorProcess, "native.scope.stop", "provider process domain stop is not confirmed", err)
		}
	}
	if cmd == nil || cmd.Process == nil {
		wait.stopped = true
		return wait.custodyErr
	}
	// A supplied scope owns all signalling. Do not target numeric PIDs after
	// the host has already stopped its domain; they may have been reused.
	pgid := 0
	if wait.scope == nil {
		pgid = processGroupIDAfterStart(cmd)
	}
	for _, stage := range []struct {
		duration time.Duration
		signal   syscall.Signal
	}{
		{1500 * time.Millisecond, syscall.SIGTERM},
		{time.Second, syscall.SIGKILL},
		{3 * time.Second, 0},
	} {
		timer := time.NewTimer(stage.duration)
		select {
		case <-wait.done:
			timer.Stop()
			if wait.scope == nil {
				_ = signalProcessTree(pgid, nil, syscall.SIGTERM)
			}
			var exit *exec.ExitError
			if wait.err != nil && !errors.As(wait.err, &exit) {
				return wrapError(ErrorProcess, "native.wait", "provider process Wait failed", wait.err)
			}
			wait.stopped = true
			return wait.custodyErr
		case <-ctx.Done():
			timer.Stop()
			if wait.scope == nil {
				_ = signalProcessTree(pgid, cmd.Process, syscall.SIGKILL)
			}
			return wrapError(ErrorProcess, "native.cleanup", "provider process exit is not confirmed", ctx.Err())
		case <-timer.C:
			if wait.scope == nil && stage.signal != 0 {
				_ = signalProcessTree(pgid, cmd.Process, stage.signal)
			}
		}
	}
	return wrapError(ErrorProcess, "native.cleanup", "provider process exit was not confirmed after cleanup", context.DeadlineExceeded)
}