test

Author: Mindgamesnl

.github/workflows/release.yml

@@ -77,6 +77,9 @@ jobs:
         id: get_version
         run: echo "version=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
 
+      - name: Clean artifacts directory
+        run: rm -rf ./artifacts
+
       - name: Download all artifacts
         uses: actions/download-artifact@v4
         with:

main.go

@@ -19,7 +19,6 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 )
 
@@ -479,8 +478,8 @@ func runServer(jarPath, memory string) error {
 
 	cmd := exec.CommandContext(ctx, "java", fmt.Sprintf("-Xmx%s", memory), "-jar", jarPath, "nogui")
 
-	// Place the child in its own process group so we can signal it (and its children) reliably
-	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	// Place the child in its own process group (POSIX) or leave default on Windows
+	setCmdSysProcAttr(cmd)
 
 	// Wire stdout/stderr directly
 	cmd.Stdout = os.Stdout
@@ -508,7 +507,8 @@ func runServer(jarPath, memory string) error {
 
 	// Signal handling: gracefully stop, then escalate
 	sigCh := make(chan os.Signal, 4)
-	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+	// Listen for interrupts and termination signals (SIGTERM on POSIX)
+	signal.Notify(sigCh, os.Interrupt)
 	defer signal.Stop(sigCh)
 
 	stopping := false
@@ -533,39 +533,25 @@ func runServer(jarPath, memory string) error {
 				// After grace period, escalate only once
 				select {
 				case <-escalateOnce:
-					go func(pid int) {
+					go func() {
 						t := time.NewTimer(10 * time.Second)
 						<-t.C
-						_ = syscall.Kill(-pid, syscall.SIGTERM)
-						t2 := time.NewTimer(5 * time.Second)
-						<-t2.C
-						_ = syscall.Kill(-pid, syscall.SIGKILL)
-					}(cmd.Process.Pid)
+						escalateTerminate(cmd)
+					}()
 				default:
 				}
 				continue
 			}
-			// Already stopping: forward the signal to the child process group immediately
-			_ = syscall.Kill(-cmd.Process.Pid, signalToSys(sig))
+			// Already stopping: forward the signal to the child
+			forwardSignal(cmd, sig)
 			if interrupts >= 3 {
 				// Hard kill on repeated interrupts
-				_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+				forceKill(cmd)
 			}
 		}
 	}
 }
 
-func signalToSys(sig os.Signal) syscall.Signal {
-	switch sig {
-	case os.Interrupt:
-		return syscall.SIGINT
-	case syscall.SIGTERM:
-		return syscall.SIGTERM
-	default:
-		return syscall.SIGINT
-	}
-}
-
 func acceptEula() error {
 	eulaContent := "# Minecraft EULA\n# Auto-accepted by mc utility\neula=true\n"
 	return os.WriteFile("eula.txt", []byte(eulaContent), 0644)

proc_posix.go

@@ -0,0 +1,52 @@
+//go:build !windows
+
+package main
+
+import (
+    "os"
+    "os/exec"
+    "syscall"
+    "time"
+)
+
+// setCmdSysProcAttr places the child into its own process group on POSIX systems
+func setCmdSysProcAttr(cmd *exec.Cmd) {
+    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+}
+
+// forwardSignal forwards signals to the child's process group
+func forwardSignal(cmd *exec.Cmd, sig os.Signal) {
+    if cmd == nil || cmd.Process == nil {
+        return
+    }
+    _ = syscall.Kill(-cmd.Process.Pid, signalToSys(sig))
+}
+
+// escalateTerminate tries SIGTERM then SIGKILL after a short delay
+func escalateTerminate(cmd *exec.Cmd) {
+    if cmd == nil || cmd.Process == nil {
+        return
+    }
+    pid := cmd.Process.Pid
+    _ = syscall.Kill(-pid, syscall.SIGTERM)
+    t2 := time.NewTimer(5 * time.Second)
+    <-t2.C
+    _ = syscall.Kill(-pid, syscall.SIGKILL)
+}
+
+// forceKill immediately terminates the process group
+func forceKill(cmd *exec.Cmd) {
+    if cmd == nil || cmd.Process == nil {
+        return
+    }
+    _ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+}
+
+func signalToSys(sig os.Signal) syscall.Signal {
+    switch s := sig.(type) {
+    case syscall.Signal:
+        return s
+    default:
+        return syscall.SIGINT
+    }
+}

proc_windows.go

@@ -0,0 +1,37 @@
+//go:build windows
+
+package main
+
+import (
+    "os"
+    "os/exec"
+    "time"
+)
+
+// setCmdSysProcAttr leaves defaults on Windows; no Setpgid available
+func setCmdSysProcAttr(cmd *exec.Cmd) {
+    // Optionally, set CreationFlags for new process group or console, but keep default for compatibility
+    // cmd.SysProcAttr = &syscall.SysProcAttr{CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP}
+}
+
+// forwardSignal is a no-op on Windows; best-effort termination is handled via forceKill
+func forwardSignal(cmd *exec.Cmd, sig os.Signal) {
+    // No portable signal forwarding on Windows
+}
+
+// escalateTerminate performs a best-effort immediate kill of the child process
+func escalateTerminate(cmd *exec.Cmd) {
+    if cmd == nil || cmd.Process == nil {
+        return
+    }
+    time.Sleep(3 * time.Second)
+    _ = cmd.Process.Kill()
+}
+
+// forceKill immediately kills the process on Windows
+func forceKill(cmd *exec.Cmd) {
+    if cmd == nil || cmd.Process == nil {
+        return
+    }
+    _ = cmd.Process.Kill()
+}