fix: LibreOffice newer versions stability (#697)

pkg/modules/api/api.go

@@ -12,13 +12,13 @@ import (
 	"time"
 
 	"github.com/alexliesenfeld/health"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/gc"
 	"github.com/labstack/echo/v4"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
 	"golang.org/x/net/http2"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 func init() {
@@ -39,7 +39,7 @@ type API struct {
 	routes              []Route
 	externalMiddlewares []Middleware
 	healthChecks        []health.CheckerOption
-	gcGraceDuration     time.Duration
+	fs                  *gotenberg.FileSystem
 	logger              *zap.Logger
 	srv                 *echo.Echo
 }
@@ -149,12 +149,6 @@ type HealthChecker interface {
 	Checks() ([]health.CheckerOption, error)
 }
 
-// GarbageCollectorGraceDurationIncrementer is a module interface for
-// increasing the grace duration provided by the API for the garbage collector.
-type GarbageCollectorGraceDurationIncrementer interface {
-	AddGraceDuration() time.Duration
-}
-
 // Descriptor returns an API's module descriptor.
 func (API) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
@@ -283,18 +277,7 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 		a.healthChecks = append(a.healthChecks, checks...)
 	}
 
-	// Grace duration.
-	a.gcGraceDuration = a.timeout
-
-	mods, err = ctx.Modules(new(GarbageCollectorGraceDurationIncrementer))
-	if err != nil {
-		return fmt.Errorf("get garbage collector grace duration increments: %w", err)
-	}
-
-	for _, incrementer := range mods {
-		a.gcGraceDuration += incrementer.(GarbageCollectorGraceDurationIncrementer).AddGraceDuration()
-	}
-
+	// Logger.
 	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
 	if err != nil {
 		return fmt.Errorf("get logger provider: %w", err)
@@ -307,6 +290,9 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 
 	a.logger = logger
 
+	// File system.
+	a.fs = gotenberg.NewFileSystem()
+
 	return nil
 }
 
@@ -437,7 +423,7 @@ func (a *API) Start() error {
 		var middlewares []echo.MiddlewareFunc
 
 		if route.IsMultipart {
-			middlewares = append(middlewares, contextMiddleware(a.timeout))
+			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout))
 
 			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
 				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
@@ -488,17 +474,10 @@ func (a API) Stop(ctx context.Context) error {
 	return a.srv.Shutdown(ctx)
 }
 
-// GraceDuration updates the expiration time of files and directories parsed by
-// the gc.GarbageCollector.
-func (a API) GraceDuration() time.Duration {
-	return a.gcGraceDuration
-}
-
 // Interface guards.
 var (
-	_ gotenberg.Module                         = (*API)(nil)
-	_ gotenberg.Provisioner                    = (*API)(nil)
-	_ gotenberg.Validator                      = (*API)(nil)
-	_ gotenberg.App                            = (*API)(nil)
-	_ gc.GarbageCollectorGraceDurationModifier = (*API)(nil)
+	_ gotenberg.Module      = (*API)(nil)
+	_ gotenberg.Provisioner = (*API)(nil)
+	_ gotenberg.Validator   = (*API)(nil)
+	_ gotenberg.App         = (*API)(nil)
 )

pkg/modules/api/api_test.go

@@ -10,12 +10,12 @@ import (
 	"os"
 	"reflect"
 	"testing"
-	"time"
 
 	"github.com/alexliesenfeld/health"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 type ProtoModule struct {
@@ -62,15 +62,6 @@ func (mod ProtoHealthChecker) Checks() ([]health.CheckerOption, error) {
 	return mod.checks()
 }
 
-type ProtoGarbageCollectorGraceDurationIncrementer struct {
-	ProtoValidator
-	addGraceDuration func() time.Duration
-}
-
-func (mod ProtoGarbageCollectorGraceDurationIncrementer) AddGraceDuration() time.Duration {
-	return mod.addGraceDuration()
-}
-
 type ProtoLoggerProvider struct {
 	ProtoModule
 	logger func(mod gotenberg.Module) (*zap.Logger, error)
@@ -93,18 +84,16 @@ func TestAPI_Descriptor(t *testing.T) {
 
 func TestAPI_Provision(t *testing.T) {
 	for i, tc := range []struct {
-		ctx                 *gotenberg.Context
-		setEnv              func(i int)
-		expectPort          int
-		expectMiddlewares   []Middleware
-		expectGraceDuration time.Duration
-		expectErr           bool
+		ctx               *gotenberg.Context
+		setEnv            func(i int)
+		expectPort        int
+		expectMiddlewares []Middleware
+		expectErr         bool
 	}{
 		{
 			ctx: func() *gotenberg.Context {
 				fs := new(API).Descriptor().FlagSet
 				err := fs.Parse([]string{"--api-port-from-env=FOO"})
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -122,7 +111,6 @@ func TestAPI_Provision(t *testing.T) {
 			ctx: func() *gotenberg.Context {
 				fs := new(API).Descriptor().FlagSet
 				err := fs.Parse([]string{"--api-port-from-env=PORT"})
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -146,7 +134,6 @@ func TestAPI_Provision(t *testing.T) {
 			ctx: func() *gotenberg.Context {
 				fs := new(API).Descriptor().FlagSet
 				err := fs.Parse([]string{"--api-port-from-env=PORT"})
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -170,7 +157,6 @@ func TestAPI_Provision(t *testing.T) {
 			ctx: func() *gotenberg.Context {
 				fs := new(API).Descriptor().FlagSet
 				err := fs.Parse([]string{"--api-port-from-env=PORT"})
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -335,60 +321,6 @@ func TestAPI_Provision(t *testing.T) {
 			}(),
 			expectErr: true,
 		},
-
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoGarbageCollectorGraceDurationIncrementer
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.validate = func() error {
-					return errors.New("foo")
-				}
-				mod.addGraceDuration = func() time.Duration {
-					return 0
-				}
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: new(API).Descriptor().FlagSet,
-					},
-					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
-					},
-				)
-			}(),
-			expectErr: true,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoGarbageCollectorGraceDurationIncrementer
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.validate = func() error {
-					return nil
-				}
-				mod.addGraceDuration = func() time.Duration {
-					return time.Duration(3) * time.Second
-				}
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: new(API).Descriptor().FlagSet,
-					},
-					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
-					},
-				)
-			}(),
-			expectGraceDuration: time.Duration(33) * time.Second,
-			expectErr:           true,
-		},
 		{
 			ctx: func() *gotenberg.Context {
 				return gotenberg.NewContext(
@@ -526,10 +458,6 @@ func TestAPI_Provision(t *testing.T) {
 			t.Errorf("test %d: expected %+v, but got: %+v", i, tc.expectMiddlewares, mod.externalMiddlewares)
 		}
 
-		if tc.expectGraceDuration != 0 && mod.gcGraceDuration != tc.expectGraceDuration {
-			t.Errorf("test %d: expected gc grace duration '%s' but got '%s'", i, tc.expectGraceDuration, mod.gcGraceDuration)
-		}
-
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
 		}
@@ -759,6 +687,7 @@ func TestAPI_Start(t *testing.T) {
 			}(),
 		},
 	}
+	mod.fs = gotenberg.NewFileSystem()
 	mod.logger = zap.NewNop()
 
 	err := mod.Start()
@@ -866,36 +795,20 @@ func TestAPI_Stop(t *testing.T) {
 	}
 }
 
-func TestAPI_GraceDuration(t *testing.T) {
-	mod := API{
-		gcGraceDuration: time.Duration(3) * time.Second,
-	}
-
-	expect := time.Duration(3) * time.Second
-	actual := mod.GraceDuration()
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
-	}
-}
-
 // Interface guards.
 var (
-	_ gotenberg.Module                         = (*ProtoModule)(nil)
-	_ gotenberg.Validator                      = (*ProtoValidator)(nil)
-	_ gotenberg.Module                         = (*ProtoValidator)(nil)
-	_ Router                                   = (*ProtoRouter)(nil)
-	_ gotenberg.Module                         = (*ProtoRouter)(nil)
-	_ gotenberg.Validator                      = (*ProtoRouter)(nil)
-	_ MiddlewareProvider                       = (*ProtoMiddlewareProvider)(nil)
-	_ gotenberg.Module                         = (*ProtoMiddlewareProvider)(nil)
-	_ gotenberg.Validator                      = (*ProtoMiddlewareProvider)(nil)
-	_ HealthChecker                            = (*ProtoHealthChecker)(nil)
-	_ gotenberg.Module                         = (*ProtoHealthChecker)(nil)
-	_ gotenberg.Validator                      = (*ProtoHealthChecker)(nil)
-	_ GarbageCollectorGraceDurationIncrementer = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
-	_ gotenberg.Module                         = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
-	_ gotenberg.Validator                      = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
-	_ gotenberg.LoggerProvider                 = (*ProtoLoggerProvider)(nil)
-	_ gotenberg.Module                         = (*ProtoLoggerProvider)(nil)
+	_ gotenberg.Module         = (*ProtoModule)(nil)
+	_ gotenberg.Validator      = (*ProtoValidator)(nil)
+	_ gotenberg.Module         = (*ProtoValidator)(nil)
+	_ Router                   = (*ProtoRouter)(nil)
+	_ gotenberg.Module         = (*ProtoRouter)(nil)
+	_ gotenberg.Validator      = (*ProtoRouter)(nil)
+	_ MiddlewareProvider       = (*ProtoMiddlewareProvider)(nil)
+	_ gotenberg.Module         = (*ProtoMiddlewareProvider)(nil)
+	_ gotenberg.Validator      = (*ProtoMiddlewareProvider)(nil)
+	_ HealthChecker            = (*ProtoHealthChecker)(nil)
+	_ gotenberg.Module         = (*ProtoHealthChecker)(nil)
+	_ gotenberg.Validator      = (*ProtoHealthChecker)(nil)
+	_ gotenberg.LoggerProvider = (*ProtoLoggerProvider)(nil)
+	_ gotenberg.Module         = (*ProtoLoggerProvider)(nil)
 )

pkg/modules/api/context.go

@@ -15,13 +15,14 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/labstack/echo/v4"
 	"github.com/mholt/archiver/v3"
 	"go.uber.org/zap"
 	"golang.org/x/text/runes"
 	"golang.org/x/text/transform"
 	"golang.org/x/text/unicode/norm"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 var (
@@ -49,7 +50,7 @@ type Context struct {
 }
 
 // newContext returns a Context by parsing a "multipart/form-data" request.
-func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration) (*Context, context.CancelFunc, error) {
+func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)
 
 	ctx := &Context{
@@ -81,7 +82,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 				return
 			}
 
-			ctx.logger.Debug(fmt.Sprintf("'%s' removed", ctx.dirPath))
+			ctx.logger.Debug(fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
 			ctx.cancelled = true
 		}
 	}()
@@ -113,7 +114,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
 	}
 
-	dirPath, err := gotenberg.MkdirAll()
+	dirPath, err := fs.MkdirAll()
 	if err != nil {
 		return nil, cancel, fmt.Errorf("create working directory: %w", err)
 	}

pkg/modules/api/context_test.go

@@ -12,9 +12,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 func TestNewContext(t *testing.T) {
@@ -104,7 +105,7 @@ func TestNewContext(t *testing.T) {
 		},
 	} {
 		handler := func(c echo.Context) error {
-			_, cancel, err := newContext(c, zap.NewNop(), time.Duration(10)*time.Second)
+			_, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second)
 			defer cancel()
 			// Context already cancelled.
 			defer cancel()
@@ -277,28 +278,33 @@ func TestContext_BuildOutputFile(t *testing.T) {
 			},
 		},
 	} {
-		dirPath, err := gotenberg.MkdirAll()
-		if err != nil {
-			t.Fatalf("%d: expected no erro but got: %v", i, err)
-		}
+		func() {
+			fs := gotenberg.NewFileSystem()
+			dirPath, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("%d: expected no erro but got: %v", i, err)
+			}
 
-		tc.ctx.dirPath = dirPath
-		tc.ctx.logger = zap.NewNop()
+			defer func() {
+				err := os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("test %d: expected no error while cleaning up but got: %v", i, err)
+				}
+			}()
 
-		_, err = tc.ctx.BuildOutputFile()
+			tc.ctx.dirPath = dirPath
+			tc.ctx.logger = zap.NewNop()
 
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			_, err = tc.ctx.BuildOutputFile()
 
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectErr && err == nil {
+				t.Errorf("test %d: expected error but got: %v", i, err)
+			}
 
-		err = os.RemoveAll(dirPath)
-		if err != nil {
-			t.Fatalf("%d: expected no erro but got: %v", i, err)
-		}
+			if !tc.expectErr && err != nil {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+		}()
 	}
 }
 

pkg/modules/api/middlewares.go

@@ -11,6 +11,8 @@ import (
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 // ErrAsyncProcess happens when a handler or middleware handles a request in an
@@ -20,7 +22,8 @@ var ErrAsyncProcess = errors.New("async process")
 // ParseError parses an error and returns the corresponding HTTP status and
 // HTTP message.
 func ParseError(err error) (int, string) {
-	echoErr, ok := err.(*echo.HTTPError)
+	var echoErr *echo.HTTPError
+	ok := errors.As(err, &echoErr)
 	if ok {
 		return echoErr.Code, http.StatusText(echoErr.Code)
 	}
@@ -199,14 +202,14 @@ func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.
 //
 //	ctx := c.Get("context").(*api.Context)
 //	cancel := c.Get("cancel").(context.CancelFunc)
-func contextMiddleware(timeout time.Duration) echo.MiddlewareFunc {
+func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			logger := c.Get("logger").(*zap.Logger)
 
 			// We create a context with a timeout so that underlying processes are
 			// able to stop early and handle correctly a timeout scenario.
-			ctx, cancel, err := newContext(c, logger, timeout)
+			ctx, cancel, err := newContext(c, logger, fs, timeout)
 			if err != nil {
 				cancel()
 

pkg/modules/api/middlewares_test.go

@@ -13,6 +13,8 @@ import (
 
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
 func TestParseError(t *testing.T) {
@@ -122,7 +124,6 @@ func TestLatencyMiddleware(t *testing.T) {
 			return nil
 		},
 	)(c)
-
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}
@@ -150,7 +151,6 @@ func TestRootPathMiddleware(t *testing.T) {
 			return nil
 		},
 	)(c)
-
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}
@@ -191,7 +191,6 @@ func TestTraceMiddleware(t *testing.T) {
 				return nil
 			},
 		)(c)
-
 		if err != nil {
 			t.Fatalf("test %d: expected no error but got: %v", i, err)
 		}
@@ -271,7 +270,6 @@ func TestLoggerMiddleware(t *testing.T) {
 		}
 
 		err := loggerMiddleware(zap.NewNop(), disableLoggingForPaths)(tc.next)(c)
-
 		if err != nil {
 			t.Errorf("test %d: expected no error but got: %v", i, err)
 		}
@@ -389,7 +387,7 @@ func TestContextMiddleware(t *testing.T) {
 		c.Set("trace", "foo")
 		c.Set("startTime", time.Now())
 
-		err := contextMiddleware(time.Duration(10) * time.Second)(tc.next)(c)
+		err := contextMiddleware(gotenberg.NewFileSystem(), time.Duration(10)*time.Second)(tc.next)(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)