fix(emissary): signal SIGINT/SIGTERM in windows correctly (#13693)

Signed-off-by: Michael Weibel <michael@helio.exchange>

go.mod

@@ -290,7 +290,7 @@ require (
 	go.opencensus.io v0.24.0 // indirect
 	go.starlark.net v0.0.0-20230525235612-a134d8f9ddca // indirect
 	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
+	golang.org/x/sys v0.21.0
 	golang.org/x/term v0.21.0
 	golang.org/x/text v0.16.0 // indirect
 	google.golang.org/appengine v1.6.8 // indirect

workflow/executor/os-specific/signal_windows.go

@@ -1,14 +1,21 @@
 package os_specific
 
 import (
+	"fmt"
 	"os"
 	"syscall"
+	"unsafe"
 
 	"github.com/argoproj/argo-workflows/v3/util/errors"
+	"golang.org/x/sys/windows"
 )
 
 var (
 	Term = os.Interrupt
+
+	modkernel32            = windows.NewLazySystemDLL("kernel32.dll")
+	procCreateRemoteThread = modkernel32.NewProc("CreateRemoteThread")
+	procCtrlRoutine        = modkernel32.NewProc("CtrlRoutine")
 )
 
 func CanIgnoreSignal(s os.Signal) bool {
@@ -19,11 +26,23 @@ func Kill(pid int, s syscall.Signal) error {
 	if pid < 0 {
 		pid = -pid // // we cannot kill a negative process on windows
 	}
-	p, err := os.FindProcess(pid)
-	if err != nil {
-		return err
+
+	winSignal := -1
+	switch s {
+	case syscall.SIGTERM:
+		winSignal = windows.CTRL_SHUTDOWN_EVENT
+	case syscall.SIGINT:
+		winSignal = windows.CTRL_C_EVENT
 	}
-	return p.Signal(s)
+
+	if winSignal == -1 {
+		p, err := os.FindProcess(pid)
+		if err != nil {
+			return err
+		}
+		return p.Signal(s)
+	}
+	return signalProcess(uint32(pid), winSignal)
 }
 
 func Setpgid(a *syscall.SysProcAttr) {
@@ -37,3 +56,77 @@ func Wait(process *os.Process) error {
 	}
 	return err
 }
+
+// signalProcess sends the specified signal to a process.
+//
+// Code +/- copied from: https://github.com/microsoft/hcsshim/blob/1d69a9c658655b77dd4e5275bff99caad6b38416/internal/jobcontainers/process.go#L251
+// License: MIT
+// Author: Microsoft
+func signalProcess(pid uint32, signal int) error {
+	hProc, err := windows.OpenProcess(windows.PROCESS_TERMINATE, true, pid)
+	if err != nil {
+		return fmt.Errorf("failed to open process: %w", err)
+	}
+	defer func() {
+		_ = windows.Close(hProc)
+	}()
+
+	if err := procCtrlRoutine.Find(); err != nil {
+		return fmt.Errorf("failed to load CtrlRoutine: %w", err)
+	}
+
+	threadHandle, err := createRemoteThread(hProc, nil, 0, procCtrlRoutine.Addr(), uintptr(signal), 0, nil)
+	if err != nil {
+		return fmt.Errorf("failed to open remote thread in target process %d: %w", pid, err)
+	}
+	defer func() {
+		_ = windows.Close(windows.Handle(threadHandle))
+	}()
+	return nil
+}
+
+// Following code has been generated using github.com/Microsoft/go-winio/tools/mkwinsyscall and inlined
+// for easier usage
+
+// HANDLE CreateRemoteThread(
+//
+//	HANDLE                 hProcess,
+//	LPSECURITY_ATTRIBUTES  lpThreadAttributes,
+//	SIZE_T                 dwStackSize,
+//	LPTHREAD_START_ROUTINE lpStartAddress,
+//	LPVOID                 lpParameter,
+//	DWORD                  dwCreationFlags,
+//	LPDWORD                lpThreadId
+//
+// );
+func createRemoteThread(process windows.Handle, sa *windows.SecurityAttributes, stackSize uint32, startAddr uintptr, parameter uintptr, creationFlags uint32, threadID *uint32) (handle windows.Handle, err error) {
+	r0, _, e1 := syscall.SyscallN(procCreateRemoteThread.Addr(), uintptr(process), uintptr(unsafe.Pointer(sa)), uintptr(stackSize), uintptr(startAddr), uintptr(parameter), uintptr(creationFlags), uintptr(unsafe.Pointer(threadID)))
+	handle = windows.Handle(r0)
+	if handle == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
+var (
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+	errERROR_EINVAL     error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+	switch e {
+	case 0:
+		return errERROR_EINVAL
+	case errnoERROR_IO_PENDING:
+		return errERROR_IO_PENDING
+	}
+	return e
+}

workflow/executor/os-specific/signal_windows_test.go

@@ -0,0 +1,36 @@
+//go:build windows
+
+package os_specific
+
+import (
+	"os/exec"
+	"sync"
+	"syscall"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKill(t *testing.T) {
+	shell := "pwsh.exe"
+	cmd := exec.Command(shell, "-c", `while(1) { sleep 600000 }`)
+
+	_, err := StartCommand(cmd)
+	require.NoError(t, err)
+
+	var wg sync.WaitGroup
+	go func() {
+		wg.Add(1)
+		defer wg.Done()
+
+		err = cmd.Wait()
+		// we'll get an exit code
+		assert.Error(t, err)
+	}()
+
+	err = Kill(cmd.Process.Pid, syscall.SIGTERM)
+	require.NoError(t, err)
+
+	wg.Wait()
+}