rolling back from previous implementation, now using master version of unoconv

internal/pkg/chrome/chrome.go

@@ -0,0 +1,143 @@
+package chrome
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"time"
+
+	"github.com/mafredri/cdp/devtool"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xexec"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xtime"
+)
+
+func Start(ctx context.Context, logger xlog.Logger) (*os.Process, 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...)
+		if err != nil {
+			return nil, err
+		}
+		// we try to start the process.
+		xexec.LogBeforeExecute(logger, cmd)
+		if err := cmd.Start(); err != nil {
+			return cmd.Process, 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 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()
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func restart(ctx context.Context, logger xlog.Logger, cmd *exec.Cmd) (*os.Process, error) {
+	const op string = "chrome.restart"
+	resolver := func() (*os.Process, error) {
+		// we try to restart the process.
+		xexec.LogBeforeExecute(logger, cmd)
+		if err := cmd.Start(); err != nil {
+			return cmd.Process, 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 cmd.Process, nil
+	}
+	proc, err := resolver()
+	if err != nil {
+		return proc, xerror.New(op, err)
+	}
+	return proc, err
+}
+
+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,
+	)
+	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
+}
+
+func warmup(logger xlog.Logger) {
+	const op string = "chrome.warmup"
+	warmupTime := xtime.Duration(10)
+	logger.DebugfOp(
+		op,
+		"waiting '%v' for allowing Google Chrome to warmup",
+		warmupTime,
+	)
+	time.Sleep(warmupTime)
+}

internal/pkg/chrome/doc.go

@@ -0,0 +1 @@
+package chrome