🐛 QD-11516: Ensure subprocess termination on Windows (#589)

* 🐛 QD-11516: Fix Qodana CLI not killing children on exit on Windows

* 🎨 QD-11516: Remove unused imports

* 🐛 QD-11516: Do not try sending os.Interrupt on Windows

Author: bindreams

cdnet/main.go

@@ -17,12 +17,9 @@
 package main
 
 import (
-	"fmt"
-	log "github.com/sirupsen/logrus"
-	"io"
 	"os"
-	"os/signal"
-	"syscall"
+
+	"github.com/JetBrains/qodana-cli/v2025/platform/process"
 )
 
 const (
@@ -38,14 +35,6 @@ var buildDateStr = "2023-12-05T10:52:23Z"
 
 // noinspection GoUnusedFunction
 func main() {
-	InterruptChannel = make(chan os.Signal, 1)
-	signal.Notify(InterruptChannel, os.Interrupt)
-	signal.Notify(InterruptChannel, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-InterruptChannel
-		fmt.Println("Interrupting Qodana...")
-		log.SetOutput(io.Discard)
-		os.Exit(0)
-	}()
+	process.Init()
 	Execute(productCode, linterName, version, buildDateStr, true)
 }

clang/main.go

@@ -1,12 +1,9 @@
 package main
 
 import (
-	"fmt"
-	log "github.com/sirupsen/logrus"
-	"io"
 	"os"
-	"os/signal"
-	"syscall"
+
+	"github.com/JetBrains/qodana-cli/v2025/platform/process"
 )
 
 const (
@@ -20,14 +17,6 @@ var buildDateStr = "2024-04-05T10:52:23Z"
 
 // noinspection GoUnusedFunction
 func main() {
-	InterruptChannel = make(chan os.Signal, 1)
-	signal.Notify(InterruptChannel, os.Interrupt)
-	signal.Notify(InterruptChannel, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-InterruptChannel
-		fmt.Println("Interrupting Qodana...")
-		log.SetOutput(io.Discard)
-		os.Exit(0)
-	}()
+	process.Init()
 	Execute(productCode, linterName, version, buildDateStr, true)
 }

cli/main.go

@@ -18,30 +18,11 @@ package main
 
 import (
 	"github.com/JetBrains/qodana-cli/v2025/cmd"
-	"github.com/JetBrains/qodana-cli/v2025/core"
-	"github.com/JetBrains/qodana-cli/v2025/platform/commoncontext"
-	"github.com/JetBrains/qodana-cli/v2025/platform/msg"
-	"github.com/JetBrains/qodana-cli/v2025/platform/version"
-	log "github.com/sirupsen/logrus"
-	"io"
-	"os"
-	"os/signal"
-	"syscall"
+	"github.com/JetBrains/qodana-cli/v2025/platform/process"
 )
 
 func main() {
-	commoncontext.InterruptChannel = make(chan os.Signal, 1)
-	signal.Notify(commoncontext.InterruptChannel, os.Interrupt)
-	signal.Notify(commoncontext.InterruptChannel, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-commoncontext.InterruptChannel
-		msg.WarningMessage("Interrupting Qodana CLI...")
-		log.SetOutput(io.Discard)
-		core.CheckForUpdates(version.Version)
-		core.ContainerCleanup()
-		_ = msg.QodanaSpinner.Stop()
-		os.Exit(0)
-	}()
+	process.Init()
 	cmd.InitCli()
 	cmd.Execute()
 }

platform/process/init.go

@@ -0,0 +1,35 @@
+package process
+
+import (
+	"github.com/JetBrains/qodana-cli/v2025/core"
+	"github.com/JetBrains/qodana-cli/v2025/platform/commoncontext"
+	"github.com/JetBrains/qodana-cli/v2025/platform/msg"
+	"github.com/JetBrains/qodana-cli/v2025/platform/version"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+// Init runs miscellaneous process-wide utility code.
+func Init() {
+	KillProcessTreeOnClose()
+
+	commoncontext.InterruptChannel = make(chan os.Signal, 1)
+	signal.Notify(commoncontext.InterruptChannel, os.Interrupt)
+	signal.Notify(commoncontext.InterruptChannel, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-commoncontext.InterruptChannel
+		msg.WarningMessage("Interrupting Qodana...")
+		log.SetOutput(io.Discard)
+		core.CheckForUpdates(version.Version)
+		core.ContainerCleanup()
+		_ = msg.QodanaSpinner.Stop()
+		// Sleep for a second to allow other functions monitoring signals elsewhere to do their thing.
+		// A future rewrite of the subprocess API should incorporate a more structured signal handling.
+		time.Sleep(1 * time.Second)
+		os.Exit(0)
+	}()
+}

platform/process/init_posix.go

@@ -0,0 +1,7 @@
+//go:build unix
+
+package process
+
+func KillProcessTreeOnClose() {
+	// Not implemented
+}

platform/process/init_windows.go

@@ -0,0 +1,25 @@
+package process
+
+import (
+	"golang.org/x/sys/windows"
+	"log"
+	"unsafe"
+)
+
+func KillProcessTreeOnClose() {
+	job, err := windows.CreateJobObject(nil, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	info := windows.JOBOBJECT_EXTENDED_LIMIT_INFORMATION{}
+	info.BasicLimitInformation.LimitFlags = windows.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+	windows.SetInformationJobObject(
+		job,
+		windows.JobObjectExtendedLimitInformation,
+		uintptr(unsafe.Pointer(&info)),
+		uint32(unsafe.Sizeof(info)),
+	)
+
+	windows.AssignProcessToJobObject(job, windows.CurrentProcess())
+}

platform/utils/cmd.go

@@ -198,7 +198,7 @@ func getCwdPath(cwd string) (string, error) {
 // handleSignals handles the signals from the subprocess
 func handleSignals(cmd *exec.Cmd, waitCh <-chan error, timeout time.Duration, timeoutExitCode int) (int, error) {
 	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
 	defer func() {
 		signal.Stop(sigChan) // Use Stop to prevent panics
 		close(sigChan)
@@ -208,15 +208,15 @@ func handleSignals(cmd *exec.Cmd, waitCh <-chan error, timeout time.Duration, ti
 
 	for {
 		select {
-		case sig := <-sigChan:
-			if err := cmd.Process.Signal(sig); err != nil && !errors.Is(
+		case <-sigChan:
+			if err := RequestTermination(cmd.Process); err != nil && !errors.Is(
 				err,
 				os.ErrProcessDone,
 			) { // Use errors.Is for semantic comparison
-				log.Error("Error sending signal: ", sig, err)
+				log.Error("Error terminating process: ", err)
 			}
 		case <-timeoutCh:
-			if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
+			if err := RequestTermination(cmd.Process); err != nil {
 				log.Fatal("failed to kill process on timeout: ", err)
 			}
 			_, _ = cmd.Process.Wait()

platform/utils/cmd_others.go

@@ -20,11 +20,17 @@ package utils
 
 import (
 	"log"
+	"os"
 	"os/exec"
+	"syscall"
 )
 
 //goland:noinspection GoUnusedParameter
 func prepareWinCmd(args ...string) *exec.Cmd {
 	log.Fatal("Function should not be called on non-windows platforms")
 	return nil
 }
+
+func RequestTermination(proc *os.Process) error {
+	return proc.Signal(syscall.SIGTERM)
+}

platform/utils/cmd_windows.go

@@ -20,8 +20,10 @@
 package utils
 
 import (
+	log "github.com/sirupsen/logrus"
 	"os"
 	"os/exec"
+	"strconv"
 	"strings"
 	"syscall"
 )
@@ -38,3 +40,26 @@ func prepareWinCmd(args ...string) *exec.Cmd {
 	cmd.SysProcAttr = &syscall.SysProcAttr{CmdLine: "/C \"" + commandLine + "\""}
 	return cmd
 }
+
+func RequestTermination(proc *os.Process) error {
+	command := exec.Command("taskkill.exe", "/pid", strconv.Itoa(proc.Pid))
+	output, err := command.CombinedOutput()
+	log.Debugf("%s: %s", command.String(), output)
+
+	if exitErr, ok := err.(*exec.ExitError); ok {
+		if exitErr.ExitCode() == 1 {
+			// Exit code 1 could mean at least:
+			// - access denied
+			// - the process can only be terminated forcefully
+			// if the process can only be terminated forcefully, this is considered a "we tried" scenario
+			// and no error should be returned. other errors with this exit code are logged and ignored.
+			return nil
+		}
+		if exitErr.ExitCode() == 128 {
+			// process not found (supposedly already exited)
+			return os.ErrProcessDone
+		}
+	}
+
+	return err
+}