refactoring process management: no more orphan processes and quicker chrome startup

internal/pkg/chrome/chrome.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"os"
 	"os/exec"
+	"strings"
+	"syscall"
 	"time"
 
 	"github.com/mafredri/cdp/devtool"
@@ -13,66 +15,26 @@ import (
 	"github.com/thecodingmachine/gotenberg/internal/pkg/xtime"
 )
 
-func Start(ctx context.Context, logger xlog.Logger) (*os.Process, error) {
+// Start starts Google Chrome headless in background.
+func Start(logger xlog.Logger) error {
 	const op string = "chrome.Start"
-	logger.DebugOp(op, "starting new Google Chrome process on port 9222...")
-	resolver := func() (*os.Process, error) {
-		binary := "google-chrome-stable"
-		args := []string{
-			"--no-sandbox",
-			"--headless",
-			// see https://github.com/GoogleChrome/puppeteer/issues/2410.
-			"--font-render-hinting=medium",
-			"--remote-debugging-port=9222",
-			"--disable-gpu",
-			"--disable-translate",
-			"--disable-extensions",
-			"--disable-background-networking",
-			"--safebrowsing-disable-auto-update",
-			"--disable-sync",
-			"--disable-default-apps",
-			"--hide-scrollbars",
-			"--metrics-recording-only",
-			"--mute-audio",
-			"--no-first-run",
-		}
-		cmd, err := xexec.CommandContext(ctx, logger, binary, args...)
+	logger.DebugOp(op, "starting new Google Chrome headless process on port 9222...")
+	resolver := func() error {
+		cmd, err := cmd(logger)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		// we try to start the process.
 		xexec.LogBeforeExecute(logger, cmd)
 		if err := cmd.Start(); err != nil {
-			return cmd.Process, err
+			return err
 		}
-		// we wait the process to be ready.
-		warmup(logger)
 		// if the process failed to start correctly,
 		// we have to restart it.
 		if !isViable(logger) {
-			return restart(ctx, logger, cmd)
+			return restart(logger, cmd.Process)
 		}
-		return cmd.Process, nil
-	}
-	proc, err := resolver()
-	if err != nil {
-		if errKill := Kill(logger, proc); errKill != nil {
-			logger.ErrorOp(op, errKill)
-		}
-		return nil, xerror.New(op, err)
-	}
-	return proc, nil
-}
-
-func Kill(logger xlog.Logger, proc *os.Process) error {
-	const op string = "chrome.Kill"
-	resolver := func() error {
-		logger.DebugOp(op, "removing Google Chrome process using port 9222...")
-		if proc == nil {
-			logger.DebugOp(op, "no Google Chrome process using port 9222 found, skipping")
-			return nil
-		}
-		return proc.Kill()
+		return nil
 	}
 	if err := resolver(); err != nil {
 		return xerror.New(op, err)
@@ -80,60 +42,125 @@ func Kill(logger xlog.Logger, proc *os.Process) error {
 	return nil
 }
 
-func restart(ctx context.Context, logger xlog.Logger, cmd *exec.Cmd) (*os.Process, error) {
+func cmd(logger xlog.Logger) (*exec.Cmd, error) {
+	const op string = "chrome.cmd"
+	binary := "google-chrome-stable"
+	args := []string{
+		"--no-sandbox",
+		"--headless",
+		// see https://github.com/GoogleChrome/puppeteer/issues/2410.
+		"--font-render-hinting=medium",
+		"--remote-debugging-port=9222",
+		"--disable-gpu",
+		"--disable-translate",
+		"--disable-extensions",
+		"--disable-background-networking",
+		"--safebrowsing-disable-auto-update",
+		"--disable-sync",
+		"--disable-default-apps",
+		"--hide-scrollbars",
+		"--metrics-recording-only",
+		"--mute-audio",
+		"--no-first-run",
+	}
+	cmd, err := xexec.Command(logger, binary, args...)
+	if err != nil {
+		return nil, xerror.New(op, err)
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	return cmd, nil
+}
+
+func kill(logger xlog.Logger, proc *os.Process) error {
+	const op string = "chrome.kill"
+	logger.DebugOp(op, "killing Google Chrome headless process using port 9222...")
+	resolver := func() error {
+		err := syscall.Kill(-proc.Pid, syscall.SIGKILL)
+		if err == nil {
+			return nil
+		}
+		if strings.Contains(err.Error(), "no such process") {
+			return nil
+		}
+		return err
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func restart(logger xlog.Logger, proc *os.Process) error {
 	const op string = "chrome.restart"
-	resolver := func() (*os.Process, error) {
+	logger.DebugOp(op, "restarting Google Chrome headless process using port 9222...")
+	resolver := func() error {
+		// kill the existing process first.
+		if err := kill(logger, proc); err != nil {
+			return err
+		}
+		cmd, err := cmd(logger)
+		if err != nil {
+			return err
+		}
 		// we try to restart the process.
 		xexec.LogBeforeExecute(logger, cmd)
 		if err := cmd.Start(); err != nil {
-			return cmd.Process, err
+			return err
 		}
-		// we wait the process to be ready.
-		warmup(logger)
 		// if the process failed to restart correctly,
 		// we have to restart it again.
 		if !isViable(logger) {
-			return restart(ctx, logger, cmd)
+			return restart(logger, cmd.Process)
 		}
-		return cmd.Process, nil
+		return nil
 	}
-	proc, err := resolver()
-	if err != nil {
-		return proc, xerror.New(op, err)
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
 	}
-	return proc, err
+	return nil
 }
 
 func isViable(logger xlog.Logger) bool {
-	const op string = "chrome.isViable"
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	endpoint := "http://localhost:9222"
-	logger.DebugfOp(
-		op,
-		"checking Google Chrome process viability via endpoint '%s/json/version'",
-		endpoint,
+	const (
+		op                string = "chrome.isViable"
+		maxViabilityTests int    = 5
 	)
-	v, err := devtool.New(endpoint).Version(ctx)
-	if err != nil {
-		logger.ErrorfOp(
+	viable := func() bool {
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		endpoint := "http://localhost:9222"
+		logger.DebugfOp(
 			op,
-			"Google Chrome is not viable as endpoint returned '%v'",
-			err,
+			"checking Google Chrome process viability via endpoint '%s/json/version'",
+			endpoint,
 		)
-		return false
+		v, err := devtool.New(endpoint).Version(ctx)
+		if err != nil {
+			logger.ErrorfOp(
+				op,
+				"Google Chrome is not viable as endpoint returned '%v'",
+				err,
+			)
+			return false
+		}
+		logger.DebugfOp(
+			op,
+			"Google Chrome is viable as endpoint returned '%v'",
+			v,
+		)
+		return true
 	}
-	logger.DebugfOp(
-		op,
-		"Google Chrome is viable as endpoint returned '%v'",
-		v,
-	)
-	return true
+	result := false
+	for i := 0; i < maxViabilityTests && !result; i++ {
+		warmup(logger)
+		result = viable()
+	}
+	return result
 }
 
 func warmup(logger xlog.Logger) {
 	const op string = "chrome.warmup"
-	warmupTime := xtime.Duration(10)
+	warmupTime := xtime.Duration(0.5)
 	logger.DebugfOp(
 		op,
 		"waiting '%v' for allowing Google Chrome to warmup",