Add support for running go-transcode on Windows (#41)

* build and run (VOD only) on Windows systems.

Really the only platform-dependent bits of code were the process group
management. I've replaced those with Windows-specific versions, although
I haven't fully tested them, because I'm not entirely sure how they're
used.
Also, the build configuration for Linux and other non-Windows platforms
is completely untested.

* add Windows command group.

* move to utils.

---------

Co-authored-by: Miroslav Šedivý <[email protected]>

Author: hheimbuerger

.gitignore

@@ -3,3 +3,4 @@
 /go-transcode
 /bin
 /.env
+.vscode/

hls/manager.go

@@ -15,6 +15,7 @@ import (
 	"github.com/rs/zerolog/log"
 
 	"github.com/m1k1o/go-transcode/internal/utils"
+	"github.com/m1k1o/go-transcode/internal/utils/cmdgroup"
 )
 
 // how often should be cleanup called
@@ -92,8 +93,8 @@ func (m *ManagerCtx) Start() error {
 	read, write := io.Pipe()
 	m.cmd.Stdout = write
 
-	// create a new process group
-	m.cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	// configure command to run in its own process group / job object
+	cmdgroup.Configure(m.cmd)
 
 	m.active = false
 	m.lastRequest = time.Now()
@@ -195,21 +196,15 @@ func (m *ManagerCtx) Start() error {
 	return err
 }
 
+// Stop terminates the running command and its children.
 func (m *ManagerCtx) Stop() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	if m.cmd != nil && m.cmd.Process != nil {
 		m.logger.Debug().Msg("performing stop")
-
-		pgid, err := syscall.Getpgid(m.cmd.Process.Pid)
-		if err == nil {
-			err := syscall.Kill(-pgid, syscall.SIGKILL)
-			m.logger.Err(err).Msg("killing process group")
-		} else {
-			m.logger.Err(err).Msg("could not get process group id")
-			err := m.cmd.Process.Kill()
-			m.logger.Err(err).Msg("killing process")
+		if err := cmdgroup.Kill(m.cmd); err != nil {
+			m.logger.Err(err).Msg("failed to kill process group")
 		}
 	}
 }

internal/api/http.go

@@ -22,7 +22,7 @@ func (a *ApiManagerCtx) Http(r chi.Router) {
 		// dummy input for testing purposes
 		file := a.config.AbsPath("profiles", "http-test.sh")
 		cmd := exec.Command(file)
-		logger.Info().Msg("command startred")
+		logger.Info().Msg("command started")
 
 		read, write := io.Pipe()
 		cmd.Stdout = write

internal/api/router.go

@@ -90,6 +90,6 @@ func (a *ApiManagerCtx) transcodeStart(profilePath string, input string) (*exec.
 		return nil, fmt.Errorf("stream not found")
 	}
 
-	log.Info().Str("profilePath", profilePath).Str("url", url).Msg("command startred")
+	log.Info().Str("profilePath", profilePath).Str("url", url).Msg("command started")
 	return exec.Command(profilePath, url), nil
 }

internal/utils/cmdgroup/cmdgroup.go

@@ -0,0 +1,15 @@
+package cmdgroup
+
+import "os/exec"
+
+// Configure applies platform-specific settings so the command starts in its own
+// process-group / job-object. Call this before cmd.Start().
+func Configure(cmd *exec.Cmd) {
+	platformConfigure(cmd)
+}
+
+// Kill terminates the command together with all of its children.
+// It is safe to call this even if the command has already exited.
+func Kill(cmd *exec.Cmd) error {
+	return platformKill(cmd)
+}

internal/utils/cmdgroup/platform_unix.go

@@ -0,0 +1,30 @@
+//go:build !windows
+// +build !windows
+
+package cmdgroup
+
+import (
+	"os/exec"
+	"syscall"
+
+	"github.com/rs/zerolog/log"
+)
+
+func platformConfigure(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+}
+
+func platformKill(cmd *exec.Cmd) error {
+	if cmd == nil || cmd.Process == nil {
+		return nil
+	}
+
+	pgid, err := syscall.Getpgid(cmd.Process.Pid)
+	if err != nil {
+		// could not obtain pgid, log and fallback to direct kill
+		log.Err(err).Msg("could not get process group id")
+		return cmd.Process.Kill()
+	}
+
+	return syscall.Kill(-pgid, syscall.SIGKILL)
+}

internal/utils/cmdgroup/platform_windows.go

@@ -0,0 +1,27 @@
+//go:build windows
+// +build windows
+
+package cmdgroup
+
+import (
+	"os"
+	"os/exec"
+	"strconv"
+	"syscall"
+)
+
+func platformConfigure(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP}
+}
+
+func platformKill(cmd *exec.Cmd) error {
+	if cmd == nil || cmd.Process == nil {
+		return nil
+	}
+
+	// TASKKILL /T /PID <pid>
+	kill := exec.Command("TASKKILL", "/T", "/PID", strconv.Itoa(cmd.Process.Pid))
+	kill.Stdout = os.Stdout
+	kill.Stderr = os.Stderr
+	return kill.Run()
+}