handling context timeout/cancelled in printer package

internal/pkg/printer/chrome.go

@@ -44,19 +44,19 @@ func (p *chrome) Print(destination string) error {
 	defer cancel()
 	devt, err := devtool.New("http://localhost:9222").Version(ctx)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	// connect to WebSocket URL (page) that speaks the Chrome DevTools Protocol.
 	devtConn, err := rpcc.DialContext(ctx, devt.WebSocketDebuggerURL)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	defer devtConn.Close() // nolint: errcheck
 	// create a new CDP Client that uses conn.
 	devtClient := cdp.NewClient(devtConn)
 	newContextTarget, err := devtClient.Target.CreateBrowserContext(ctx)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	// create a new blank target with the new browser context.
 	createTargetArgs := target.
@@ -64,13 +64,13 @@ func (p *chrome) Print(destination string) error {
 		SetBrowserContextID(newContextTarget.BrowserContextID)
 	newTarget, err := devtClient.Target.CreateTarget(ctx, createTargetArgs)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	// connect the client to the new target.
 	newTargetWsURL := fmt.Sprintf("ws://127.0.0.1:9222/devtools/page/%s", newTarget.TargetID)
 	newContextConn, err := rpcc.DialContext(ctx, newTargetWsURL)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	defer newContextConn.Close() // nolint: errcheck
 	// create a new CDP Client that uses newContextConn.
@@ -85,10 +85,10 @@ func (p *chrome) Print(destination string) error {
 		func() error { return targetClient.Page.Enable(ctx) },
 		func() error { return targetClient.Runtime.Enable(ctx) },
 	); err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	if err := p.navigate(ctx, targetClient); err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	print, err := targetClient.Page.PrintToPDF(
 		ctx,
@@ -106,7 +106,7 @@ func (p *chrome) Print(destination string) error {
 			SetPrintBackground(true),
 	)
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	if err := ioutil.WriteFile(destination, print.Data, 0644); err != nil {
 		return &standarderror.Error{Op: op, Err: err}

internal/pkg/printer/merge.go

@@ -41,7 +41,7 @@ func (p *merge) Print(destination string) error {
 	cmd := exec.CommandContext(p.ctx, "pdftk", cmdArgs...)
 	_, err := cmd.Output()
 	if err != nil {
-		return &standarderror.Error{Op: op, Err: err}
+		return handleErrContext(p.ctx, &standarderror.Error{Op: op, Err: err})
 	}
 	return nil
 }

internal/pkg/printer/office.go

@@ -43,7 +43,7 @@ func (p *office) Print(destination string) error {
 		baseFilename := random.String(32)
 		tmpDest := fmt.Sprintf("%s/%d%s.pdf", dirPath, i, baseFilename)
 		if err := unoconv(ctx, fpath, tmpDest, p.opts); err != nil {
-			return &standarderror.Error{Op: op, Err: err}
+			return handleErrContext(ctx, &standarderror.Error{Op: op, Err: err})
 		}
 		fpaths[i] = tmpDest
 	}

internal/pkg/printer/printer.go

@@ -1,7 +1,39 @@
 package printer
 
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/standarderror"
+)
+
 // Printer is a type that can create a PDF file from a source.
 // The source is defined in the underlying implementation.
 type Printer interface {
 	Print(destination string) error
 }
+
+func handleErrContext(ctx context.Context, previousErr error) error {
+	const op = "printer.handleErrContext"
+	if previousErr == nil {
+		panic(fmt.Sprintf("%s: previous error should not be nil", op))
+	}
+	err := ctx.Err()
+	if err == nil {
+		return previousErr
+	}
+	if strings.Contains(err.Error(), context.DeadlineExceeded.Error()) {
+		return &standarderror.Error{
+			Code:    standarderror.Timeout,
+			Message: "context has timed out",
+			Op:      op,
+			Err:     previousErr,
+		}
+	}
+	return &standarderror.Error{
+		Message: "context finished with an error",
+		Op:      op,
+		Err:     previousErr,
+	}
+}

internal/pkg/printer/printer_test.go

@@ -0,0 +1,35 @@
+package printer
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/standarderror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/timeout"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestHandlerErr(t *testing.T) {
+	previousErr := errors.New("previous error")
+	// should be OK.
+	ctx, cancel := timeout.Context(5)
+	defer cancel()
+	assert.NotNil(t, handleErrContext(ctx, previousErr))
+	// should timeout.
+	ctx, cancel = timeout.Context(0.5)
+	defer cancel()
+	time.Sleep(timeout.Duration(1))
+	err := handleErrContext(ctx, previousErr)
+	assert.NotNil(t, err)
+	standardized := test.RequireStandardError(t, err)
+	assert.Equal(t, standarderror.Timeout, standardized.Code)
+	// should failed.
+	ctx, cancel = timeout.Context(5)
+	cancel()
+	err = handleErrContext(ctx, previousErr)
+	assert.NotNil(t, err)
+	standardized = test.RequireStandardError(t, err)
+	assert.Equal(t, standarderror.Internal, standarderror.Code(err))
+}