fix: typo Docker Registry -> Docker Repository

Add tags on openapi.yaml endpoints

.blueprints/Dockerfile.blueprint

@@ -1,64 +0,0 @@
-FROM {{ if eq "CI" .Orbit.Image }}golang:1.10-stretch{{ else }}debian:stretch-slim{{ end }}
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-{{- if eq "CI" .Orbit.Image }}
-
-WORKDIR /go/src/github.com/thecodingmachine/gotenberg
-
-# Installs lint dependencies.
-RUN go get -u gopkg.in/alecthomas/gometalinter.v2 &&\
-    gometalinter.v2 --install
-
-# Copies our Go source.
-COPY . .
-
-# Installs project dependencies.
-RUN go get -d -v ./...
-
-ENTRYPOINT [".ci/docker-entrypoint.sh"]
-{{- else }}
-
-COPY .ci/gotenberg /usr/bin/gotenberg
-RUN ln -s /usr/bin/gotenberg /usr/local/bin/gotenberg
-
-COPY .ci/gotenberg.yml /gotenberg/gotenberg.yml
-
-WORKDIR /gotenberg
-
-EXPOSE 3000
-CMD ["gotenberg"]
-{{- end }}

.ci/docker-entrypoint.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-
-set -xe
-
-# Statically checking Go source for errors and warnings.
-gometalinter.v2 --disable-all -E vet -E gofmt -E misspell -E ineffassign -E goimports -E deadcode -E gocyclo --vendor ./...;
-
-# Running tests according to current Gotenberg version.
-if [[ "$VERSION" == "snapshot" ]]; then
-    for d in $(go list ./... | grep -v vendor); do
-        go test -race -cover -covermode=atomic $d;
-    done
-else
-    echo "" > .ci/coverage.txt;
-    for d in $(go list ./... | grep -v vendor); do
-        go test -race -coverprofile=profile.out -covermode=atomic $d;
-        if [ -f profile.out ]; then
-            cat profile.out >> .ci/coverage.txt;
-            rm profile.out;
-        fi
-    done
-fi
-
-
-# Builds the Linux binary.
-if [ -f .ci/gotenberg ]; then
-    rm .ci/gotenberg
-fi
-
-env GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION}" && mv gotenberg .ci/;
-
-# Bye!
-exit 0;

.ci/gotenberg.yml

@@ -1,60 +0,0 @@
-# The port the application will listen to.
-port: 3000
-
-logs:
-  # Accepted values, in order of severity: DEBUG, INFO, WARN, ERROR, FATAL, PANIC.
-  # Messages at and above the selected level will be logged.
-  level: "INFO"
-
-  # Accepted values: text, json.
-  # When a TTY is not attached, the output will be in the defined format.
-  formatter: "text"
-
-# You don't like a library which is used for a conversion? You want to handle a new file type?
-# You may provide here your own implementation!
-commands:
-
-  # Some libraries like unoconv cannot perform concurrent conversions. That's why the API does only one conversion at a time.
-  # If your current implementation uses libraries which are able to perform concurrent conversions, you may
-  # change this value to false.
-  lock: true
-
-  # Unlike others commands' templates, you have access to FilesPaths instead of FilePath: it gathers all PDF files which should be merged.
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  
-  # You may add more commands (or less, or even none).
-  conversions:
-
-      # The command template: you have access to FilePath and ResultFilePath variables.
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      # The binary which will call the command.
-      interpreter: "/bin/sh -c"
-      # Duration in seconds after which the command will be killed if it has not finished.
-      timeout: 30
-      # Files with the following extensions will be converted by the current command.
-      extensions:
-        - ".md"
-
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

.dockerignore

@@ -0,0 +1 @@
+.git

.github/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at neuhart.julien@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -1,33 +0,0 @@
-# Contributing
-
-Hi! Thank your for considering contributing to Gotenberg. You'll
-find below useful information about how to contribute to the Gotenberg project.
-
-## Contributing code
-
-### Install from sources
-
-1. Fork this repository
-2. Clone it to your local Go environment (requires *Go* >= 1.10)
-3. Install the latest [Orbit](https://github.com/gulien/orbit) release
-
-### Working with git
-
-1. Create your feature branch (`git checkout -b my-new-feature`)
-2. Commit your changes (`git commit -am 'Add some feature'`)
-3. Push to the branch (`git push origin my-new-feature`)
-4. Create a new pull request
-
-## Reporting bugs and feature request
-
-Your issue or feature request may already be reported!
-Please search on the [issue tracker](../../../issues) before creating one.
-
-If you do not find any relevant issue or feature request, feel free to
-add a new one!
-
-## Additional resources
-
-* [Code of conduct](CODE_OF_CONDUCT.md)
-* [Issue template](ISSUE_TEMPLATE.md)
-* [Pull request template](PULL_REQUEST_TEMPLATE.md)

.github/ISSUE_TEMPLATE.md

@@ -1,32 +0,0 @@
-Your issue may already be reported!
-Please search on the [issue tracker](../../../issues) before creating one.
-
-## Expected Behavior
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
-
-## Current Behavior
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-## Possible Solution
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
-<!--- or ideas how to implement the addition or change -->
-
-## Steps to Reproduce (for bugs)
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-1.
-2.
-3.
-4.
-
-## Context
-<!--- How has this issue affected you? What are you trying to accomplish? -->
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
-
-## Your Environment
-<!--- Include as many relevant details about the environment you experienced the bug in -->
-* Version used:
-* Operating System and version:
-* Link to your project:

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,44 +0,0 @@
-A similar PR may already be submitted!
-Please search among the [pull requests](../../../pulls) before creating one.
-
-Thanks for submitting a pull request! Please provide enough information so that others can review your pull request:
-
-For more information, see the [CONTRIBUTING](CONTRIBUTING.md) guide.
-
-**Summary**
-
-<!-- Summary of the PR -->
-
-This PR fixes/implements the following **bugs/features**
-
-* [ ] Bug 1
-* [ ] Bug 2
-* [ ] Feature 1
-* [ ] Feature 2
-* [ ] Breaking changes
-
-<!-- You can skip this if you're fixing a typo or adding an app to the Showcase. -->
-
-Explain the **motivation** for making this change. What existing problem does the pull request solve?
-
-<!-- Example: When "Adding a function to do X", explain why it is necessary to have a way to do X. -->
-
-**Test plan (required)**
-
-Demonstrate the code is solid. Example: The exact commands you ran and their output.
-
-<!-- Make sure tests pass on both Travis and AppVeyor. -->
-
-**Closing issues**
-
-<!-- Put `closes #XXXX` in your comment to auto-close the issue that your PR fixes (if such). -->
-Fixes #
-
-**Checklist**
-
-- [ ] Have you followed the guidelines in our [CONTRIBUTING](CONTRIBUTING.md) guide?
-- [ ] Have you lint your code locally prior to submission (`orbit run fmt`)?
-- [ ] Have you written new tests for your core changes, as applicable?
-- [ ] Have you successfully ran tests with your changes locally (`orbit run ci`)?
-- [ ] I have squashed any insignificant commits
-- [ ] This change has comments for package types, values, functions, and non-obvious lines of code

.github/stale.yml

@@ -0,0 +1,18 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - bug
+  - documentation
+  - enhancement
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.github/workflows/continuous_delivery.yml

@@ -0,0 +1,27 @@
+name: Continuous Delivery
+
+on:
+  release:
+    types: [ published ]
+
+jobs:
+
+  release:
+    name: Release Docker image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Checkout source code
+        uses: actions/checkout@v2
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push Docker image
+        run: |
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }}
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REPOSITORY=thecodingmachine

.github/workflows/continuous_integration.yml

@@ -0,0 +1,43 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v2
+      - name: Run linters
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: v1.42
+
+  tests:
+    needs:
+      - Lint
+    name: Tests
+    # TODO: once arm64 actions are available, also run the tests on this architecture.
+    # See: https://github.com/actions/virtual-environments/issues/2552#issuecomment-771478000.
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Checkout source code
+        uses: actions/checkout@v2
+      - name: Build testing environment
+        run: make build build-tests
+      - name: Run tests
+        run: |
+          make tests-once
+          bash <(curl -s https://codecov.io/bash)

.gitignore

@@ -1,2 +1,2 @@
-.ci/coverage.txt
-.ci/gotenberg
+/coverage.html
+/coverage.txt

.golangci.yml

@@ -0,0 +1,30 @@
+linters:
+  disable-all: true
+  enable:
+    - bodyclose
+    - deadcode
+    - errcheck
+    - gofmt
+    - goimports
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - misspell
+    - prealloc
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unconvert
+    - unused
+    - varcheck
+
+run:
+  deadline: 5m
+  issues-exit-code: 1
+  tests: false
+
+output:
+  format: 'colored-line-number'
+  print-issued-lines: true
+  print-linter-name: true

.goreleaser.yml

@@ -1,28 +0,0 @@
----
-project_name: Gotenberg
-builds:
-  - main: ./main.go
-    binary: gotenberg
-    env:
-     - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-      - windows
-    goarch:
-      - 386
-      - amd64
-      - arm
-      - arm64
-archive:
-  name_template: '{{ .Binary }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
-  replacements:
-    darwin: Darwin
-    linux: Linux
-    windows: Windows
-    386: i386
-    amd64: x86_64
-  format: tar.gz
-  format_overrides:
-    - goos: windows
-      format: zip

.travis.yml

@@ -1,23 +0,0 @@
-sudo: required
-
-language: generic
-
-services:
-  - docker
-
-env:
-  global:
-  - secure: d6pliM7iR7KJ3TQkr1C0tHi0HgU6Vdmc/ycw11XrXs794/dgj6g9UDrhgcvT2mTzOVIUNouHx7gyEWAlwJv7p8PPyguHJfIsyqMWfaXNPoytTx1ETUiygl1G/UsvXVdry6I5tZF/U+/PJ3hBXoAvo8EOFe0/MxxvP3ghCeeCpeEwEdoYP2jbADGffywVUNI7OEdmS29A28GusXXp2cWCIZYSq5Gn5iu1ZMPaJA6SkRTXpS+iVVLUvlbz5HW09ETFfurTvsdz5Ze4JICiuQt///CR1uwdxD8K7Ils/mkenaMtja9NHA9RdQBa51Azn8iCLsObCTYc52Zb6atbCi/X4ae9M8GA8qaaLigNz5G4v1BHneJylYfWKj5GwqUA3VmRu1mlEw7d2sN2uFRmgIl5kgsYYyOVOLBOKaJWhyBhNnR4U8KeqwUkOnlSdmNZnjfexXXBEcKHen1SozpXwMnzZh8LZuN6BNYd6TVpKmjulGI3vqNMM0c4JJZ9pSm4q5FjbNGQArwCsujDDwY4bCGZSJJTPMXjYOrx4yJ1RY+0TpyV9oDU3ogEqaWnhrkgrphfiYBlDY2bEvrxMTMukLCxJb0Nru6LGCpg4X1P9hu9r0gceqUSnBgdJI4rYTNddenxlEd4j/Thqv835stJWz6YoV+rfvERuSUpntl8xvrk3U8=
-  - secure: CmLh169xwt3OC7l19lDUwdZYfw+l/+XXKjTGxnuJiXHa9hAH+nc4mEUSmqHMHwjquyYE6LnSVGZ94LH8sCaGed/TMm0Lj3DZtZ0VsjYu3sKsNrVJn5WdYEah+GvNJ8i8uzvHnGk1L2fAagLpXFUB2K9UraA1CFiHs1fF5Fua7Ra0mE7lMz0MFvyvzcmc9u8nMz71K2YVsXqn+I/rv8onJCTtc/Ds0hVrBXwG5Fh0T3xHqjOhME9ZI2hRHnnQVdBojSY3USifQ//qAKowfBVc0pebEtgFpyXx/I17A6xCm0KVtnA2tNqu1+XFkjWaBzryaLE9ujhJcTRC/YK0JUZ+QxfYbD5C7jVy9Jlx1lOEjJ42B/ImNxPP+9p3wi2MWNbcbZJPxIe635fnT17lI7CLK2Qg1xjfTQ4WTEKW5IhnYMiyfRKiripFh4PCkDm8cJlTbpntsX1n0uheydbsgf/11vS7o1WGhVQ8+Jelc4DvIbBHCqienQEOLJDBwm7FiK5JbwZJ6ZAGeDM/IhGU1h9PNjVbHUyJhUxYoPYUE9QsZFT7ENCrRQpq49KOzXBRfffyJNJRh+Ep9X5YoW0dUp0MNu5B7z2+6w9X9n/C+loa11xF42bFzniCvvbSOQ37J+EngDinVxJkNPeyivR4fye2ENhIAjAEjouTJLOSXL9nAOU=
-
-before_install:
-  - wget -qO- https://github.com/gulien/orbit/releases/download/v3.0.0/orbit_Linux_x86_64.tar.gz | tar xvz -C .
-  - sudo mv ./orbit /usr/local/bin && chmod +x /usr/local/bin/orbit
-
-script:
-  - orbit run ci -p "Version,${TRAVIS_BRANCH}"
-  - orbit run build -p "Version,${TRAVIS_BRANCH}"
-  # Uploads coverage.
-  - bash <(curl -s https://codecov.io/bash)
-  # Let's push to Docker hub only if not in a pull request and the branch name matches the semver format.
-  - if [[ "$TRAVIS_PULL_REQUEST" = false && "$TRAVIS_BRANCH" =~ ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$ ]]; then docker login -u $DOCKER_USER -p $DOCKER_PASS && docker push thecodingmachine/gotenberg:${TRAVIS_BRANCH}; fi

Dockerfile

@@ -1,46 +0,0 @@
-FROM debian:stretch-slim
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-COPY .ci/gotenberg /usr/bin/gotenberg
-RUN ln -s /usr/bin/gotenberg /usr/local/bin/gotenberg
-
-COPY .ci/gotenberg.yml /gotenberg/gotenberg.yml
-
-WORKDIR /gotenberg
-
-EXPOSE 3000
-CMD ["gotenberg"]

Dockerfile.ci

@@ -1,50 +0,0 @@
-FROM golang:1.10-stretch
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-WORKDIR /go/src/github.com/thecodingmachine/gotenberg
-
-# Installs lint dependencies.
-RUN go get -u gopkg.in/alecthomas/gometalinter.v2 &&\
-    gometalinter.v2 --install
-
-# Copies our Go source.
-COPY . .
-
-# Installs project dependencies.
-RUN go get -d -v ./...
-
-ENTRYPOINT [".ci/docker-entrypoint.sh"]

Gopkg.lock

@@ -1,66 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  name = "github.com/dustin/go-humanize"
-  packages = ["."]
-  revision = "02af3965c54e8cacf948b97fef38925c4120652c"
-
-[[projects]]
-  name = "github.com/gorilla/context"
-  packages = ["."]
-  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
-  version = "v1.1"
-
-[[projects]]
-  name = "github.com/gorilla/mux"
-  packages = ["."]
-  revision = "53c1911da2b537f792e7cafcb446b05ffe33b996"
-  version = "v1.6.1"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/justinas/alice"
-  packages = ["."]
-  revision = "03f45bd4b7dad4734bc4620e46a35789349abb20"
-
-[[projects]]
-  name = "github.com/satori/go.uuid"
-  packages = ["."]
-  revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
-  version = "v1.2.0"
-
-[[projects]]
-  name = "github.com/sirupsen/logrus"
-  packages = ["."]
-  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
-  version = "v1.0.5"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-  packages = ["ssh/terminal"]
-  revision = "88942b9c40a4c9d203b82b3731787b672d6e809b"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = [
-    "unix",
-    "windows"
-  ]
-  revision = "13d03a9a82fba647c21a0ef8fba44a795d0f0835"
-
-[[projects]]
-  name = "gopkg.in/yaml.v2"
-  packages = ["."]
-  revision = "86f5ed62f8a0ee96bd888d2efdfd6d4fb100a4eb"
-  version = "v2.2.0"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "97e0dbb20631792bc25ad19e6a85a90a9d24bb03f773cd36dee11eebae152091"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,54 +0,0 @@
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#   name = "github.com/x/y"
-#   version = "2.4.0"
-#
-# [prune]
-#   non-go = false
-#   go-tests = true
-#   unused-packages = true
-
-
-[prune]
-  go-tests = true
-  unused-packages = true
-
-[[constraint]]
-  name = "github.com/satori/go.uuid"
-  version = "1.2.0"
-
-[[constraint]]
-  name = "github.com/gorilla/mux"
-  version = "1.6.1"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/justinas/alice"
-
-[[constraint]]
-  name = "gopkg.in/yaml.v2"
-  version = "2.2.0"
-
-[[constraint]]
-  name = "github.com/sirupsen/logrus"
-  version = "1.0.5"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/dustin/go-humanize"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 TheCodingMachine
+Copyright (c) 2021 Julien Neuhart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,133 @@
+.PHONY: help
+help: ## Show the help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: it
+it: build build-tests ## Initialize the development environment
+
+GOLANG_VERSION=1.17
+DOCKER_REPOSITORY=gotenberg
+GOTENBERG_VERSION=snapshot
+GOTENBERG_USER_GID=1001
+GOTENBERG_USER_UID=1001
+PDFTK_VERSION=1353200058 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
+GOLANGCI_LINT_VERSION=v1.42.0 # See https://github.com/golangci/golangci-lint/releases.
+
+.PHONY: build
+build: ## Build the Gotenberg's Docker image
+	docker build \
+	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
+	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
+	--build-arg GOTENBERG_USER_GID=$(GOTENBERG_USER_GID) \
+	--build-arg GOTENBERG_USER_UID=$(GOTENBERG_USER_UID) \
+	--build-arg PDFTK_VERSION=$(PDFTK_VERSION) \
+	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	-f build/Dockerfile .
+
+GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
+API_PORT=3000
+API_PORT_FROM_ENV=
+API_READ_TIMEOUT=30s
+API_PROCESS_TIMEOUT=30s
+API_WRITE_TIMEOUT=30s
+API_ROOT_PATH=/
+API_TRACE_HEADER=Gotenberg-Trace
+API_DISABLE_HEALTH_CHECK_LOGGING=false
+API_WEBHOOK_ALLOW_LIST=
+API_WEBHOOK_DENY_LIST=
+API_WEBHOOK_ERROR_ALLOW_LIST=
+API_WEBHOOK_ERROR_DENY_LIST=
+API_WEBHOOK_MAX_RETRY=4
+API_WEBHOOK_RETRY_MIN_WAIT=1s
+API_WEBHOOK_RETRY_MAX_WAIT=30s
+API_DISABLE_WEBHOOK=false
+CHROMIUM_USER_AGENT=
+CHROMIUM_INCOGNITO=false
+CHROMIUM_IGNORE_CERTIFICATE_ERRORS=false
+CHROMIUM_ALLOW_LIST=
+CHROMIUM_DENY_LIST="^file:///[^tmp].*"
+CHROMIUM_DISABLE_ROUTES=false
+LIBREOFFICE_DISABLES_ROUTES=false
+LOG_LEVEL=info
+LOG_FORMAT=auto
+PDFENGINES_ENGINES=
+PDFENGINES_DISABLE_ROUTES=false
+
+.PHONY: run
+run: ## Start a Gotenberg container
+	docker run --rm -it \
+	-p $(API_PORT):$(API_PORT) \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	gotenberg \
+	--gotenberg-graceful-shutdown-duration=$(GOTENBERG_GRACEFUL_SHUTDOWN_DURATION) \
+	--api-port=$(API_PORT) \
+	--api-port-from-env=$(API_PORT_FROM_ENV) \
+	--api-read-timeout=$(API_READ_TIMEOUT) \
+	--api-process-timeout=$(API_PROCESS_TIMEOUT) \
+	--api-write-timeout=$(API_WRITE_TIMEOUT) \
+	--api-root-path=$(API_ROOT_PATH) \
+	--api-trace-header=$(API_TRACE_HEADER) \
+	--api-disable-health-check-logging=$(API_DISABLE_HEALTH_CHECK_LOGGING) \
+	--api-webhook-allow-list=$(API_WEBHOOK_ALLOW_LIST) \
+	--api-webhook-deny-list=$(API_WEBHOOK_DENY_LIST) \
+	--api-webhook-error-allow-list=$(API_WEBHOOK_ERROR_ALLOW_LIST) \
+	--api-webhook-error-deny-list=$(API_WEBHOOK_ERROR_DENY_LIST) \
+	--api-webhook-max-retry=$(API_WEBHOOK_MAX_RETRY) \
+	--api-webhook-retry-min-wait=$(API_WEBHOOK_RETRY_MIN_WAIT) \
+	--api-webhook-retry-max-wait=$(API_WEBHOOK_RETRY_MAX_WAIT) \
+	--api-disable-webhook=$(API_DISABLE_WEBHOOK) \
+	--chromium-user-agent=$(CHROMIUM_USER_AGENT) \
+	--chromium-incognito=$(CHROMIUM_INCOGNITO) \
+	--chromium-ignore-certificate-errors=$(CHROMIUM_IGNORE_CERTIFICATE_ERRORS) \
+	--chromium-allow-list=$(CHROMIUM_ALLOW_LIST) \
+	--chromium-deny-list=$(CHROMIUM_DENY_LIST) \
+	--chromium-disable-routes=$(CHROMIUM_DISABLE_ROUTES) \
+	--libreoffice-disable-routes=$(LIBREOFFICE_DISABLES_ROUTES) \
+	--log-level=$(LOG_LEVEL) \
+	--log-format=$(LOG_FORMAT) \
+	--pdfengines-engines=$(PDFENGINES_ENGINES) \
+	--pdfengines-disable-routes=$(PDFENGINES_DISABLE_ROUTES)
+
+.PHONY: build-tests
+build-tests: ## Build the tests' Docker image
+	docker build \
+	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
+	--build-arg DOCKER_REPOSITORY=$(DOCKER_REPOSITORY) \
+	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
+	--build-arg GOLANGCI_LINT_VERSION=$(GOLANGCI_LINT_VERSION) \
+	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	-f test/Dockerfile .
+
+.PHONY: tests
+tests: ## Start the testing environment
+	docker run --rm -it \
+	-v $(PWD):/tests \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	bash
+
+.PHONY: tests-once
+tests-once: ## Run the tests once (prefer the "tests" command while developing)
+	docker run --rm  \
+	-v $(PWD):/tests \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	gotest
+
+.PHONY: fmt
+fmt: ## Format the code and "optimize" the dependencies
+	go fmt ./...
+	go mod tidy
+
+.PHONY: godoc
+godoc: ## Run a webserver with Gotenberg godoc (go get golang.org/x/tools/cmd/godoc)
+	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v7)
+	godoc -http=:6060
+
+.PHONY: release
+release: ## Build the Gotenberg's Docker image for linux/amd64 and linux/arm64 platforms, then push it to a Docker repository
+	./scripts/release.sh \
+ 	$(GOLANG_VERSION) \
+	$(GOTENBERG_VERSION) \
+	$(GOTENBERG_USER_GID) \
+	$(GOTENBERG_USER_UID) \
+	$(PDFTK_VERSION) \
+	$(DOCKER_REPOSITORY)

README.md

@@ -1,202 +1,46 @@
 <p align="center">
-    <img src="https://user-images.githubusercontent.com/8983173/38133342-11df3bd8-340f-11e8-9fe4-50baecdceeca.png" alt="Gotenberg's logo" width="250" height="250" />
-</p>
+    <img src="https://user-images.githubusercontent.com/8983173/130322857-185831e2-f041-46eb-a17f-0a69d066c4e5.png" alt="Gotenberg Logo" width="150" height="150" />
 <h3 align="center">Gotenberg</h3>
-<p align="center">A stateless API for converting Markdown files, HTML files and Office documents to PDF</p>
-<p align="center">
-    <a href="https://microbadger.com/images/thecodingmachine/gotenberg:2.0.0">
-        <img src="https://images.microbadger.com/badges/image/thecodingmachine/gotenberg:2.0.0.svg" alt="MicroBadger layers">
-    </a>
-    <a href="https://travis-ci.org/thecodingmachine/gotenberg">
-        <img src="https://travis-ci.org/thecodingmachine/gotenberg.svg?branch=master" alt="Travis CI">
-    </a>
-    <a href="https://godoc.org/github.com/thecodingmachine/gotenberg">
-        <img src="https://godoc.org/github.com/thecodingmachine/gotenberg?status.svg" alt="GoDoc">
-    </a>
-    <a href="https://goreportcard.com/report/thecodingmachine/gotenberg">
-        <img src="https://goreportcard.com/badge/github.com/thecodingmachine/gotenberg" alt="Go Report Card">
-    </a>
-    <a href="https://codecov.io/gh/thecodingmachine/gotenberg/branch/master">
-        <img src="https://codecov.io/gh/thecodingmachine/gotenberg/branch/master/graph/badge.svg" alt="Codecov">
-    </a>
+<p align="center">A Docker-powered stateless API for PDF files</p>
+<p align="center"><a href="https://gotenberg.dev/docs/about">Documentation</a><!-- &#183; <a href="#">OpenAPI</a></p>-->
 </p>
 
 ---
 
-At TheCodingMachine, we build a lot of web applications (intranets, extranets and so on) which require to generate PDF from 
-various sources. Each time, we ended up using some well known libraries like **wkhtmltopdf** or **unoconv** and kind of lost time by
-reimplementing a solution from a project to another project. Meh.
+Gotenberg provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice to convert many
+documents to PDF, transform them, merge them, and more!
 
-# Menu
+## Quick Start
 
-* [Usage](#usage)
-* [Security](#security)
-* [Scalability](#scalability)
-* [Custom implementation](#custom-implementation)
-* [Clients](#clients)
+Open a terminal and run the following command:
 
-## Usage
-
-Let's say you're starting the API using this simple command:
-
-```sh
-$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:2.0.0
+```
+docker run --rm -p 3000:3000 gotenberg/gotenberg:7
 ```
 
-The API is now available on your host under `http://127.0.0.1:3000`.
+Alternatively, using the historic Docker repository from our sponsor [TheCodingMachine](https://www.thecodingmachine.com):
 
-It accepts `POST` requests with a `multipart/form-data` Content-Type. Your form data should provide one or more files to convert.
-The default image accepts the following:
-
-* Markdown files
-* HTML files
-* Office documents (.docx, .doc, .odt, .pptx, .ppt, .odp and so on)
-* PDF files
-
-**Heads up:** the API relies on the file extension to determine which library to use for conversion.
-
-There are two use cases:
-
-* If you send one file, it will convert it and return the resulting PDF
-* If many files, it will convert them to PDF, merge the resulting PDFs into a single PDF and return it
-
-### Examples:
-
-* One file
-
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.docx \
-    > result.pdf
+```
+docker run --rm -p 3000:3000 thecodingmachine/gotenberg:7
 ```
 
-* Many files
+The API is now available on your host at http://localhost:3000.
 
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.md \
-    --form files=@file.html \
-    --form files=@file.pdf \
-    --form files=@file.docx \
-    > result.pdf
-```
+Head to the [documentation](https://gotenberg.dev/docs/about) to learn how to interact with it 🚀
 
-## Security
+## Sponsors
 
-The API does not provide any authentication mechanisms. Make sure to not put it on a public facing port and your client(s) should always 
-controls what is sent to the API.
+<p align="center">
+    <a href="https://thecodingmachine.com">
+        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="429" height="210" />
+    </a>
+</p>
 
-## Scalability
+## Badges
 
-Some libraries like **unoconv** cannot perform concurrent conversions. That's why the API does only one conversion at a time.
-If your API is under heavy load, a request will take time to be processed. 
-
-Fortunately, you may pass through this limitation by scaling the API.
-
-In the following example, I'll demonstrate how to do some vertical scaling (= on the same machine) with Docker Compose, but of course horizontal scaling works too!
-
-```yaml
-version: '3'
-
-services:
-
-  # your others services
-      
-  gotenberg:
-    image: thecodingmachine/gotenberg:2.0.0
-```
-
-You may now launch your services using:
-
-```bash
-docker-compose up --scale gotenberg=your_number_of_instances
-```
-
-When requesting the Gotenberg service with your client(s), Docker will automatically redirect a request to a Gotenberg container
-according to the round-robin strategy.
-
-## Custom implementation
-
-The API relies on a simple YAML configuration file called `gotenberg.yml`. It allows you to tweak some values and even provides you 
-a way to change the commands called for each kind of conversion.
-
-Below the default configuration file:
-
-```yaml
-# The port the application will listen to.
-port: 3000
-
-logs:
-  # Accepted values, in order of severity: DEBUG, INFO, WARN, ERROR, FATAL, PANIC.
-  # Messages at and above the selected level will be logged.
-  level: "INFO"
-
-  # Accepted values: text, json.
-  # When a TTY is not attached, the output will be in the defined format.
-  formatter: "text"
-
-# You don't like a library which is used for a conversion? You want to handle a new file type?
-# You may provide here your own implementation!
-commands:
-
-  # Some libraries like unoconv cannot perform concurrent conversions. That's why the API does only one conversion at a time.
-  # If your current implementation uses libraries which are able to perform concurrent conversions, you may
-  # change this value to false.
-  lock: true
-
-  # Unlike others commands' templates, you have access to FilesPaths instead of FilePath: it gathers all PDF files which should be merged.
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  
-  # You may add more commands (or less, or even none).
-  conversions:
-
-      # The command template: you have access to FilePath and ResultFilePath variables.
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      # The binary which will call the command.
-      interpreter: "/bin/sh -c"
-      # Duration in seconds after which the command will be killed if it has not finished.
-      timeout: 30
-      # Files with the following extensions will be converted by the current command.
-      extensions:
-        - ".md"
-
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"
-```
-
-We provide binaries for a wide range of OS and architecture in the [releases page](../../releases), 
-so feel free to create your own Docker image for your implementation of the Gotenberg API :metal:
-
-## Clients
-
-* https://github.com/thecodingmachine/gotenberg-php-client (PHP client)
-* Add your own client by submitting a [pull request](../../pulls)!
-
----
-
-Would you like to update this documentation ? Feel free to open an [issue](../../issues).
+[![Docker pulls](https://img.shields.io/docker/pulls/gotenberg/gotenberg)](https://hub.docker.com/r/gotenberg/gotenberg)
+[![Docker pulls](https://img.shields.io/docker/pulls/thecodingmachine/gotenberg)](https://hub.docker.com/r/thecodingmachine/gotenberg)
+[![Continuous Integration](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml)
+[![Go Reference](https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg)](https://pkg.go.dev/github.com/gotenberg/gotenberg/v7)
+[![Codecov](https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg)](https://codecov.io/gh/gotenberg/gotenberg)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gotenberg/gotenberg)](https://goreportcard.com/report/gotenberg/gotenberg)

_tests/configurations/broken-gotenberg.yml

@@ -1,39 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: {
-      value: [
-      ...
-    }
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"
-

_tests/configurations/duplicate-command-gotenberg.yml

@@ -1,40 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/merge-timeout-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 0
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/no-lock-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: false
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/timeout-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 0
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 0
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 0
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 0
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/wrong-command-template-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/wrong-logging-formatter-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "DEBUG"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/wrong-logging-level-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "text"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/configurations/wrong-merge-command-template-gotenberg.yml

@@ -1,35 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  formatter: "text"
-commands:
-  lock: true
-  merge:
-    template: "pdftk {{ range $filePath := FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-    interpreter: "/bin/sh -c"
-    timeout: 30
-  conversions:
-    - template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".md"
-    - template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".html"
-        - ".htm"
-    - template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-      interpreter: "/bin/sh -c"
-      timeout: 30
-      extensions:
-        - ".doc"
-        - ".docx"
-        - ".odt"
-        - ".xls"
-        - ".xlsx"
-        - ".ods"
-        - ".ppt"
-        - ".pptx"
-        - ".odp"

_tests/file.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-  <meta charset="utf-8">
-  <title>Some title</title>
-  <meta name="author" content="Julien Neuhart">
-  <meta name="description" content="Simple HTML page">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-</head>
-
-<body>
-  <p>Hi! I have been converted from an HTML page!</p>
-</body>
-
-</html>

_tests/file.md

@@ -1 +0,0 @@
-# Hi, I've been converted from a markdown file!

app/config/config.go

@@ -1,213 +0,0 @@
-/*
-Package config contains all the logic allowing us to instantiate the application's configuration.
-
-The application's configuration is loaded from a YAML file named gotenberg.yml.
-It should be located where the user starts the application from the CLI.
-*/
-package config
-
-import (
-	"fmt"
-	"strings"
-	"text/template"
-
-	"github.com/sirupsen/logrus"
-)
-
-type (
-	// appConfig gathers all configuration data.
-	appConfig struct {
-		port          string
-		logsLevel     logrus.Level
-		logsFormatter logrus.Formatter
-		lock          bool
-		// commands associates a file extension with a Command instance.
-		// Particular case: ".pdf" extension is used for the merge command.
-		commands map[string]*Command
-	}
-
-	// Command gathers information on how to launch an external binary used for converting
-	// a file to PDF.
-	Command struct {
-		// Template is the data-driven template of the command.
-		Template *template.Template
-		// The binary which will call the command.
-		Interpreter []string
-		// Timeout is the duration in seconds after which the command's process will be killed
-		// if it does not finish before.
-		Timeout int
-	}
-)
-
-// our default instance of appConfig.
-var config = &appConfig{}
-
-// Reset reinitializes our configuration.
-func Reset() {
-	config = &appConfig{}
-}
-
-// WithPort sets the port which will be used by the application.
-func WithPort(port string) {
-	config.port = port
-}
-
-// GetPort returns the current port.
-func GetPort() string {
-	return config.port
-}
-
-// levels associates logging levels as defined in the configuration file gotenberg.yml
-// with its counterpart from the logrus library.
-var levels = map[string]logrus.Level{
-	"DEBUG": logrus.DebugLevel,
-	"INFO":  logrus.InfoLevel,
-	"WARN":  logrus.WarnLevel,
-	"ERROR": logrus.ErrorLevel,
-	"FATAL": logrus.FatalLevel,
-	"PANIC": logrus.PanicLevel,
-}
-
-type wrongLogsLevelError struct{}
-
-const wrongLogsLevelErrorMessage = "accepted values for logs level: DEBUG, INFO, WARN, ERROR, FATAL, PANIC"
-
-func (e *wrongLogsLevelError) Error() string {
-	return wrongLogsLevelErrorMessage
-}
-
-// WithLogsLevel sets the logs level.
-// If the given string does not match with a logrus level,
-// throws an error.
-func WithLogsLevel(level string) error {
-	l, ok := levels[level]
-	if !ok {
-		return &wrongLogsLevelError{}
-	}
-
-	config.logsLevel = l
-	return nil
-}
-
-// GetLogsLevel returns the current logs level.
-func GetLogsLevel() logrus.Level {
-	return config.logsLevel
-}
-
-// formatters associates logging formatter as defined in the configuration file gotenberg.yml
-// with its counterpart from the logrus library.
-var formatters = map[string]logrus.Formatter{
-	"text": &logrus.TextFormatter{},
-	"json": &logrus.JSONFormatter{},
-}
-
-type wrongLogsFormatterError struct{}
-
-const wrongLogsFormatterErrorMessage = "accepted value for logs formatter: text, json"
-
-func (e *wrongLogsFormatterError) Error() string {
-	return wrongLogsFormatterErrorMessage
-}
-
-// WithLogsFormatter sets the logs formatter.
-// If the given string does not match with a logrus formatter,
-// throws an error.
-func WithLogsFormatter(formatter string) error {
-	f, ok := formatters[formatter]
-	if !ok {
-		return &wrongLogsFormatterError{}
-	}
-
-	config.logsFormatter = f
-	return nil
-}
-
-// GetLogsFormatter returns the current logs formatter.
-func GetLogsFormatter() logrus.Formatter {
-	return config.logsFormatter
-}
-
-// WithLock sets the lock strategy.
-func WithLock(lock bool) {
-	config.lock = lock
-}
-
-// HasLock returns the current lock strategy.
-func HasLock() bool {
-	return config.lock
-}
-
-type interpreterEmptyError struct {
-	command string
-}
-
-const interpreterEmptyErrorMessage = "the interepreter for command %s should not be empty"
-
-func (e *interpreterEmptyError) Error() string {
-	return fmt.Sprintf(interpreterEmptyErrorMessage, e.command)
-}
-
-// NewCommand instantiates a Command. If the given command string
-// is not a valid template, throws an error.
-func NewCommand(command string, interpreter string, timeout int) (*Command, error) {
-	t, err := template.New(command).Parse(command)
-	if err != nil {
-		return nil, err
-	}
-
-	if interpreter == "" {
-		return nil, &interpreterEmptyError{command}
-	}
-
-	return &Command{t, strings.Fields(interpreter), timeout}, nil
-}
-
-type fileExtensionAlreadyUsedError struct {
-	extension       string
-	command         *Command
-	existingCommand *Command
-}
-
-const fileExtensionAlreadyUsedErrorMessage = "file extension %s from command %s is already used by command %s"
-
-func (e *fileExtensionAlreadyUsedError) Error() string {
-	return fmt.Sprintf(fileExtensionAlreadyUsedErrorMessage, e.extension, e.command.Template.Name(), e.existingCommand.Template.Name())
-}
-
-// WithCommand adds a Command instance and associates it with the given
-// file extension. If the file extension is already used by another Command
-// instance, throws an error.
-func WithCommand(extension string, command *Command) error {
-	if config.commands == nil {
-		config.commands = make(map[string]*Command)
-	}
-
-	existingCommand, ok := config.commands[extension]
-	if ok {
-		return &fileExtensionAlreadyUsedError{extension, command, existingCommand}
-	}
-
-	config.commands[extension] = command
-	return nil
-}
-
-type noCommandFoundForFileExtensionError struct {
-	extension string
-}
-
-const noCommandFoundForFileExtensionErrorMessage = "no command found for file extension %s"
-
-func (e *noCommandFoundForFileExtensionError) Error() string {
-	return fmt.Sprintf(noCommandFoundForFileExtensionErrorMessage, e.extension)
-}
-
-// GetCommand returns the Command instance associated with the given
-// file extension. If no Command instance found, throws an error.
-func GetCommand(extension string) (*Command, error) {
-	c, ok := config.commands[extension]
-	if !ok {
-		return nil, &noCommandFoundForFileExtensionError{extension}
-	}
-
-	return c, nil
-}

app/config/config_test.go

@@ -1,201 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/sirupsen/logrus"
-)
-
-func TestReset(t *testing.T) {
-	c := &appConfig{}
-	config.port = "3000"
-	Reset()
-
-	if c.port != config.port {
-		t.Error("Configuration should have been reset")
-	}
-}
-
-func TestWithPort(t *testing.T) {
-	port := "3000"
-	WithPort(port)
-
-	if config.port != port {
-		t.Errorf("Configuration populated with a wrong port: got '%s' want '%s'", config.port, port)
-	}
-}
-
-func TestGetPort(t *testing.T) {
-	port := "3000"
-	config.port = port
-
-	if GetPort() != port {
-		t.Errorf("Configuration returned a wrong port: got '%s' want '%s'", GetPort(), port)
-	}
-}
-
-func TestWrongLogsLevelError(t *testing.T) {
-	err := &wrongLogsLevelError{}
-	if err.Error() != wrongLogsLevelErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), wrongLogsLevelErrorMessage)
-	}
-}
-
-func TestWithLogsLevel(t *testing.T) {
-	var lvl string
-
-	// case 1: uses a wrong logs level.
-	lvl = "text"
-	if err := WithLogsLevel(lvl); err == nil {
-		t.Errorf("Configuration should not have been populated by using '%s' as logs level", lvl)
-	}
-
-	// case 2: uses a correct logs level.
-	lvl = "DEBUG"
-	if err := WithLogsLevel(lvl); err != nil {
-		t.Errorf("Configuration should have been populated by using '%s' as logs level", lvl)
-	}
-}
-
-func TestGetLogsLevel(t *testing.T) {
-	lvl := logrus.DebugLevel
-	config.logsLevel = lvl
-
-	if GetLogsLevel() != lvl {
-		t.Errorf("Configuration returned a wrong logs level: got '%s' want '%s'", GetLogsLevel(), lvl)
-	}
-}
-
-func TestWrongLogsFormatterError(t *testing.T) {
-	err := &wrongLogsFormatterError{}
-	if err.Error() != wrongLogsFormatterErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), wrongLogsFormatterErrorMessage)
-	}
-}
-
-func TestWithLogsFormatter(t *testing.T) {
-	var formatter string
-
-	// case 1: uses a wrong logs formatter.
-	formatter = "DEBUG"
-	if err := WithLogsFormatter(formatter); err == nil {
-		t.Errorf("Configuration should not have been populated by using '%s' as logs formatter", formatter)
-	}
-
-	// case 2: uses a correct logs formatter.
-	formatter = "text"
-	if err := WithLogsFormatter(formatter); err != nil {
-		t.Errorf("Configuration should have been populated by using '%s' as logs formatter", formatter)
-	}
-}
-
-func TestGetLogsFormatter(t *testing.T) {
-	formatter := &logrus.TextFormatter{}
-	config.logsFormatter = formatter
-
-	if GetLogsFormatter() != formatter {
-		t.Errorf("Configuration returned a wrong logs formatter: got '%v' want '%v'", GetLogsFormatter(), formatter)
-	}
-}
-
-func TestWithLock(t *testing.T) {
-	lock := true
-	WithLock(lock)
-
-	if config.lock != lock {
-		t.Errorf("Configuration populated with a wrong lock strategy: got '%t' want '%t'", config.lock, lock)
-	}
-}
-
-func TestHasLock(t *testing.T) {
-	lock := true
-	config.lock = true
-
-	if HasLock() != lock {
-		t.Errorf("Configuration returned a wrong port: got '%t' want '%t'", HasLock(), lock)
-	}
-}
-
-func TestInterpreterEmptyError(t *testing.T) {
-	err := &interpreterEmptyError{"echo hello world"}
-	expected := fmt.Sprintf(interpreterEmptyErrorMessage, err.command)
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}
-
-func TestNewCommand(t *testing.T) {
-	var cmd string
-
-	// case 1: uses a wrong command template.
-	cmd = "pdftk {{ range $filePath := FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-	if _, err := NewCommand(cmd, "/bin/sh -c", 0); err == nil {
-		t.Errorf("Command should not have been instantiated by using '%s' as command template", cmd)
-	}
-
-	// case 2: uses a correct command template.
-	cmd = "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"
-	if _, err := NewCommand(cmd, "/bin/sh -c", 0); err != nil {
-		t.Errorf("Command should have been instantiated by using '%s' as command template", cmd)
-	}
-
-	// case 3: uses an empty interpreter.
-	if _, err := NewCommand(cmd, "", 0); err == nil {
-		t.Error("Command should not have been instantiated by using an empty interpreter")
-	}
-}
-
-func TestFileExtensionAlreadyUsedError(t *testing.T) {
-	ext := ".pdf"
-	cmd1, _ := NewCommand("echo", "/bin/sh -c", 0)
-	cmd2, _ := NewCommand("echo", "/bin/sh -c", 0)
-	err := &fileExtensionAlreadyUsedError{ext, cmd1, cmd2}
-	expected := fmt.Sprintf(fileExtensionAlreadyUsedErrorMessage, err.extension, err.command.Template.Name(), err.existingCommand.Template.Name())
-
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}
-
-func TestWithCommand(t *testing.T) {
-	ext := ".pdf"
-	cmd, _ := NewCommand("echo", "/bin/sh -c", 0)
-
-	// case 1: uses a command with a file extension not already referenced.
-	if err := WithCommand(ext, cmd); err != nil {
-		t.Errorf("Configuration should have been populated by using a command with the file extension '%s'", ext)
-	}
-
-	// case 2: uses a command with a file extension already referenced.
-	if err := WithCommand(ext, cmd); err == nil {
-		t.Errorf("Configuration should not have been populated by using a command with the file extension '%s'", ext)
-	}
-}
-
-func TestNoCommandFoundForFileExtensionError(t *testing.T) {
-	err := &noCommandFoundForFileExtensionError{".pdf"}
-	expected := fmt.Sprintf(noCommandFoundForFileExtensionErrorMessage, err.extension)
-
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}
-
-func TestGetCommand(t *testing.T) {
-	Reset()
-	ext := ".pdf"
-	cmd, _ := NewCommand("echo", "/bin/sh -c", 0)
-	WithCommand(ext, cmd)
-
-	// case 1: uses a file extension which has a command associated.
-	if _, err := GetCommand(ext); err != nil {
-		t.Errorf("Configuration should have been able to return a command by using the file extension '%s'", ext)
-	}
-
-	// case 2: uses a file extension which has no command associated.
-	ext = ".docx"
-	if _, err := GetCommand(ext); err == nil {
-		t.Errorf("Configuration should not have been able to return a command by using the file extension '%s'", ext)
-	}
-}

app/config/parser.go

@@ -1,99 +0,0 @@
-package config
-
-import (
-	"io/ioutil"
-
-	"gopkg.in/yaml.v2"
-)
-
-// ParseFile instantiates the application's configuration using the given YAML file.
-func ParseFile(configurationFilePath string) error {
-	fileConfig, err := readFile(configurationFilePath)
-	if err != nil {
-		return err
-	}
-
-	WithPort(fileConfig.Port)
-
-	if err := WithLogsLevel(fileConfig.Logs.Level); err != nil {
-		return err
-	}
-
-	if err := WithLogsFormatter(fileConfig.Logs.Formatter); err != nil {
-		return err
-	}
-
-	WithLock(fileConfig.Commands.Lock)
-
-	// handles merge command first...
-	cmd, err := NewCommand(fileConfig.Commands.Merge.Template, fileConfig.Commands.Merge.Interpreter, fileConfig.Commands.Merge.Timeout)
-	if err != nil {
-		return err
-	}
-
-	WithCommand(".pdf", cmd)
-
-	// ...then conversion commands!
-	for _, command := range fileConfig.Commands.Conversions {
-		cmd, err := NewCommand(command.Template, command.Interpreter, command.Timeout)
-		if err != nil {
-			return err
-		}
-
-		for _, ext := range command.Extensions {
-			if err := WithCommand(ext, cmd); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-type (
-	// fileConfig gathers all data coming from the configuration file gotenberg.yml.
-	fileConfig struct {
-		Port string `yaml:"port"`
-		Logs struct {
-			Level     string `yaml:"level"`
-			Formatter string `yaml:"formatter"`
-		} `yaml:"logs"`
-		Commands struct {
-			Lock        bool                 `yaml:"lock"`
-			Merge       *mergeCommand        `yaml:"merge"`
-			Conversions []*conversionCommand `yaml:"conversions,omitempty"`
-		} `yaml:"commands"`
-	}
-
-	// mergeCommand gathers all data regarding the... merge command.
-	mergeCommand struct {
-		Template    string `yaml:"template"`
-		Interpreter string `yaml:"interpreter"`
-		Timeout     int    `yaml:"timeout"`
-	}
-
-	// conversionCommand gathers all data regarding a conversion command.
-	conversionCommand struct {
-		Template    string   `yaml:"template"`
-		Interpreter string   `yaml:"interpreter"`
-		Timeout     int      `yaml:"timeout"`
-		Extensions  []string `yaml:"extensions"`
-	}
-)
-
-// readFile instantiates a fileConfig instance by reading
-// the given YAML file.
-func readFile(configurationFilePath string) (*fileConfig, error) {
-	c := &fileConfig{}
-
-	data, err := ioutil.ReadFile(configurationFilePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := yaml.Unmarshal(data, &c); err != nil {
-		return nil, err
-	}
-
-	return c, nil
-}

app/config/parser_test.go

@@ -1,62 +0,0 @@
-package config
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func load(configurationFilePath string) error {
-	Reset()
-	return ParseFile(configurationFilePath)
-}
-
-func TestParseFile(t *testing.T) {
-	var path string
-
-	// case 1: uses an empty configuration file path.
-	if err := load(""); err == nil {
-		t.Error("Configuration should not have been populated by using an empty configuration file path")
-	}
-
-	// case 2: uses a broken configuration file.
-	path, _ = filepath.Abs("../../_tests/configurations/broken-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 3: uses a configuration file with a wrong logging level.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-logging-level-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 4: uses a configuration file with a wrong logging formatter.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-logging-formatter-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 5: uses a configuration file with a wrong merge command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-merge-command-template-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 6: uses a configuration file with a wrong command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-command-template-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 7: uses a configuration file with a duplicate command.
-	path, _ = filepath.Abs("../../_tests/configurations/duplicate-command-gotenberg.yml")
-	if err := load(path); err == nil {
-		t.Errorf("Configuration should not have been populated with '%s'", path)
-	}
-
-	// case 8: uses a correct configuration file.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	if err := load(path); err != nil {
-		t.Errorf("Configuration should have been populated with '%s'", path)
-	}
-}

app/context/context.go

@@ -1,105 +0,0 @@
-// Package context provides functions for setting and getting values from
-// a request's context.
-package context
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/thecodingmachine/gotenberg/app/converter"
-)
-
-type key uint32
-
-const (
-	requestIDKey key = iota
-	converterKey
-	resultFilePathKey
-)
-
-// WithRequestID populates a request's context with the given request ID
-// and returns the updated request.
-func WithRequestID(r *http.Request, requestID string) *http.Request {
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, requestIDKey, requestID)
-	r = r.WithContext(ctx)
-
-	return r
-}
-
-type requestIDNotFoundError struct{}
-
-const requestIDNotFoundErrorMessage = "the request ID was not found in request context"
-
-func (e *requestIDNotFoundError) Error() string {
-	return requestIDNotFoundErrorMessage
-}
-
-// GetRequestID returns the request ID if found in
-// the request's context. Otherwise throws an error.
-func GetRequestID(r *http.Request) (string, error) {
-	ID, ok := r.Context().Value(requestIDKey).(string)
-	if !ok {
-		return "", &requestIDNotFoundError{}
-	}
-
-	return ID, nil
-}
-
-// WithConverter populates a request's context with the given converter
-// and returns the updated request.
-func WithConverter(r *http.Request, converter *converter.Converter) *http.Request {
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, converterKey, converter)
-	r = r.WithContext(ctx)
-
-	return r
-}
-
-type converterNotFoundError struct{}
-
-const converterNotFoundErrorMessage = "the converter was not found in request context"
-
-func (e *converterNotFoundError) Error() string {
-	return converterNotFoundErrorMessage
-}
-
-// GetConverter returns the converter if found in
-// the request's context. Otherwise throws an error.
-func GetConverter(r *http.Request) (*converter.Converter, error) {
-	c, ok := r.Context().Value(converterKey).(*converter.Converter)
-	if !ok {
-		return nil, &converterNotFoundError{}
-	}
-
-	return c, nil
-}
-
-// WithResultFilePath populates a request's context with the given result file path
-// and returns the updated request.
-func WithResultFilePath(r *http.Request, resultFilePath string) *http.Request {
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, resultFilePathKey, resultFilePath)
-	r = r.WithContext(ctx)
-
-	return r
-}
-
-type resultFilePathNotFoundError struct{}
-
-const resultFilePathNotFoundErrorMessage = "the result file path was not found in request context"
-
-func (e *resultFilePathNotFoundError) Error() string {
-	return resultFilePathNotFoundErrorMessage
-}
-
-// GetResultFilePath returns the result file path if found in
-// the request's context. Otherwise throws an error.
-func GetResultFilePath(r *http.Request) (string, error) {
-	path, ok := r.Context().Value(resultFilePathKey).(string)
-	if !ok {
-		return "", &resultFilePathNotFoundError{}
-	}
-
-	return path, nil
-}

app/context/context_test.go

@@ -1,100 +0,0 @@
-package context
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/converter"
-
-	"github.com/satori/go.uuid"
-)
-
-func TestWithRequestID(t *testing.T) {
-	requestID := uuid.NewV4().String()
-	req := WithRequestID(httptest.NewRequest(http.MethodPost, "/", nil), requestID)
-	if ID, _ := req.Context().Value(requestIDKey).(string); ID != requestID {
-		t.Errorf("Context returned a wrong converter: got '%s' want '%s'", ID, requestID)
-	}
-}
-
-func TestRequestIDNotFoundError(t *testing.T) {
-	err := &requestIDNotFoundError{}
-	if err.Error() != requestIDNotFoundErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), requestIDNotFoundErrorMessage)
-	}
-}
-
-func TestGetRequestID(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a request ID entry in its context.
-	if _, err := GetRequestID(req); err == nil {
-		t.Error("Context should not have a request ID entry")
-	}
-
-	// case 2: uses a request with a request ID entry in its context.
-	req = WithRequestID(req, uuid.NewV4().String())
-	if _, err := GetRequestID(req); err != nil {
-		t.Error("Context should have a request ID entry")
-	}
-}
-
-func TestWithConverter(t *testing.T) {
-	req := WithConverter(httptest.NewRequest(http.MethodPost, "/", nil), &converter.Converter{})
-	if c, _ := req.Context().Value(converterKey).(*converter.Converter); c == nil {
-		t.Errorf("Context returned a wrong converter: got '%v' want not nil", c)
-	}
-}
-
-func TestConverterNotFoundError(t *testing.T) {
-	err := &converterNotFoundError{}
-	if err.Error() != converterNotFoundErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), converterNotFoundErrorMessage)
-	}
-}
-
-func TestGetConverter(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a converter entry in its context.
-	if _, err := GetConverter(req); err == nil {
-		t.Error("Context should not have a converter entry")
-	}
-
-	// case 2: uses a request with a converter entry in its context.
-	req = WithConverter(req, &converter.Converter{})
-	if _, err := GetConverter(req); err != nil {
-		t.Error("Context should have a converter entry")
-	}
-}
-
-func TestWithResultFilePath(t *testing.T) {
-	filePath := "file.pdf"
-	req := WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), filePath)
-	if path, _ := req.Context().Value(resultFilePathKey).(string); path != filePath {
-		t.Errorf("Context returned a wrong result file path: got '%s' want '%s'", path, filePath)
-	}
-}
-
-func TestResultFilePathNotFoundError(t *testing.T) {
-	err := &resultFilePathNotFoundError{}
-	if err.Error() != resultFilePathNotFoundErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), resultFilePathNotFoundErrorMessage)
-	}
-}
-
-func TestGetResultFilePath(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a result file path entry in its context.
-	if _, err := GetResultFilePath(req); err == nil {
-		t.Error("Context should not have a result file path entry")
-	}
-
-	// case 2: uses a request with a result file path entry in its context.
-	req = WithResultFilePath(req, "file.pdf")
-	if _, err := GetResultFilePath(req); err != nil {
-		t.Error("Context should have a result file path entry")
-	}
-}

app/converter/converter.go

@@ -1,114 +0,0 @@
-// Package converter implements a solution for converting one or more files to PDF.
-package converter
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-	"github.com/thecodingmachine/gotenberg/app/converter/process"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/satori/go.uuid"
-)
-
-// Converter handles conversion into PDF of files coming from a request.
-type Converter struct {
-	files      []*gfile.File
-	workingDir string
-}
-
-// NoFileToConvertError is raided when a request has not file attached to it.
-type NoFileToConvertError struct{}
-
-const noFileToConvertErrorMessage = "no file to convert"
-
-func (e *NoFileToConvertError) Error() string {
-	return noFileToConvertErrorMessage
-}
-
-// NewConverter instantiates a converter by parsing a request.
-func NewConverter(r *http.Request) (*Converter, error) {
-	c := &Converter{
-		workingDir: fmt.Sprintf("./%s/", uuid.NewV4().String()),
-	}
-
-	if err := os.Mkdir(c.workingDir, 0666); err != nil {
-		return nil, err
-	}
-
-	logger.Debugf("created working directory %s", c.workingDir)
-
-	reader, err := r.MultipartReader()
-	if err != nil {
-		return c, err
-	}
-
-	for {
-		part, err := reader.NextPart()
-		if err == io.EOF {
-			break
-		}
-
-		fileName := part.FileName()
-		if fileName == "" {
-			continue
-		}
-
-		f, err := gfile.NewFile(c.workingDir, part, fileName)
-		if err != nil {
-			return c, err
-		}
-
-		c.files = append(c.files, f)
-	}
-
-	if len(c.files) == 0 {
-		return c, &NoFileToConvertError{}
-	}
-
-	return c, nil
-}
-
-// Convert converts its associated files to PDF. If more than one file,
-// it will merge all of them into one unique PDF file.
-// Returns the new file path or an error if something bad happened.
-func (c *Converter) Convert() (string, error) {
-	var filesPaths []string
-	for _, f := range c.files {
-		if f.Extension != ".pdf" {
-			path, err := process.Unconv(c.workingDir, f)
-			if err != nil {
-				return "", err
-			}
-
-			filesPaths = append(filesPaths, path)
-		} else {
-			filesPaths = append(filesPaths, f.Path)
-		}
-	}
-
-	if len(filesPaths) == 1 {
-		return filesPaths[0], nil
-	}
-
-	path, err := process.Merge(c.workingDir, filesPaths)
-	if err != nil {
-		return "", err
-	}
-
-	return path, nil
-}
-
-// Clear removes all file inside its working directory.
-func (c *Converter) Clear() error {
-	if err := os.RemoveAll(c.workingDir); err != nil {
-		logger.Error(fmt.Errorf("failed to remove working directory %s", c.workingDir))
-		return err
-	}
-
-	logger.Debugf("removed working directory %s", c.workingDir)
-	return nil
-}

app/converter/converter_test.go

@@ -1,150 +0,0 @@
-package converter
-
-import (
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-)
-
-func makeRequest(filesPaths ...string) *http.Request {
-	r, w := io.Pipe()
-	mpw := multipart.NewWriter(w)
-
-	go func() {
-		var part io.Writer
-		defer w.Close()
-
-		if len(filesPaths) == 0 {
-			part, _ = mpw.CreateFormField("foo")
-			part.Write([]byte("bar"))
-		} else {
-			for _, filePath := range filesPaths {
-				file, _ := os.Open(filePath)
-				defer file.Close()
-
-				fileInfo, _ := file.Stat()
-				part, _ = mpw.CreateFormFile("files", fileInfo.Name())
-				io.Copy(part, file)
-			}
-		}
-
-		mpw.Close()
-	}()
-
-	req := httptest.NewRequest(http.MethodPost, "/", r)
-	req.Header.Set("Content-Type", mpw.FormDataContentType())
-	return req
-}
-
-func load(configurationFilePath string) {
-	config.Reset()
-	path, _ := filepath.Abs(configurationFilePath)
-	config.ParseFile(path)
-}
-
-func TestNoFileToConvertError(t *testing.T) {
-	err := &NoFileToConvertError{}
-	if err.Error() != noFileToConvertErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), noFileToConvertErrorMessage)
-	}
-}
-
-func TestNewConverter(t *testing.T) {
-	var (
-		path  string
-		oPath string
-	)
-
-	load("../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses a request with a single file.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path)); err != nil {
-		t.Errorf("Converter should have been instantiated with '%s'", path)
-	}
-
-	// case 2: uses a request with wrong file type.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	if _, err := NewConverter(makeRequest(path)); err == nil {
-		t.Errorf("Converter should not have been instantiated with '%s'", path)
-	}
-
-	// case 3: uses a request with two files.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path, oPath)); err != nil {
-		t.Errorf("Converter should have been instantiated with '%s' and '%s'", path, oPath)
-	}
-
-	// case 4: uses a request with one Office file type and one wrong file type.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path, oPath)); err == nil {
-		t.Errorf("Converter should not have been instantiated with '%s' and '%s'", path, oPath)
-	}
-
-	// case 5: uses a request with no file.
-	if _, err := NewConverter(makeRequest()); err == nil {
-		t.Error("Converter should not have been instantiated with no file")
-	}
-}
-
-func TestConvert(t *testing.T) {
-	var (
-		path  string
-		oPath string
-		c     *Converter
-	)
-
-	load("../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses a request with a single file.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path))
-	if _, err := c.Convert(); err != nil {
-		t.Errorf("Converter should have been able to convert '%s' to PDF", path)
-	}
-
-	// case 2: uses a request with two files.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path, oPath))
-	if _, err := c.Convert(); err != nil {
-		t.Errorf("Converter should have been able to convert '%s' and '%s' to PDF", path, oPath)
-	}
-
-	load("../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 3: uses a request with a single file and a configuration with an unsuitable timeout for the conversion commands.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path))
-	if _, err := c.Convert(); err == nil {
-		t.Errorf("Converter should not have been able to convert '%s' to PDF", path)
-	}
-
-	load("../../_tests/configurations/merge-timeout-gotenberg.yml")
-
-	// case 4: uses a request with two files and a configuration with an unsuitable timeout for the merge command.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path, oPath))
-	if _, err := c.Convert(); err == nil {
-		t.Errorf("Converter should not have been able to merge '%s' and '%s' into PDF", path, oPath)
-	}
-}
-
-func TestClear(t *testing.T) {
-	load("../../_tests/configurations/gotenberg.yml")
-
-	path, _ := filepath.Abs("../../_tests/file.docx")
-	c, _ := NewConverter(makeRequest(path))
-	if err := c.Clear(); err != nil {
-		t.Error("Converter should have been able to clear itself")
-	}
-}

app/converter/file/file.go

@@ -1,60 +0,0 @@
-// Package file implements a solution for handling files coming from a request.
-package file
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/dustin/go-humanize"
-	"github.com/satori/go.uuid"
-)
-
-// File represents a file which has been created
-// from a request.
-type File struct {
-	// Extension is the extension of the file.
-	Extension string
-	// Path is the file path.
-	Path string
-}
-
-// NewFile creates a file in the considered directory.
-// Returns a *File instance or an error if something bad happened.
-func NewFile(workingDir string, r io.Reader, fileName string) (*File, error) {
-	ext := filepath.Ext(fileName)
-
-	if _, err := config.GetCommand(ext); err != nil {
-		return nil, err
-	}
-
-	f := &File{ext, MakeFilePath(workingDir, ext)}
-
-	file, err := os.Create(f.Path)
-	if err != nil {
-		return nil, err
-	}
-
-	defer file.Close()
-
-	n, err := io.Copy(file, r)
-	if err != nil {
-		return nil, err
-	}
-
-	// resets the read pointer.
-	file.Seek(0, 0)
-
-	logger.Debugf("working file %s has been created from %s (%s copied)", f.Path, fileName, humanize.Bytes(uint64(n)))
-	return f, nil
-}
-
-// MakeFilePath is a simple helper which generates a random file name
-// and associates it with the considered directory to make a path.
-func MakeFilePath(workingDir string, ext string) string {
-	return fmt.Sprintf("%s%s%s", workingDir, uuid.NewV4().String(), ext)
-}

app/converter/file/file_test.go

@@ -1,38 +0,0 @@
-package file
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-)
-
-func load(configurationFilePath string) {
-	config.Reset()
-	path, _ := filepath.Abs(configurationFilePath)
-	config.ParseFile(path)
-}
-
-func TestNewFile(t *testing.T) {
-	load("../../../_tests/configurations/gotenberg.yml")
-
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	// case 1: uses a wrong file name.
-	if _, err := NewFile(workingDir, new(bytes.Buffer), "file.yml"); err == nil {
-		t.Error("File should not have been instantiated with an empty buffer")
-	}
-
-	// case 2: uses a file name.
-	filePath, _ := filepath.Abs("../../../_tests/file.pdf")
-	r, _ := os.Open(filePath)
-	defer r.Close()
-	if _, err := NewFile(workingDir, r, "file.pdf"); err != nil {
-		t.Errorf("File should have been instantiated using a reader of '%s'", filePath)
-	}
-
-	os.RemoveAll(workingDir)
-}

app/converter/process/process.go

@@ -1,130 +0,0 @@
-// Package process handles all commands executions.
-package process
-
-import (
-	"bytes"
-	"fmt"
-	"os/exec"
-	"sync"
-	"time"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-)
-
-type runner struct {
-	mu sync.Mutex
-}
-
-var forest = &runner{}
-
-type commandTimeoutError struct {
-	command string
-	timeout int
-}
-
-const commandTimeoutErrorMessage = "the command %s has reached the %d second(s) timeout"
-
-func (e *commandTimeoutError) Error() string {
-	return fmt.Sprintf(commandTimeoutErrorMessage, e.command, e.timeout)
-}
-
-// run runs the given command. If timeout is reached or
-// something bad happened, returns an error.
-func (r *runner) run(command string, interpreter []string, timeout int) error {
-	if config.HasLock() {
-		r.mu.Lock()
-		defer r.mu.Unlock()
-	} else {
-		logger.Warn("lock disabled")
-	}
-
-	binary := interpreter[0]
-	parameters := append(interpreter[1:], command)
-	cmd := exec.Command(binary, parameters...)
-	logger.Debugf("executing command %s", cmd.Args)
-
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	done := make(chan error, 1)
-	go func() {
-		done <- cmd.Wait()
-	}()
-
-	// wait for the process to finish or kill it after a timeout.
-	select {
-	case <-time.After(time.Duration(timeout) * time.Second):
-		if err := cmd.Process.Kill(); err != nil {
-			return err
-		}
-
-		return &commandTimeoutError{command, timeout}
-	case err := <-done:
-		if err != nil {
-			return err
-		}
-
-		return nil
-	}
-}
-
-// conversionData will be applied to the data-driven templates of conversions commands.
-type conversionData struct {
-	FilePath       string
-	ResultFilePath string
-}
-
-// Unconv converts a file to PDF and returns the new file path.
-func Unconv(workingDir string, file *gfile.File) (string, error) {
-	cmdData := &conversionData{file.Path, gfile.MakeFilePath(workingDir, ".pdf")}
-
-	cmd, err := config.GetCommand(file.Extension)
-	if err != nil {
-		return "", err
-	}
-
-	var data bytes.Buffer
-	if err := cmd.Template.Execute(&data, cmdData); err != nil {
-		return "", err
-	}
-
-	err = forest.run(data.String(), cmd.Interpreter, cmd.Timeout)
-	if err != nil {
-		return "", err
-	}
-
-	logger.Debugf("created %s from %s", cmdData.ResultFilePath, cmdData.FilePath)
-	return cmdData.ResultFilePath, nil
-}
-
-// mergeData will be applied to the data-driven template of the merge command.
-type mergeData struct {
-	FilesPaths     []string
-	ResultFilePath string
-}
-
-// Merge merges many PDF files to one unique PDF file and returns the new file path.
-func Merge(workingDir string, filesPaths []string) (string, error) {
-	cmdData := &mergeData{filesPaths, gfile.MakeFilePath(workingDir, ".pdf")}
-
-	cmd, err := config.GetCommand(".pdf")
-	if err != nil {
-		return "", err
-	}
-
-	var data bytes.Buffer
-	if err := cmd.Template.Execute(&data, cmdData); err != nil {
-		return "", err
-	}
-
-	err = forest.run(data.String(), cmd.Interpreter, cmd.Timeout)
-	if err != nil {
-		return "", err
-	}
-
-	logger.Debugf("created %s from %+v", cmdData.ResultFilePath, cmdData.FilesPaths)
-	return cmdData.ResultFilePath, nil
-}

app/converter/process/process_test.go

@@ -1,140 +0,0 @@
-package process
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-)
-
-func makeFile(workingDir string, fileName string) *gfile.File {
-	filePath := fmt.Sprintf("%s%s", "../../../_tests/", fileName)
-	absPath, _ := filepath.Abs(filePath)
-
-	r, _ := os.Open(absPath)
-	defer r.Close()
-
-	f, _ := gfile.NewFile(workingDir, r, fileName)
-
-	return f
-}
-
-func load(configurationFilePath string) {
-	config.Reset()
-	path, _ := filepath.Abs(configurationFilePath)
-	config.ParseFile(path)
-}
-
-func TestCommandTimeoutError(t *testing.T) {
-	err := &commandTimeoutError{"echo hello", 30}
-	expected := fmt.Sprintf(commandTimeoutErrorMessage, err.command, err.timeout)
-
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}
-
-func TestRun(t *testing.T) {
-	var cmd string
-
-	load("../../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses a simple command.
-	cmd = "echo Hello world"
-	if err := forest.run(cmd, strings.Fields("/bin/sh -c"), 30); err != nil {
-		t.Errorf("Command '%s' should have worked", cmd)
-	}
-
-	// case 2: uses a simple command but with an unsuitable timeout.
-	cmd = "sleep 5"
-	if err := forest.run(cmd, strings.Fields("/bin/sh -c"), 0); err == nil {
-		t.Errorf("Command '%s' should not have worked", cmd)
-	}
-
-	// case 3: uses a broken command.
-	cmd = "helloworld"
-	if err := forest.run(cmd, strings.Fields("/bin/sh -c"), 30); err == nil {
-		t.Errorf("Command '%s' should not have worked", cmd)
-	}
-
-	load("../../../_tests/configurations/no-lock-gotenberg.yml")
-
-	// case 4: uses a configuration with a no lock strategy.
-	cmd = "echo Hello world"
-	if err := forest.run(cmd, strings.Fields("/bin/sh -c"), 30); err != nil {
-		t.Errorf("Command '%s' should have worked", cmd)
-	}
-}
-
-func TestUnconv(t *testing.T) {
-	var file *gfile.File
-
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	load("../../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses an Markdown file type.
-	file = makeFile(workingDir, "file.md")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 2: uses an HTML file type.
-	file = makeFile(workingDir, "file.html")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 3: uses an Office file type.
-	file = makeFile(workingDir, "file.docx")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 4: uses a PDF file type.
-	file = makeFile(workingDir, "file.pdf")
-	if _, err := Unconv(workingDir, file); err == nil {
-		t.Errorf("Converting '%s' to PDF should not have worked", file.Path)
-	}
-
-	load("../../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 5: uses a command with an unsuitable timeout.
-	file = makeFile(workingDir, "file.docx")
-	if _, err := Unconv(workingDir, makeFile(workingDir, "file.docx")); err == nil {
-		t.Errorf("Converting '%s' to PDF should have reached timeout", file.Path)
-	}
-
-	os.RemoveAll(workingDir)
-}
-
-func TestMerge(t *testing.T) {
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	load("../../../_tests/configurations/gotenberg.yml")
-
-	var filesPaths []string
-	path, _ := filepath.Abs("../../../_tests/file.pdf")
-	filesPaths = append(filesPaths, path)
-	filesPaths = append(filesPaths, path)
-
-	// case 1: simple merge.
-	if _, err := Merge(workingDir, filesPaths); err != nil {
-		t.Error("Merge should have worked")
-	}
-
-	load("../../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 2: uses a command with an unsuitable timeout.
-	if _, err := Merge(workingDir, filesPaths); err == nil {
-		t.Error("Merge should have reached timeout")
-	}
-
-	os.RemoveAll(workingDir)
-}

app/handlers.go

@@ -1,170 +0,0 @@
-// Package app implements all functions on which a request will pass through.
-package app
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	"github.com/thecodingmachine/gotenberg/app/context"
-	"github.com/thecodingmachine/gotenberg/app/converter"
-	ghttp "github.com/thecodingmachine/gotenberg/app/http"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/dustin/go-humanize"
-	"github.com/justinas/alice"
-	"github.com/satori/go.uuid"
-)
-
-// GetHandlersChain returns the handlers chaining
-// thanks to the alice library.
-func GetHandlersChain() http.Handler {
-	return alice.New(enforceContentLengthHandler, enforceContentTypeHandler, convertHandler).ThenFunc(serveHandler)
-}
-
-type requestHasNoContentError struct{}
-
-const requestHasNoContentErrorMessage = "request has not content"
-
-func (e *requestHasNoContentError) Error() string {
-	return requestHasNoContentErrorMessage
-}
-
-// enforeContentLengthHandler checks if the request has content.
-func enforceContentLengthHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.ContentLength == 0 {
-			e := &requestHasNoContentError{}
-			http.Error(w, e.Error(), http.StatusBadRequest)
-			logger.Error(e)
-			return
-		}
-
-		requestID := uuid.NewV4().String()
-		r = context.WithRequestID(r, requestID)
-		logger.Infof("identified new request (%s) with %s", humanize.Bytes(uint64(r.ContentLength)), requestID)
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// enforceContentTypeHandler checks if the "Content-Type" entry
-// from the request's header matches the allowed content type.
-func enforceContentTypeHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := ghttp.CheckAuthorizedContentType(r.Header); err != nil {
-			http.Error(w, err.Error(), http.StatusUnsupportedMediaType)
-			logger.Error(err)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// convertHandler is in charge of converting the file(s) from the request to PDF.
-func convertHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		c, err := converter.NewConverter(r)
-		if err != nil {
-			if _, ok := err.(*converter.NoFileToConvertError); ok {
-				http.Error(w, err.Error(), http.StatusBadRequest)
-			} else {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-
-			logger.Error(err)
-
-			if c != nil {
-				r = context.WithConverter(r, c)
-				cleanup(r)
-			}
-
-			return
-		}
-
-		r = context.WithConverter(r, c)
-
-		path, err := c.Convert()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			logger.Error(err)
-			cleanup(r)
-			return
-		}
-
-		r = context.WithResultFilePath(r, path)
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// serveHandler simply serves the created PDF.
-func serveHandler(w http.ResponseWriter, r *http.Request) {
-	path, err := context.GetResultFilePath(r)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	reader, err := os.Open(path)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	defer reader.Close()
-
-	resultFileInfo, err := reader.Stat()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	requestID, err := context.GetRequestID(r)
-	if err != nil {
-		logger.Error(err)
-	}
-
-	logger.Debugf("serving result file %s for request %s...", path, requestID)
-
-	done := make(chan error, 1)
-	go func() {
-		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", resultFileInfo.Name()))
-		w.Header().Set("Content-Type", "application/pdf")
-		w.Header().Set("Content-Length", fmt.Sprintf("%d", resultFileInfo.Size()))
-		_, err := io.Copy(w, reader)
-
-		done <- err
-	}()
-
-	err = <-done
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-	} else {
-		logger.Infof("result file %s (%s) sent for request %s", path, humanize.Bytes(uint64(resultFileInfo.Size())), requestID)
-	}
-
-	cleanup(r)
-}
-
-// cleanup removes all files created during the conversion.
-func cleanup(r *http.Request) {
-	c, err := context.GetConverter(r)
-	if err != nil {
-		logger.Error(err)
-		return
-	}
-
-	if err := c.Clear(); err != nil {
-		logger.Error(err)
-	}
-}

app/handlers_test.go

@@ -1,227 +0,0 @@
-package app
-
-import (
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/context"
-
-	"github.com/justinas/alice"
-)
-
-func makeRequest(filesPaths ...string) *http.Request {
-	r, w := io.Pipe()
-	mpw := multipart.NewWriter(w)
-
-	go func() {
-		var part io.Writer
-		defer w.Close()
-
-		if len(filesPaths) == 0 {
-			part, _ = mpw.CreateFormField("foo")
-			part.Write([]byte("bar"))
-		} else {
-			for _, filePath := range filesPaths {
-				file, _ := os.Open(filePath)
-				defer file.Close()
-
-				fileInfo, _ := file.Stat()
-				part, _ = mpw.CreateFormFile("files", fileInfo.Name())
-				io.Copy(part, file)
-			}
-		}
-
-		mpw.Close()
-	}()
-
-	req := httptest.NewRequest(http.MethodPost, "/", r)
-	req.Header.Set("Content-Type", mpw.FormDataContentType())
-	return req
-}
-
-func load(configurationFilePath string) {
-	config.Reset()
-	path, _ := filepath.Abs(configurationFilePath)
-	config.ParseFile(path)
-}
-
-func fakeSuccessHandler(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(http.StatusOK)
-}
-
-func TestGetHandlersChain(t *testing.T) {
-	// dumb test to improve code coverage...
-	if GetHandlersChain() == nil {
-		t.Errorf("Handler chains should not be nil")
-	}
-}
-
-func TestRequestHasNoContentError(t *testing.T) {
-	err := &requestHasNoContentError{}
-	if err.Error() != requestHasNoContentErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), requestHasNoContentErrorMessage)
-	}
-}
-
-func TestEnforceContentLengthHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New(enforceContentLengthHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends an empty request.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusBadRequest {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusBadRequest)
-	}
-
-	// case 2: sends a real body.
-	path, _ := filepath.Abs("../_tests/file.docx")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, makeRequest(path))
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}
-
-func TestEnforceContentTypeHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New(enforceContentTypeHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends a wrong content type.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	req.Header.Set("Content-Type", "application/pdf")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusUnsupportedMediaType {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusUnsupportedMediaType)
-	}
-
-	// case 2: sends a good content type.
-	path, _ := filepath.Abs("../_tests/file.docx")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, makeRequest(path))
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned wrong a status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}
-
-func TestConvertHandler(t *testing.T) {
-	var (
-		req   *http.Request
-		rr    *httptest.ResponseRecorder
-		path  string
-		oPath string
-	)
-
-	h := alice.New(convertHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends a request without body.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 2: sends a request with no file.
-	req = makeRequest()
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusBadRequest {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusBadRequest)
-	}
-
-	load("../_tests/configurations/merge-timeout-gotenberg.yml")
-
-	// case 3: sends a request with two files and using an unsuitable timeout for merge commande.
-	path, _ = filepath.Abs("../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../_tests/file.docx")
-	req = makeRequest(path, oPath)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	load("../_tests/configurations/gotenberg.yml")
-
-	// case 4: sends a request with two files.
-	path, _ = filepath.Abs("../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../_tests/file.docx")
-	req = makeRequest(path, oPath)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-
-	// case 5: sends five requests (almost) simultany.
-	path, _ = filepath.Abs("../_tests/file.docx")
-	filesPaths := []string{
-		path,
-		path,
-		path,
-		path,
-		path,
-	}
-
-	for i := 0; i < len(filesPaths); i++ {
-		go func(i int) {
-			req := makeRequest(filesPaths[i])
-			rr := httptest.NewRecorder()
-			h.ServeHTTP(rr, req)
-			if status := rr.Code; status != http.StatusOK {
-				t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-			}
-		}(i)
-	}
-}
-
-func TestServeHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New().ThenFunc(serveHandler)
-
-	// case 1: sends a request without a result file path entry in its context.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 2: sends a request with a wrong result file path entry in its context.
-	req = context.WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), "file")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 3: sends a request with a correct result file path entry in its context.
-	path, _ := filepath.Abs("../_tests/file.pdf")
-	req = context.WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), path)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}

app/http/http.go

@@ -1,49 +0,0 @@
-// Package http provides functions for detecting a request content type.
-package http
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-)
-
-// ContentType is a string which represents a content type.
-type ContentType string
-
-// MultipartFormDataContentType represents... the multipart form data content type.
-const MultipartFormDataContentType ContentType = "multipart/form-data"
-
-type notAuthorizedContentTypeError struct{}
-
-const notAuthorizedContentTypeErrorMessage = "accepted value for 'Content-Type': %s"
-
-func (e *notAuthorizedContentTypeError) Error() string {
-	return fmt.Sprintf(notAuthorizedContentTypeErrorMessage, MultipartFormDataContentType)
-}
-
-// CheckAuthorizedContentType checks if the request header header has an authorized content type.
-// If no authorized content type found, throws an error.
-func CheckAuthorizedContentType(h http.Header) error {
-	ct := findContentType(h.Get("Content-Type"), MultipartFormDataContentType)
-	if ct == "" {
-		return &notAuthorizedContentTypeError{}
-	}
-
-	return nil
-}
-
-// findContentType parses a string representing a content type and tries to find
-// one of the given content types.
-func findContentType(requestContentType string, contentTypes ...ContentType) ContentType {
-	for _, ct := range contentTypes {
-		if i := strings.IndexRune(requestContentType, ';'); i != -1 {
-			requestContentType = requestContentType[0:i]
-		}
-
-		if requestContentType == string(ct) {
-			return ct
-		}
-	}
-
-	return ""
-}

app/http/http_test.go

@@ -1,39 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestCheckAuthorizedContentType(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a content type entry in its header.
-	if err := CheckAuthorizedContentType(req.Header); err == nil {
-		t.Error("Function should not have been able to retrieve an authorized content type from request's header")
-	}
-
-	// case 2: uses a request with a content type entry in its header.
-	req.Header.Set("Content-Type", string(MultipartFormDataContentType))
-	if err := CheckAuthorizedContentType(req.Header); err != nil {
-		t.Error("Function should have been able to retrieve an authorized content type from request's header")
-	}
-
-	// case 3: uses a request with a composed content type entry in its header.
-	req.Header.Set("Content-Type", "multipart/form-data; boundary=—-WebKitFormBoundary7MA4YWxkTrZu0gW")
-	if err := CheckAuthorizedContentType(req.Header); err != nil {
-		t.Error("Function should have been able to retrieve an authorized content type from request's header")
-	}
-
-}
-
-func TestNotAuthorizedContentTypeError(t *testing.T) {
-	err := &notAuthorizedContentTypeError{}
-	expected := fmt.Sprintf(notAuthorizedContentTypeErrorMessage, MultipartFormDataContentType)
-
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}

app/logger/logger.go

@@ -1,81 +0,0 @@
-// Package logger implements a simple wrapper of the logrus library.
-package logger
-
-import (
-	"os"
-
-	"github.com/sirupsen/logrus"
-)
-
-// logger wraps a logrus.Logger instance.
-type logger struct {
-	logger *logrus.Logger
-}
-
-// log is our logger instance used across the application.
-var log = newLogger()
-
-// newLogger instantiates a logger instance with default values.
-func newLogger() *logger {
-	l := &logger{logrus.New()}
-	l.logger.Out = os.Stdout
-	l.logger.Level = logrus.InfoLevel
-
-	return l
-}
-
-// SetLevel updates the level of messages which will be logged.
-func SetLevel(level logrus.Level) {
-	log.logger.SetLevel(level)
-}
-
-// SetFormatter updates the output format.
-// When a TTY is not attached, the output will be in the defined format.
-func SetFormatter(formatter logrus.Formatter) {
-	log.logger.Formatter = formatter
-}
-
-// Debug is a wrapper of the logrus Debug function.
-func Debug(message string) {
-	log.logger.Debug(message)
-}
-
-// Debugf is a wrapper of the logrus Debugf function.
-func Debugf(format string, args ...interface{}) {
-	log.logger.Debugf(format, args...)
-}
-
-// Info is a wrapper of the logrus Info function.
-func Info(message string) {
-	log.logger.Info(message)
-}
-
-// Infof is a wrapper of the logrus Infof function.
-func Infof(format string, args ...interface{}) {
-	log.logger.Infof(format, args...)
-}
-
-// Warn is a wrapper of the logrus Warn function.
-func Warn(message string) {
-	log.logger.Warn(message)
-}
-
-// Warnf is wrapper of the logrus Warnf function.
-func Warnf(format string, args ...interface{}) {
-	log.logger.Warnf(format, args...)
-}
-
-// Error is a wrapper of the logrus Error function.
-func Error(err error) {
-	log.logger.Error(err.Error())
-}
-
-// Fatal is a wrapper of the logrus Fatal function.
-func Fatal(err error) {
-	log.logger.Fatal(err.Error())
-}
-
-// Panic is a wrapper of the logrus Panic function.
-func Panic(err error) {
-	log.logger.Panic(err.Error())
-}

build/Dockerfile

@@ -0,0 +1,157 @@
+# Note: ARG instructions do not create additional layers.
+# Instead, next layers will concatenate them.
+ARG GOLANG_VERSION
+# Note: we have to repeat ARG instructions in each build stage that uses them.
+ARG GOTENBERG_VERSION
+
+FROM golang:$GOLANG_VERSION AS builder
+
+ENV CGO_ENABLED 0
+
+# Define the working directory outside of $GOPATH (we're using go modules).
+WORKDIR /home
+
+# Install module dependencies.
+COPY go.mod go.sum ./
+
+RUN go mod download &&\
+    go mod verify
+
+# Copy the source code.
+COPY cmd ./cmd
+COPY pkg ./pkg
+
+# Build the binary.
+ARG GOTENBERG_VERSION
+
+RUN go build -o gotenberg -ldflags "-X 'github.com/gotenberg/gotenberg/v7/cmd.Version=$GOTENBERG_VERSION'" cmd/gotenberg/main.go
+
+FROM debian:bullseye-slim
+
+ARG GOTENBERG_VERSION
+
+LABEL author="Julien Neuhart" \
+      description="A Docker-powered stateless API for PDF files." \
+      github="https://github.com/gotenberg/gotenberg" \
+      version="$GOTENBERG_VERSION" \
+      website="https://gotenberg.dev"
+
+# Improve fonts subpixel hinting and smoothing.
+# Credits:
+# https://github.com/arachnys/athenapdf/issues/69.
+# https://github.com/arachnys/athenapdf/commit/ba25a8d80a25d08d58865519c4cd8756dc9a336d.
+COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
+
+# Simple wrapper around Java and PDFtk.
+COPY build/pdftk.sh /usr/bin/pdftk
+
+# Setup the Docker image.
+ARG GOTENBERG_USER_GID
+ARG GOTENBERG_USER_UID
+ARG PDFTK_VERSION
+
+# Script for installing either Google Chrome stable on amd64 architecture or
+# Chromium on arm64 architecture.
+# See https://github.com/gotenberg/gotenberg/issues/328.
+COPY build/install-chromium.sh /tmp/install-chromium.sh
+
+RUN \
+    # Create a non-root user.
+    # All processes in the Docker container will run with this dedicated user.
+    groupadd --gid "$GOTENBERG_USER_GID" gotenberg &&\
+    useradd --uid "$GOTENBERG_USER_UID" --gid gotenberg --shell /bin/bash --home /home/gotenberg --no-create-home gotenberg &&\
+    mkdir /home/gotenberg &&\
+    chown gotenberg: /home/gotenberg &&\
+    # Install dependencies required for the next instructions or debugging.
+    # Note: procps for "top" command (useful when debugging processes).
+    # Note: tini is a helper for reaping zombie processes.
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends curl gnupg procps tini python3 default-jre-headless &&\
+    # Install fonts.
+    # Credits:
+    # https://github.com/arachnys/athenapdf/blob/master/cli/Dockerfile.
+    # https://help.accusoft.com/PrizmDoc/v12.1/HTML/Installing_Asian_Fonts_on_Ubuntu_and_Debian.html.
+    curl -o ./ttf-mscorefonts-installer_3.8_all.deb http://httpredir.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.8_all.deb &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
+    ./ttf-mscorefonts-installer_3.8_all.deb \
+    culmus \
+    fonts-beng \
+    fonts-hosny-amiri \
+    fonts-lklug-sinhala \
+    fonts-lohit-guru \
+    fonts-lohit-knda \
+    fonts-samyak-gujr \
+    fonts-samyak-mlym \
+    fonts-samyak-taml \
+    fonts-sarai \
+    fonts-sil-abyssinica \
+    fonts-sil-padauk \
+    fonts-telu \
+    fonts-thai-tlwg \
+    ttf-wqy-zenhei \
+    fonts-arphic-ukai \
+    fonts-arphic-uming \
+    fonts-ipafont-mincho \
+    fonts-ipafont-gothic \
+    fonts-unfonts-core \
+    # LibreOffice recommends.
+    fonts-crosextra-caladea \
+    fonts-crosextra-carlito \
+    fonts-dejavu \
+    fonts-dejavu-extra \
+    fonts-liberation \
+    fonts-liberation2 \
+    fonts-linuxlibertine \
+    fonts-noto-core \
+    fonts-noto-mono \
+    fonts-noto-ui-core \
+    fonts-sil-gentium \
+    fonts-sil-gentium-basic &&\
+    rm -f ./ttf-mscorefonts-installer_3.8_all.deb &&\
+    # Install Google Chrome / Chromium.
+    /tmp/install-chromium.sh &&\
+    # Install LibreOffice.
+    # Note: we use the sid distribution to get the latest LibreOffice version.
+    # See https://github.com/gotenberg/gotenberg/pull/322.
+    echo "deb https://httpredir.debian.org/debian/ sid main contrib non-free" >> /etc/apt/sources.list &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends -t sid libreoffice &&\
+    # Download unoconv (Python script).
+    curl -Ls https://raw.githubusercontent.com/dagwieers/unoconv/master/unoconv -o /usr/bin/unoconv &&\
+    chmod +x /usr/bin/unoconv &&\
+    # unoconv will look for the Python binary, which has to be at version 3.
+    ln -s /usr/bin/python3 /usr/bin/python &&\
+    # Download PDFtk.
+    # See https://github.com/gotenberg/gotenberg/pull/273.
+    curl -o /usr/bin/pdftk-all.jar "https://gitlab.com/pdftk-java/pdftk/-/jobs/$PDFTK_VERSION/artifacts/raw/build/libs/pdftk-all.jar" &&\
+    chmod a+x /usr/bin/pdftk-all.jar &&\
+    # See https://github.com/nextcloud/docker/issues/380.
+    mkdir -p /usr/share/man/man1mkdir -p /usr/share/man/man1 &&\
+    # Cleanup.
+    # Note: the Debian image does automatically a clean after each install thanks to a hook.
+    # Therefore, there is no need for apt-get clean.
+    # See https://stackoverflow.com/a/24417119/3248473.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* &&\
+    # Print versions of main dependencies.
+    chromium --version &&\
+    libreoffice --version &&\
+    unoconv --version &&\
+    pdftk --version
+
+# Copy the Gotenberg binary from the builder stage.
+COPY --from=builder /home/gotenberg /usr/bin/
+
+# Environment variables required by modules or else.
+ENV GC_EXCLUDE_SUBSTR "hsperfdata_root,hsperfdata_gotenberg"
+ENV CHROMIUM_BIN_PATH /usr/bin/chromium
+ENV UNOCONV_BIN_PATH /usr/bin/unoconv
+ENV PDFTK_BIN_PATH /usr/bin/pdftk
+
+USER gotenberg
+WORKDIR /home/gotenberg
+
+# Default API port.
+EXPOSE 3000
+
+ENTRYPOINT [ "/usr/bin/tini", "--" ]
+CMD [ "gotenberg" ]

build/Dockerfile.cloudrun

@@ -0,0 +1,15 @@
+# Note: ARG instructions do not create additional layers.
+# Instead, next layers will concatenate them.
+ARG DOCKER_REPOSITORY
+ARG GOTENBERG_VERSION
+
+FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION
+
+USER root
+
+# For security reasons, the non-root user gotenberg does not own the Tini binary by default.
+# However, some providers like Cloud Run from Google Cloud cannot start a Docker container in that case.
+# See https://github.com/gotenberg/gotenberg/issues/90#issuecomment-543551353.
+RUN chown gotenberg: /usr/bin/tini
+
+USER gotenberg

build/fonts.conf

@@ -0,0 +1,29 @@
+<?xml version='1.0'?>
+<!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
+<fontconfig>
+ <match target="font">
+  <edit mode="assign" name="rgba">
+   <const>rgb</const>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="hinting">
+   <bool>true</bool>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="hintstyle">
+   <const>hintslight</const>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="antialias">
+   <bool>true</bool>
+  </edit>
+ </match>
+  <match target="font">
+    <edit mode="assign" name="lcdfilter">
+      <const>lcddefault</const>
+    </edit>
+  </match>
+</fontconfig>

build/install-chromium.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+set -e
+
+ARCH=$(dpkg --print-architecture)
+
+if [[ "$ARCH" == "amd64" ]]; then
+  curl https://dl.google.com/linux/linux_signing_key.pub | apt-key add -
+  echo "deb http://dl.google.com/linux/chrome/deb/ stable main" | tee /etc/apt/sources.list.d/google-chrome.list
+  apt-get update -qq
+  DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends --allow-unauthenticated google-chrome-stable
+  mv /usr/bin/google-chrome-stable /usr/bin/chromium
+else
+  DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends chromium
+fi

build/pdftk.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exec java -jar /usr/bin/pdftk-all.jar "$@"

cmd/gotenberg.go

@@ -0,0 +1,119 @@
+package gotenbergcmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	flag "github.com/spf13/pflag"
+)
+
+// See https://patorjk.com/software/taag/#p=display&f=Small%20Slant&t=Gotenberg.
+// Credits: https://github.com/labstack/echo/blob/v4.3.0/echo.go#L240.
+const banner = `
+  _____     __           __               
+ / ___/__  / /____ ___  / /  ___ _______ _
+/ (_ / _ \/ __/ -_) _ \/ _ \/ -_) __/ _ '/
+\___/\___/\__/\__/_//_/_.__/\__/_/  \_, / 
+                                   /___/
+
+A Docker-powered stateless API for PDF files.
+Version: %s
+-------------------------------------------------------
+`
+
+// Version is the... version of the Gotenberg application. We set it at the
+// build stage of the Docker image.
+var Version = "snapshot"
+
+// Run starts the Gotenberg application. Call this in the main of your program.
+func Run() {
+	fmt.Printf(banner, Version)
+
+	// Creates the roo` FlagSet and adds the modules flags to it.
+	fs := flag.NewFlagSet("gotenberg", flag.ExitOnError)
+	fs.Duration("gotenberg-graceful-shutdown-duration", time.Duration(30)*time.Second, "Set the graceful shutdown duration")
+
+	descriptors := gotenberg.GetModuleDescriptors()
+	var modsInfo string
+	for _, desc := range descriptors {
+		fs.AddFlagSet(desc.FlagSet)
+		modsInfo += desc.ID + " "
+	}
+
+	fmt.Printf("[SYSTEM] modules: %s\n", modsInfo)
+
+	// Parses the flags...
+	err := fs.Parse(os.Args[1:])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// ...and creates a wrapper around those.
+	parsedFlags := gotenberg.ParsedFlags{FlagSet: fs}
+
+	// Get the graceful shutdown duration.
+	gracefulShutdownDuration := parsedFlags.MustDuration("gotenberg-graceful-shutdown-duration")
+
+	ctx := gotenberg.NewContext(parsedFlags, descriptors)
+
+	// Starts application modules.
+	apps, err := ctx.Modules(new(gotenberg.App))
+	if err != nil {
+		fmt.Printf("[FATAL] %s\n", err)
+		os.Exit(1)
+	}
+
+	for _, a := range apps {
+		go func(app gotenberg.App) {
+			id := app.(gotenberg.Module).Descriptor().ID
+			err = app.Start()
+
+			if err != nil {
+				fmt.Printf("[FATAL] starting %s: %s\n", id, err)
+				os.Exit(1)
+			}
+
+			startupMessage := app.StartupMessage()
+			if startupMessage == "" {
+				fmt.Printf("[SYSTEM] %s: application started\n", id)
+
+				return
+			}
+
+			fmt.Printf("[SYSTEM] %s: %s\n", id, startupMessage)
+		}(a.(gotenberg.App))
+
+	}
+
+	quit := make(chan os.Signal, 1)
+
+	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C).
+	signal.Notify(quit, os.Interrupt)
+
+	// Block until we receive our signal.
+	<-quit
+
+	gracefulShutdownCtx, cancel := context.WithTimeout(context.Background(), gracefulShutdownDuration)
+	defer cancel()
+
+	fmt.Printf("[SYSTEM] graceful shutdown of %s\n", gracefulShutdownDuration)
+
+	for _, a := range apps {
+		id := a.(gotenberg.Module).Descriptor().ID
+		app := a.(gotenberg.App)
+
+		err = app.Stop(gracefulShutdownCtx)
+		if err != nil {
+			fmt.Printf("[ERROR] stopping %s: %s\n", id, err)
+		}
+
+		fmt.Printf("[SYSTEM] %s: application stopped\n", id)
+	}
+
+	os.Exit(0)
+}

cmd/gotenberg/main.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	gotenbergcmd "github.com/gotenberg/gotenberg/v7/cmd"
+
+	// Gotenberg modules.
+	_ "github.com/gotenberg/gotenberg/v7/pkg/standard"
+)
+
+func main() {
+	gotenbergcmd.Run()
+}

go.mod

@@ -0,0 +1,58 @@
+module github.com/gotenberg/gotenberg/v7
+
+go 1.17
+
+require (
+	github.com/alexliesenfeld/health v0.6.0
+	github.com/andybalholm/brotli v1.0.3 // indirect
+	github.com/chromedp/cdproto v0.0.0-20210823203301-2c0adcc9edc4
+	github.com/chromedp/chromedp v0.7.4
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/uuid v1.3.0
+	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.0
+	github.com/klauspost/compress v1.13.4 // indirect
+	github.com/klauspost/pgzip v1.2.5 // indirect
+	github.com/labstack/echo/v4 v4.5.0
+	github.com/labstack/gommon v0.3.0
+	github.com/mattn/go-isatty v0.0.13 // indirect
+	github.com/mholt/archiver/v3 v3.5.0
+	github.com/microcosm-cc/bluemonday v1.0.15
+	github.com/nwaples/rardecode v1.1.2 // indirect
+	github.com/pdfcpu/pdfcpu v0.3.12
+	github.com/pierrec/lz4/v4 v4.1.8 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0
+	github.com/spf13/pflag v1.0.5
+	github.com/ulikunitz/xz v0.5.10 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.7.0
+	go.uber.org/zap v1.19.0
+	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect
+	golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
+	golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 // indirect
+	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b
+	golang.org/x/text v0.3.7
+	golang.org/x/tools v0.1.5 // indirect
+)
+
+require (
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/dsnet/compress v0.0.1 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.1.0 // indirect
+	github.com/gorilla/css v1.0.0 // indirect
+	github.com/hhrutter/lzw v0.0.0-20190829144645-6f07a24e8650 // indirect
+	github.com/hhrutter/tiff v0.0.0-20190829141212-736cae8d0bc7 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.8 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.1 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+)

go.sum

@@ -0,0 +1,198 @@
+github.com/alexliesenfeld/health v0.6.0 h1:HRBTCgybNSe4lqGEk7nU82c3bjwh9W+3b46W6UvD4CQ=
+github.com/alexliesenfeld/health v0.6.0/go.mod h1:N4NDIeQtlWumG+6z1ne1v62eQxktz5ylEgGgH9emdMw=
+github.com/andybalholm/brotli v1.0.0/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
+github.com/andybalholm/brotli v1.0.3 h1:fpcw+r1N1h0Poc1F/pHbW40cUm/lMEQslZtCkBQ0UnM=
+github.com/andybalholm/brotli v1.0.3/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
+github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
+github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/chromedp/cdproto v0.0.0-20210713064928-7d28b402946a/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
+github.com/chromedp/cdproto v0.0.0-20210823203301-2c0adcc9edc4 h1:cD7F5LfNjC4dtb+BQe1KxxE8RsceYtS+Kyo+yEs4iUc=
+github.com/chromedp/cdproto v0.0.0-20210823203301-2c0adcc9edc4/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
+github.com/chromedp/chromedp v0.7.4 h1:U+0d3WbB/Oj4mDuBOI0P7S3PJEued5UZIl5AJ3QulwU=
+github.com/chromedp/chromedp v0.7.4/go.mod h1:dBj+SXuQHznp6ZPwZeDDEBZKwclUwDLbZ0hjMialMYs=
+github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
+github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dsnet/compress v0.0.1 h1:PlZu0n3Tuv04TzpfPbrnI0HW/YwodEXDS+oPKahKF0Q=
+github.com/dsnet/compress v0.0.1/go.mod h1:Aw8dCMJ7RioblQeTqt88akK31OvO8Dhf5JflhBbQEHo=
+github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
+github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
+github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
+github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
+github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI=
+github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
+github.com/hashicorp/go-retryablehttp v0.7.0 h1:eu1EI/mbirUgP5C8hVsTNaGZreBDlYiwC1FZWkvQPQ4=
+github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
+github.com/hhrutter/lzw v0.0.0-20190827003112-58b82c5a41cc/go.mod h1:yJBvOcu1wLQ9q9XZmfiPfur+3dQJuIhYQsMGLYcItZk=
+github.com/hhrutter/lzw v0.0.0-20190829144645-6f07a24e8650 h1:1yY/RQWNSBjJe2GDCIYoLmpWVidrooriUr4QS/zaATQ=
+github.com/hhrutter/lzw v0.0.0-20190829144645-6f07a24e8650/go.mod h1:yJBvOcu1wLQ9q9XZmfiPfur+3dQJuIhYQsMGLYcItZk=
+github.com/hhrutter/tiff v0.0.0-20190829141212-736cae8d0bc7 h1:o1wMw7uTNyA58IlEdDpxIrtFHTgnvYzA8sCQz8luv94=
+github.com/hhrutter/tiff v0.0.0-20190829141212-736cae8d0bc7/go.mod h1:WkUxfS2JUu3qPo6tRld7ISb8HiC0gVSU91kooBMDVok=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.10.10/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.13.4 h1:0zhec2I8zGnjWcKyLl6i3gPqKANCCn5e9xmviEEeX6s=
+github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
+github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/pgzip v1.2.4/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/klauspost/pgzip v1.2.5 h1:qnWYvvKqedOF2ulHpMG72XQol4ILEJ8k2wwRl/Km8oE=
+github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/labstack/echo/v4 v4.5.0 h1:JXk6H5PAw9I3GwizqUHhYyS4f45iyGebR/c1xNCeOCY=
+github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
+github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
+github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mholt/archiver/v3 v3.5.0 h1:nE8gZIrw66cu4osS/U7UW7YDuGMHssxKutU8IfWxwWE=
+github.com/mholt/archiver/v3 v3.5.0/go.mod h1:qqTTPUK/HZPFgFQ/TJ3BzvTpF/dPtFVJXdQbCmeMxwc=
+github.com/microcosm-cc/bluemonday v1.0.15 h1:J4uN+qPng9rvkBZBoBb8YGR+ijuklIMpSOZZLjYpbeY=
+github.com/microcosm-cc/bluemonday v1.0.15/go.mod h1:ZLvAzeakRwrGnzQEvstVzVt3ZpqOF2+sdFr0Om+ce30=
+github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
+github.com/nwaples/rardecode v1.1.2 h1:Cj0yZY6T1Zx1R7AhTbyGSALm44/Mmq+BAPc4B/p/d3M=
+github.com/nwaples/rardecode v1.1.2/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
+github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5 h1:1SoBaSPudixRecmlHXb/GxmaD3fLMtHIDN13QujwQuc=
+github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
+github.com/pdfcpu/pdfcpu v0.3.12 h1:B+MdKisilWNSk5OCO58Z9U6H93usH73xqk6hMOaZCls=
+github.com/pdfcpu/pdfcpu v0.3.12/go.mod h1:8XVBtVxuuIuSZL4Ez15Q4QoC+H8zeAaGnuiOEwAk8jA=
+github.com/pierrec/lz4/v4 v4.0.3/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.8 h1:ieHkV+i2BRzngO4Wd/3HGowuZStgq6QkPsD1eolNAO4=
+github.com/pierrec/lz4/v4 v4.1.8/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/ulikunitz/xz v0.5.6/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
+github.com/ulikunitz/xz v0.5.7/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
+github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/valyala/fasttemplate v1.2.1 h1:TVEnxayobAdVkhQfrfes2IzOB6o+z4roRkPF52WA1u4=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
+github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0=
+go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.7.0 h1:zaiO/rmgFjbmCXdSYJWQcdvOCsthmdaHfr3Gm2Kx4Ec=
+go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
+go.uber.org/zap v1.19.0 h1:mZQZefskPPCMIBCSEH0v2/iUqqLrYtaeqwD6FUGUnFE=
+go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/image v0.0.0-20190823064033-3a9bac650e44/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
+golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d h1:LO7XpTYMwTqxjLcGWPijK3vRXg1aWdlNOVOHRq45d7c=
+golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 h1:rw6UNGRMfarCepjI8qOepea/SXwIBVfTKjztZ5gBbq4=
+golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
+golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,89 +0,0 @@
-/*
-Package main handles the application startup and shutdown.
-
-Gotenberg is a stateless API for converting Markdown files, HTML files and Office documents to PDF.
-
-For more information, go to https://github.com/thecodingmachine/gotenberg.
-*/
-package main
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/thecodingmachine/gotenberg/app"
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/gorilla/mux"
-	"github.com/sirupsen/logrus"
-)
-
-// version will be set on build time.
-var version = "master"
-
-// defaultConfigurationFilePath is our default configuration file to parse.
-const defaultConfigurationFilePath = "gotenberg.yml"
-
-// main initializes the application, starts it, and handles
-// graceful shutdown.
-func main() {
-	err := config.ParseFile(defaultConfigurationFilePath)
-	if err != nil {
-		logger.SetLevel(logrus.InfoLevel)
-		logger.Fatal(err)
-		os.Exit(1)
-	}
-
-	// defines our application logging.
-	logger.SetLevel(config.GetLogsLevel())
-	logger.SetFormatter(config.GetLogsFormatter())
-
-	// defines our application router.
-	r := mux.NewRouter()
-	r.Handle("/", app.GetHandlersChain()).Methods(http.MethodPost)
-
-	// defines our server.
-	s := &http.Server{
-		Addr:    fmt.Sprintf(":%s", config.GetPort()),
-		Handler: r,
-	}
-
-	logger.Debugf("configuration loaded from file %s", defaultConfigurationFilePath)
-	logger.Infof("starting Gotenberg version %s", version)
-	logger.Infof("listening on port %s", config.GetPort())
-
-	// runs our server in a goroutine so that it doesn't block.
-	go func() {
-		if err = s.ListenAndServe(); err != nil {
-			logger.SetLevel(logrus.InfoLevel)
-			logger.Panic(err)
-			os.Exit(1)
-		}
-	}()
-
-	quit := make(chan os.Signal, 1)
-	// we'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
-	// SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
-	signal.Notify(quit, os.Interrupt)
-
-	// blocks until we receive our signal.
-	<-quit
-
-	// creates a deadline to wait for.
-	var wait time.Duration
-	ctx, cancel := context.WithTimeout(context.Background(), wait)
-	defer cancel()
-
-	// doesn't block if no connections, but will otherwise wait
-	// until the timeout deadline.
-	s.Shutdown(ctx)
-
-	logger.SetLevel(logrus.InfoLevel)
-	logger.Info("bye!")
-	os.Exit(0)
-}

orbit-payload.yml

@@ -1,4 +0,0 @@
-payload:
-
-  - key: Version
-    value: snapshot

orbit.yml

@@ -1,28 +0,0 @@
-tasks:
-  
-  - use: fmt
-    short: Runs go fmt ./...
-    run:
-      - go fmt ./...
-
-  - use: generate
-    short: Generates all files from blueprints
-    run:
-      - orbit generate -f .blueprints/Dockerfile.blueprint -o Dockerfile.ci -p "Image,CI"
-      - orbit generate -f .blueprints/Dockerfile.blueprint -o Dockerfile -p "Image,MAIN"
-
-  - use: ci
-    short: Runs CI process inside a container
-    run:
-      - docker build -t thecodingmachine/gotenberg:ci -f Dockerfile.ci .
-      - docker run --rm -e "VERSION={{ .Orbit.Version }}" -v "$(pwd)/.ci:/go/src/github.com/thecodingmachine/gotenberg/.ci" thecodingmachine/gotenberg:ci
-
-  - use: build
-    short: Builds the main Docker image
-    run:
-      - docker build . -t thecodingmachine/gotenberg:{{ .Orbit.Version }}
-
-  - use: up
-    short: Starts the {{ .Orbit.Version }} version of the Gotenberg image
-    run:
-      - docker run --rm -p 3000:3000/tcp thecodingmachine/gotenberg:{{ .Orbit.Version }}

pkg/gotenberg/cmd.go

@@ -0,0 +1,187 @@
+package gotenberg
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	"go.uber.org/zap"
+)
+
+// Cmd wraps an exec.Cmd.
+type Cmd struct {
+	ctx     context.Context
+	logger  *zap.Logger
+	process *exec.Cmd
+}
+
+// Command creates a Cmd without a context. It configures the internal
+// exec.Cmd of Cmd so that we may kill its unix process and all its children
+// without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func Command(logger *zap.Logger, binPath string, args ...string) Cmd {
+	cmd := exec.Command(binPath, args...)
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	return Cmd{
+		ctx:     nil,
+		logger:  logger.Named("cmd"),
+		process: cmd,
+	}
+}
+
+// CommandContext creates a Cmd with a context. It configures the internal
+// exec.Cmd of Cmd so that we may kill its unix process and all its children
+// without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func CommandContext(ctx context.Context, logger *zap.Logger, binPath string, args ...string) (Cmd, error) {
+	if ctx == nil {
+		return Cmd{}, errors.New("nil context")
+	}
+
+	cmd := exec.CommandContext(ctx, binPath, args...)
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	return Cmd{
+		ctx:     ctx,
+		logger:  logger.Named("cmd"),
+		process: cmd,
+	}, nil
+}
+
+// Start starts the command but does not wait for its completion.
+func (cmd Cmd) Start() error {
+	err := cmd.pipeOutput()
+	if err != nil {
+		return fmt.Errorf("pipe unix process output: %w", err)
+	}
+
+	cmd.logger.Debug(fmt.Sprintf("start unix process: %s", strings.Join(cmd.process.Args, " ")))
+
+	err = cmd.process.Start()
+	if err != nil {
+		return fmt.Errorf("start unix process: %w", err)
+	}
+
+	return nil
+}
+
+// Exec executes the command and wait for its completion or until the context
+// is done. In any case, it kills the unix process and all its children.
+func (cmd Cmd) Exec() error {
+	if cmd.ctx == nil {
+		return errors.New("nil context")
+	}
+
+	err := cmd.Start()
+	if err != nil {
+		return fmt.Errorf("start command: %w", err)
+	}
+
+	errChan := make(chan error, 1)
+
+	go func() {
+		errChan <- cmd.process.Wait()
+	}()
+
+	select {
+	case err = <-errChan:
+		errProc := cmd.Kill()
+		if errProc != nil {
+			cmd.logger.Error(errProc.Error())
+		}
+
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("unix process error: %w", err)
+	case <-cmd.ctx.Done():
+		errProc := cmd.Kill()
+		if errProc != nil {
+			cmd.logger.Error(errProc.Error())
+		}
+
+		return fmt.Errorf("context done: %w", cmd.ctx.Err())
+	}
+}
+
+// pipeOutput creates logs entries according to the process stdout and stderr.
+// It does nothing if the logging level is not debug.
+func (cmd Cmd) pipeOutput() error {
+	checkedEntry := cmd.logger.Check(zap.DebugLevel, "check for debug level before piping unix process output")
+	if checkedEntry == nil {
+		return nil
+	}
+
+	stdout, err := cmd.process.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("pipe unix process stdout: %w", err)
+	}
+
+	stderr, err := cmd.process.StderrPipe()
+	if err != nil {
+		return fmt.Errorf("unix process sdterr: %w", err)
+	}
+
+	// logCommandOutput creates logs entries according to a reader
+	// (either stdout or stderr).
+	logCommandOutput := func(logger *zap.Logger, reader io.ReadCloser) {
+		r := bufio.NewReader(reader)
+		defer reader.Close()
+
+		for {
+			line, _, err := r.ReadLine()
+
+			if err != nil {
+				if err != io.EOF && !strings.Contains(err.Error(), "file already closed") {
+					logger.Error(fmt.Sprintf("pipe unix process output error: %s", err))
+				}
+
+				break
+			}
+
+			if len(line) != 0 {
+				logger.Debug(string(line))
+			}
+		}
+	}
+
+	go logCommandOutput(cmd.logger.Named("stdout"), stdout)
+	go logCommandOutput(cmd.logger.Named("stderr"), stderr)
+
+	return nil
+}
+
+// Kill kills the unix process and all its children without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func (cmd Cmd) Kill() error {
+	if cmd.process == nil {
+		// We cannot use the logger here, because for whatever reason using it
+		// result to a panic.
+		// cmd.logger.Debug("no process, skip killing")
+		return nil
+	}
+
+	err := syscall.Kill(-cmd.process.Process.Pid, syscall.SIGKILL)
+	if err == nil {
+		cmd.logger.Debug("unix process killed")
+		return nil
+	}
+
+	// If the process does not exist anymore, the error is irrelevant.
+	if strings.Contains(err.Error(), "no such process") {
+		cmd.logger.Debug("unix process already killed")
+		return nil
+	}
+
+	return fmt.Errorf("kill unix process: %w", err)
+}

pkg/gotenberg/cmd_test.go

@@ -0,0 +1,220 @@
+package gotenberg
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+func TestCommand(t *testing.T) {
+	cmd := Command(zap.NewNop(), "foo")
+
+	if !cmd.process.SysProcAttr.Setpgid {
+		t.Error("expected Setpgid to be true")
+	}
+}
+
+func TestCommandContext(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       context.Context
+		expectErr bool
+	}{
+		{
+			ctx:       nil,
+			expectErr: true,
+		},
+		{
+			ctx: context.TODO(),
+		},
+	} {
+		cmd, err := CommandContext(tc.ctx, zap.NewNop(), "foo")
+
+		if err == nil && !cmd.process.SysProcAttr.Setpgid {
+			t.Fatalf("test %d: expected Setpgid to be true", i)
+		}
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestCmd_Start(t *testing.T) {
+	for i, tc := range []struct {
+		cmd       Cmd
+		expectErr bool
+	}{
+		{
+			cmd:       Command(zap.NewNop(), "foo"),
+			expectErr: true,
+		},
+		{
+			cmd: Command(zap.NewNop(), "echo", "Hello", "World"),
+		},
+	} {
+		err := tc.cmd.Start()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestCmd_Exec(t *testing.T) {
+	for i, tc := range []struct {
+		cmd       Cmd
+		timeout   time.Duration
+		expectErr bool
+	}{
+		{
+			cmd:       Command(zap.NewNop(), "foo"),
+			expectErr: true,
+		},
+		{
+			cmd:       Command(zap.NewNop(), "foo"),
+			timeout:   time.Duration(5) * time.Second,
+			expectErr: true,
+		},
+		{
+			cmd:     Command(zap.NewNop(), "echo", "Hello", "World"),
+			timeout: time.Duration(5) * time.Second,
+		},
+		{
+			cmd:       Command(zap.NewNop(), "sleep", "3"),
+			timeout:   time.Duration(2) * time.Second,
+			expectErr: true,
+		},
+	} {
+		if tc.timeout > 0 {
+			ctx, cancel := context.WithTimeout(context.TODO(), tc.timeout)
+			defer cancel()
+
+			tc.cmd.ctx = ctx
+		}
+
+		err := tc.cmd.Exec()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestCmd_pipeOutput(t *testing.T) {
+	for i, tc := range []struct {
+		cmd       Cmd
+		run       bool
+		expectErr bool
+	}{
+		{
+			cmd: Command(zap.NewNop(), "echo", "Hello", "World"),
+		},
+		{
+			cmd: func() Cmd {
+				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
+				_, err := cmd.process.StdoutPipe()
+
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return cmd
+			}(),
+			expectErr: true,
+		},
+		{
+			cmd: func() Cmd {
+				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
+				_, err := cmd.process.StderrPipe()
+
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return cmd
+			}(),
+			expectErr: true,
+		},
+		{
+			cmd: Command(zap.NewExample(), "echo", "Hello", "World"),
+			run: true,
+		},
+	} {
+		err := tc.cmd.pipeOutput()
+
+		if tc.run {
+			errStart := tc.cmd.process.Start()
+
+			if errStart != nil {
+				t.Fatalf("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)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestCmd_Kill(t *testing.T) {
+	for i, tc := range []struct {
+		cmd       Cmd
+		expectErr bool
+	}{
+		{
+			cmd: Cmd{logger: zap.NewNop()},
+		},
+		{
+			cmd: func() Cmd {
+				cmd := Command(zap.NewNop(), "sleep", "60")
+				err := cmd.process.Start()
+
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return cmd
+			}(),
+		},
+		{
+			cmd: func() Cmd {
+				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
+				err := cmd.process.Run()
+
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return cmd
+			}(),
+		},
+	} {
+		err := tc.cmd.Kill()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}

pkg/gotenberg/context.go

@@ -0,0 +1,125 @@
+package gotenberg
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Context is a struct which helps initializing modules. When provisioning, a
+// module may use the context to get other modules that it needs internally.
+type Context struct {
+	flags           ParsedFlags
+	descriptors     []ModuleDescriptor
+	moduleInstances map[string]interface{}
+}
+
+// NewContext creates a Context.
+// In a module, prefer the Provisioner interface to get a Context.
+func NewContext(
+	flags ParsedFlags,
+	descriptors []ModuleDescriptor,
+) *Context {
+	return &Context{
+		flags:           flags,
+		descriptors:     descriptors,
+		moduleInstances: make(map[string]interface{}),
+	}
+}
+
+// ParsedFlags returns the parsed flags.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		flags := ctx.ParsedFlags()
+//		m.foo = flags.RequiredString("foo")
+//	}
+func (ctx Context) ParsedFlags() ParsedFlags {
+	return ctx.flags
+}
+
+// Module returns a module which satisfies the requested interface.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		mod, _ := ctx.Module(new(ModuleInterface))
+//		real := mod.(ModuleInterface)
+//	}
+//
+// If the module has not yet been initialized, this method
+// initializes it. Otherwise, returns the already initialized instance.
+func (ctx *Context) Module(kind interface{}) (interface{}, error) {
+	mods, err := ctx.Modules(kind)
+
+	if err != nil {
+		return nil, fmt.Errorf("get module: %w", err)
+	}
+
+	if len(mods) != 1 {
+		return nil, fmt.Errorf("expected to have one and only one %s module", kind)
+	}
+
+	return mods[0], nil
+}
+
+// Modules returns the list of modules which satisfies the requested interface.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		mods, _ := ctx.Modules(new(ModuleInterface))
+//		for _, mod := range mods {
+//			real := mod.(ModuleInterface)
+//			// ...
+//		}
+//	}
+//
+// If one or more modules have not yet been initialized, this method
+// initializes them. Otherwise, returns the already initialized instances.
+func (ctx *Context) Modules(kind interface{}) ([]interface{}, error) {
+	realKind := reflect.TypeOf(kind).Elem()
+
+	var mods []interface{}
+
+	for _, desc := range ctx.descriptors {
+		newInstance := desc.New()
+
+		if ok := reflect.TypeOf(newInstance).Implements(realKind); ok {
+			// The module implements the requested interface.
+			// We check if it has already been initialized.
+			instance, ok := ctx.moduleInstances[desc.ID]
+
+			if ok {
+				mods = append(mods, instance)
+			} else {
+				err := ctx.loadModule(desc.ID, newInstance)
+				if err != nil {
+					return nil, err
+				}
+
+				mods = append(mods, newInstance)
+			}
+		}
+	}
+
+	return mods, nil
+}
+
+// loadModule calls the Provision and/or Validate methods of the requested
+// module if it satisfies the Provisioner and/or Validator interfaces.
+func (ctx *Context) loadModule(id string, instance interface{}) error {
+	if prov, ok := instance.(Provisioner); ok {
+		// The instance can be provisioned.
+		err := prov.Provision(ctx)
+		if err != nil {
+			return fmt.Errorf("provision module %s: %w", id, err)
+		}
+	}
+
+	if validator, ok := instance.(Validator); ok {
+		// The instance can be validated.
+		err := validator.Validate()
+		if err != nil {
+			return fmt.Errorf("validate module %s: %w", id, err)
+		}
+	}
+
+	ctx.moduleInstances[id] = instance
+
+	return nil
+}

pkg/gotenberg/context_test.go

@@ -0,0 +1,195 @@
+package gotenberg
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNewContext(t *testing.T) {
+	if NewContext(ParsedFlags{}, nil) == nil {
+		t.Error("expected a non-nil value")
+	}
+}
+
+func TestContext_ParsedFlags(t *testing.T) {
+	ctx := NewContext(ParsedFlags{}, nil)
+
+	actual := ctx.ParsedFlags()
+	expect := ParsedFlags{}
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestContext_Module(t *testing.T) {
+	for i, tc := range []struct {
+		mods      []ModuleDescriptor
+		kind      interface{}
+		expectErr bool
+	}{
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return errors.New("foo") }
+
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:      new(Provisioner),
+			expectErr: true,
+		},
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return nil }
+
+				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
+			}(),
+			kind:      new(Provisioner),
+			expectErr: true,
+		},
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return nil }
+
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind: new(Provisioner),
+		},
+	} {
+
+		ctx := NewContext(ParsedFlags{}, tc.mods)
+		_, err := ctx.Module(tc.kind)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestContext_Modules(t *testing.T) {
+	for i, tc := range []struct {
+		mods      []ModuleDescriptor
+		kind      interface{}
+		expectErr bool
+	}{
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return errors.New("foo") }
+
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:      new(Provisioner),
+			expectErr: true,
+		},
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return nil }
+
+				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
+			}(),
+			kind: new(Provisioner),
+		},
+		{
+			mods: func() []ModuleDescriptor {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return nil }
+
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind: new(Provisioner),
+		},
+	} {
+
+		ctx := NewContext(ParsedFlags{}, tc.mods)
+		_, err := ctx.Modules(tc.kind)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestContext_loadModule(t *testing.T) {
+	for i, tc := range []struct {
+		instance  interface{}
+		expectErr bool
+	}{
+		{
+			instance: func() interface{} {
+				mod := struct{ ProtoProvisioner }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.provision = func(ctx *Context) error { return errors.New("foo") }
+
+				return mod
+			}(),
+			expectErr: true,
+		},
+		{
+			instance: func() interface{} {
+				mod := struct{ ProtoValidator }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.validate = func() error { return errors.New("foo") }
+
+				return mod
+			}(),
+			expectErr: true,
+		},
+		{
+			instance: func() interface{} {
+				mod := struct{ ProtoValidator }{}
+				mod.descriptor = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.validate = func() error { return nil }
+
+				return mod
+			}(),
+		},
+	} {
+
+		ctx := NewContext(ParsedFlags{}, nil)
+		err := ctx.loadModule("foo", tc.instance)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}

pkg/gotenberg/doc.go

@@ -0,0 +1,7 @@
+// Package gotenberg provides most of the logic of the module system.
+//
+// caddyserver/caddy, licensed under the Apache License 2.0, has significantly
+// inspired this module system.
+//
+// More details are available on https://caddyserver.com/.
+package gotenberg

pkg/gotenberg/flags.go

@@ -0,0 +1,109 @@
+package gotenberg
+
+import (
+	"regexp"
+	"time"
+
+	"github.com/labstack/gommon/bytes"
+	flag "github.com/spf13/pflag"
+)
+
+// ParsedFlags wraps a flag.FlagSet so that retrieving the typed values is
+// easier.
+type ParsedFlags struct {
+	*flag.FlagSet
+}
+
+// MustString returns the string value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustString(name string) string {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustStringSlice returns the string slice value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustStringSlice(name string) []string {
+	val, err := f.GetStringSlice(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustBool returns the boolean value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustBool(name string) bool {
+	val, err := f.GetBool(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustInt returns the int value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustInt(name string) int {
+	val, err := f.GetInt(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustFloat64 returns the float value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustFloat64(name string) float64 {
+	val, err := f.GetFloat64(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDuration returns the time.Duration value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDuration(name string) time.Duration {
+	val, err := f.GetDuration(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustHumanReadableBytesString returns the human-readable bytes string of a
+// flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	_, err = bytes.Parse(val)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustRegexp returns the regular expression of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return regexp.MustCompile(val)
+}

pkg/gotenberg/flags_test.go

@@ -0,0 +1,378 @@
+package gotenberg
+
+import (
+	"testing"
+	"time"
+
+	flag "github.com/spf13/pflag"
+)
+
+func TestParsedFlags_MustString(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "", "")
+
+	err := fs.Parse([]string{"--foo=foo"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustString(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustStringSlice(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.StringSlice("foo", make([]string, 0), "")
+
+	err := fs.Parse([]string{"--foo=foo", "--foo=bar", "--foo=baz"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustStringSlice(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustBool(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Bool("foo", false, "")
+
+	err := fs.Parse([]string{"--foo=true"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustBool(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustInt(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Int("foo", 0, "")
+
+	err := fs.Parse([]string{"--foo=1"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustInt(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustFloat64(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Float64("foo", 1.0, "")
+
+	err := fs.Parse([]string{"--foo=2.0"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustFloat64(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustDuration(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Duration("foo", time.Duration(1)*time.Second, "")
+
+	err := fs.Parse([]string{"--foo=2m"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustDuration(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "1MB", "")
+	fs.String("bar", "1MB", "")
+
+	err := fs.Parse([]string{"--foo=1GB", "--bar=foo"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+		{
+			name:        "baz",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustHumanReadableBytesString(tc.name)
+		}()
+	}
+}
+
+func TestParsedFlags_MustRegexp(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "", "")
+	fs.String("bar", "", "")
+
+	err := fs.Parse([]string{"--foo=", "--bar=*"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for i, tc := range []struct {
+		name        string
+		expectPanic bool
+	}{
+		{
+			name: "foo",
+		},
+		{
+			name:        "bar",
+			expectPanic: true,
+		},
+		{
+			name:        "baz",
+			expectPanic: true,
+		},
+	} {
+		func() {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			parsedFlags.MustRegexp(tc.name)
+		}()
+	}
+}

pkg/gotenberg/fs.go

@@ -0,0 +1,33 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/google/uuid"
+)
+
+// TmpPath returns the default directory to use for temporary files and
+// directories. Most if not all files and directories created by the
+// application and its dependencies must be based on this default directory.
+func TmpPath() string {
+	return os.TempDir()
+}
+
+// NewDirPath returns a random absolute path based on the temporary path.
+func NewDirPath() string {
+	return fmt.Sprintf("%s/%s", TmpPath(), uuid.New())
+}
+
+// MkdirAll creates a random directory based on the temporary path and
+// returns its absolute path.
+func MkdirAll() (string, error) {
+	path := NewDirPath()
+
+	err := os.MkdirAll(path, 0755)
+	if err != nil {
+		return "", fmt.Errorf("create directory %s: %w", path, err)
+	}
+
+	return path, nil
+}

pkg/gotenberg/fs_test.go

@@ -0,0 +1,59 @@
+package gotenberg
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestTmpPath(t *testing.T) {
+	osTempDir := os.TempDir()
+	tmpPath := TmpPath()
+
+	if tmpPath != osTempDir {
+		t.Errorf("expected path '%s' but got '%s'", osTempDir, tmpPath)
+	}
+}
+
+func TestNewDirPath(t *testing.T) {
+	newDirPath := NewDirPath()
+	tmpPath := TmpPath()
+
+	if !strings.HasPrefix(newDirPath, tmpPath) {
+		t.Fatalf("expected path '%s' to start with '%s'", newDirPath, tmpPath)
+	}
+
+	newDirPaths := make([]string, 1000)
+	for i := range newDirPaths {
+		newDirPaths[i] = NewDirPath()
+	}
+
+	for i, newDirPath := range newDirPaths {
+		for j, comparison := range newDirPaths {
+			if i == j {
+				continue
+			}
+
+			if newDirPath == comparison {
+				t.Fatalf("expected path '%s' (index %d) to be unique, but found an identical path on index %d", newDirPath, i, j)
+			}
+		}
+	}
+}
+
+func TestMkdirAll(t *testing.T) {
+	path, err := MkdirAll()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	tmpPath := TmpPath()
+	if !strings.HasPrefix(path, tmpPath) {
+		t.Fatalf("expected path '%s' to start with '%s'", path, tmpPath)
+	}
+
+	_, err = os.Stat(path)
+	if os.IsNotExist(err) {
+		t.Errorf("expected path '%s' to exist but got: %v", path, err)
+	}
+}

pkg/gotenberg/logging.go

@@ -0,0 +1,14 @@
+package gotenberg
+
+import "go.uber.org/zap"
+
+// LoggerProvider is a module interface which exposes a method for creating a
+// zap.Logger for other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.LoggerProvider))
+//		logger, _   := provider.(gotenberg.LoggerProvider).Logger(m)
+//	}
+type LoggerProvider interface {
+	Logger(mod Module) (*zap.Logger, error)
+}

pkg/gotenberg/modules.go

@@ -0,0 +1,135 @@
+package gotenberg
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"sync"
+
+	flag "github.com/spf13/pflag"
+)
+
+// Module is a sort of plugin which adds new functionalities to the application
+// or other modules.
+//
+//	type YourModule struct {
+//		property string
+//	}
+//
+//	func (YourModule) Descriptor() gotenberg.ModuleDescriptor {
+//		return gotenberg.ModuleDescriptor{
+//			ID: "your_module",
+//			FlagSet: func() *flag.FlagSet {
+//				fs := flag.NewFlagSet("your_module", flag.ExitOnError)
+//				fs.String("your_module-property", "default value", "flag description")
+//
+//				return fs
+//			}(),
+//			New: func() gotenberg.Module { return new(YourModule) },
+//		}
+//	}
+type Module interface {
+	Descriptor() ModuleDescriptor
+}
+
+// ModuleDescriptor describes your module for the application.
+type ModuleDescriptor struct {
+	// ID is the unique name (snake case) of the module.
+	// Required.
+	ID string
+
+	// FlagSet is the definition of the flags of the module.
+	// Optional.
+	FlagSet *flag.FlagSet
+
+	// New returns a new and empty instance of the module's type.
+	// Required.
+	New func() Module
+}
+
+// Provisioner is a module interface for modules which have to be initialized
+// according to flags, environment variables, the context, etc.
+type Provisioner interface {
+	Provision(*Context) error
+}
+
+// Validator is a module interface for modules which have to be validated after
+// provisioning.
+type Validator interface {
+	Validate() error
+}
+
+// App is a module interface for modules which can be started or stopped by the
+// application.
+type App interface {
+	Start() error
+	// StartupMessage returns a custom message to display on startup. If it
+	// returns an empty string, a default startup message is used instead.
+	StartupMessage() string
+	Stop(ctx context.Context) error
+}
+
+// MustRegisterModule registers a module.
+//
+// To register a module, create an init() method in the module main go file:
+//
+//	func init() {
+//		gotenberg.MustRegisterModule(YourModule{})
+//	}
+//
+// Then, in the main command (github.com/gotenberg/gotenberg/v7/cmd/gotenberg),
+// import the module:
+//
+//	imports (
+//		// Gotenberg modules.
+//		_ "your_module_path"
+//	)
+func MustRegisterModule(mod Module) {
+	desc := mod.Descriptor()
+
+	if desc.ID == "" {
+		panic("module with an empty ID cannot be registered")
+	}
+
+	if desc.New == nil {
+		panic("module New function cannot be nil")
+	}
+
+	if val := desc.New(); val == nil {
+		panic("module New function cannot return a nil instance")
+	}
+
+	descriptorsMu.Lock()
+	defer descriptorsMu.Unlock()
+
+	if _, ok := descriptors[desc.ID]; ok {
+		panic(fmt.Sprintf("module %s is already registered", desc.ID))
+	}
+
+	descriptors[desc.ID] = desc
+}
+
+// GetModuleDescriptors returns the descriptors of all registered modules.
+func GetModuleDescriptors() []ModuleDescriptor {
+	descriptorsMu.RLock()
+	defer descriptorsMu.RUnlock()
+
+	mods := make([]ModuleDescriptor, len(descriptors))
+	i := 0
+
+	for _, desc := range descriptors {
+		mods[i] = desc
+		i++
+	}
+
+	sort.Slice(mods, func(i, j int) bool {
+		return mods[i].ID < mods[j].ID
+	})
+
+	return mods
+}
+
+var (
+	descriptors   = make(map[string]ModuleDescriptor)
+	descriptorsMu sync.RWMutex
+)

pkg/gotenberg/modules_test.go

@@ -0,0 +1,135 @@
+package gotenberg
+
+import (
+	"reflect"
+	"testing"
+)
+
+type ProtoModule struct {
+	descriptor func() ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoProvisioner struct {
+	ProtoModule
+	provision func(ctx *Context) error
+}
+
+func (mod ProtoProvisioner) Provision(ctx *Context) error {
+	return mod.provision(ctx)
+}
+
+type ProtoValidator struct {
+	ProtoModule
+	validate func() error
+}
+
+func (mod ProtoValidator) Validate() error {
+	return mod.validate()
+}
+
+func TestMustRegisterModule(t *testing.T) {
+	descriptorsMu.RLock()
+	descriptors = map[string]ModuleDescriptor{
+		"a": {ID: "a"},
+	}
+	descriptorsMu.RUnlock()
+
+	for i, tc := range []struct {
+		ID          string
+		New         func() Module
+		expectPanic bool
+	}{
+		{
+			ID:          "",
+			New:         func() Module { return new(ProtoModule) },
+			expectPanic: true,
+		},
+		{
+			ID:          "b",
+			New:         nil,
+			expectPanic: true,
+		},
+		{
+			ID:          "b",
+			New:         func() Module { return nil },
+			expectPanic: true,
+		},
+		{
+			ID:          "a",
+			New:         func() Module { return new(ProtoModule) },
+			expectPanic: true,
+		},
+		{
+			ID:  "b",
+			New: func() Module { return new(ProtoModule) },
+		},
+	} {
+		func() {
+			mod := struct{ ProtoModule }{}
+			mod.descriptor = func() ModuleDescriptor { return ModuleDescriptor{ID: tc.ID, New: tc.New} }
+
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Errorf("test %d: expected panic but got none", i)
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("test %d: expected no panic but got: %v", i, r)
+					}
+				}()
+			}
+
+			MustRegisterModule(mod)
+		}()
+	}
+
+	descriptorsMu.RLock()
+	descriptors = make(map[string]ModuleDescriptor)
+	descriptorsMu.RUnlock()
+}
+
+func TestGetModuleDescriptors(t *testing.T) {
+	descriptorsMu.RLock()
+	descriptors = map[string]ModuleDescriptor{
+		"d": {ID: "d"},
+		"c": {ID: "c"},
+		"b": {ID: "b"},
+		"a": {ID: "a"},
+	}
+	descriptorsMu.RUnlock()
+
+	expect := []ModuleDescriptor{
+		{ID: "a"},
+		{ID: "b"},
+		{ID: "c"},
+		{ID: "d"},
+	}
+
+	actual := GetModuleDescriptors()
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+
+	descriptorsMu.RLock()
+	descriptors = make(map[string]ModuleDescriptor)
+	descriptorsMu.RUnlock()
+}
+
+// Interface guards.
+var (
+	_ Module      = (*ProtoModule)(nil)
+	_ Provisioner = (*ProtoProvisioner)(nil)
+	_ Module      = (*ProtoProvisioner)(nil)
+	_ Validator   = (*ProtoValidator)(nil)
+	_ Module      = (*ProtoValidator)(nil)
+)

pkg/gotenberg/pdfengine.go

@@ -0,0 +1,52 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+
+	"go.uber.org/zap"
+)
+
+var (
+	// ErrPDFEngineMethodNotAvailable happens if a PDFEngine method is not
+	// available in the implementation.
+	ErrPDFEngineMethodNotAvailable = errors.New("method not available")
+
+	// ErrPDFFormatNotAvailable happens if a PDFEngine Convert's method does
+	// not handle a specific format.
+	ErrPDFFormatNotAvailable = errors.New("PDF format not available")
+)
+
+const (
+	FormatPDFA1a string = "PDF/A-1a"
+	FormatPDFA1b string = "PDF/A-1b"
+	FormatPDFA2a string = "PDF/A-2a"
+	FormatPDFA2b string = "PDF/A-2b"
+	FormatPDFA2u string = "PDF/A-2u"
+	FormatPDFA3a string = "PDF/A-3a"
+	FormatPDFA3b string = "PDF/A-3b"
+	FormatPDFA3u string = "PDF/A-3u"
+)
+
+// PDFEngine is a module interface which exposes methods for manipulating one
+// or more PDFs. Implementations may abstract powerful tools like PDFtk, or
+// fulfill those methods contracts in Golang directly.
+type PDFEngine interface {
+	// Merge merges the given PDFs into a unique PDF. The pages' order reflects
+	// order of the given files.
+	Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
+
+	// Convert converts the given PDF to a specific PDF format.
+	Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error
+}
+
+// PDFEngineProvider is a module interface which exposes a method for creating a
+// PDFEngine for other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _  := ctx.Module(new(gotenberg.PDFEngineProvider))
+//		pdfengines, _ := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+//	}
+type PDFEngineProvider interface {
+	PDFEngine() (PDFEngine, error)
+}

pkg/modules/api/api.go

@@ -0,0 +1,490 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"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"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(API{})
+}
+
+// API is a module which provides an HTTP server. Other modules may add
+// "multipart/form-data" routes, middlewares or health checks.
+type API struct {
+	port                      int
+	readTimeout               time.Duration
+	processTimeout            time.Duration
+	writeTimeout              time.Duration
+	rootPath                  string
+	traceHeader               string
+	disableHealthCheckLogging bool
+	webhookAllowList          *regexp.Regexp
+	webhookDenyList           *regexp.Regexp
+	webhookErrorAllowList     *regexp.Regexp
+	webhookErrorDenyList      *regexp.Regexp
+	webhookMaxRetry           int
+	webhookRetryMinWait       time.Duration
+	webhookRetryMaxWait       time.Duration
+	disableWebhook            bool
+
+	multipartFormDataRoutes []MultipartFormDataRoute
+	externalMiddlewares     []Middleware
+	healthChecks            []health.CheckerOption
+	logger                  *zap.Logger
+	srv                     *echo.Echo
+}
+
+// MultipartFormDataRouter is a module interface which adds
+// "multipart/form-data" routes to the API.
+type MultipartFormDataRouter interface {
+	Routes() ([]MultipartFormDataRoute, error)
+}
+
+// MultipartFormDataRoute represents a "multipart/form-data" route. All routes
+// uses the HTTP POST method.
+type MultipartFormDataRoute struct {
+	// Path is the sub path of the route. Must start with a slash.
+	// Required.
+	Path string
+
+	// Handler is the function which handles the request.
+	// Required.
+	Handler func(ctx *Context) error
+}
+
+// MiddlewareProvider is a module interface which adds middlewares to the API.
+type MiddlewareProvider interface {
+	Middlewares() ([]Middleware, error)
+}
+
+// MiddlewarePriority is a type which helps to determine the execution order of
+// middlewares provided by the MiddlewareProvider modules.
+type MiddlewarePriority uint32
+
+const (
+	VeryLowPriority MiddlewarePriority = iota
+	LowPriority
+	MediumPriority
+	HighPriority
+	VeryHighPriority
+)
+
+// Middleware is a middleware which can be added to the API's middlewares
+// chain.
+//
+//  middleware := &Middleware{
+//    Handler: func() echo.MiddlewareFunc {
+//      return func(next echo.HandlerFunc) echo.HandlerFunc {
+//        return func(c echo.Context) error {
+//          rootPath := c.Get("rootPath").(string)
+//          healthURI := fmt.Sprintf("%shealth", rootPath)
+//
+//          // Skip the middleware if health check URI.
+//          if c.Request().RequestURI == healthURI {
+//            // Call the next middleware in the chain.
+//            return next(c)
+//          }
+//
+//          // Your middleware process.
+//          // ...
+//
+//          // Call the next middleware in the chain.
+//          return next(c)
+//        }
+//      }
+//    }(),
+//  }
+type Middleware struct {
+	// RunBeforeRouter tells if the middleware should run before the router
+	// process an HTTP request.
+	// Optional.
+	RunBeforeRouter bool
+
+	// Priority tells if the middleware should be positioned high or not in
+	// the middlewares chain.
+	// Default to VeryLowPriority.
+	// Optional.
+	Priority MiddlewarePriority
+
+	// Handler is the function of the middleware.
+	// Required.
+	Handler echo.MiddlewareFunc
+}
+
+// HealthChecker is a module interface which allows adding health checks to the
+// API.
+//
+// See https://github.com/alexliesenfeld/health for more details.
+type HealthChecker interface {
+	Checks() ([]health.CheckerOption, error)
+}
+
+// Descriptor returns an API's module descriptor.
+func (API) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "api",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("api", flag.ExitOnError)
+			fs.Int("api-port", 3000, "Set the port on which the API should listen")
+			fs.String("api-port-from-env", "", "Set the environment variable with the port on which the API should listen - override the default port")
+			fs.Duration("api-read-timeout", time.Duration(30)*time.Second, "Set the maximum duration allowed to read a complete request, including the body")
+			fs.Duration("api-process-timeout", time.Duration(30)*time.Second, "Set the maximum duration allowed to process a request")
+			fs.Duration("api-write-timeout", time.Duration(30)*time.Second, "Set the maximum duration before timing out writes of the response")
+			fs.String("api-root-path", "/", "Set the root path of the API - for service discovery via URL paths")
+			fs.String("api-trace-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
+			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
+			fs.String("api-webhook-allow-list", "", "Set the allowed URLs for the webhook feature using a regular expression")
+			fs.String("api-webhook-deny-list", "", "Set the denied URLs for the webhook feature using a regular expression")
+			fs.String("api-webhook-error-allow-list", "", "Set the allowed URLs in case of an error for the webhook feature using a regular expression")
+			fs.String("api-webhook-error-deny-list", "", "Set the denied URLs in case of an error for the webhook feature using a regular expression")
+			fs.Int("api-webhook-max-retry", 4, "Set the maximum number of retries for the webhook feature")
+			fs.Duration("api-webhook-retry-min-wait", time.Duration(1)*time.Second, "Set the minimum duration to wait before trying to call the webhook again")
+			fs.Duration("api-webhook-retry-max-wait", time.Duration(30)*time.Second, "Set the maximum duration to wait before trying to call the webhook again")
+			fs.Bool("api-disable-webhook", false, "Disable the webhook feature")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(API) },
+	}
+}
+
+// Provision sets the module properties.
+func (a *API) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	a.port = flags.MustInt("api-port")
+	a.readTimeout = flags.MustDuration("api-read-timeout")
+	a.processTimeout = flags.MustDuration("api-process-timeout")
+	a.writeTimeout = flags.MustDuration("api-write-timeout")
+	a.rootPath = flags.MustString("api-root-path")
+	a.traceHeader = flags.MustString("api-trace-header")
+	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
+	a.webhookAllowList = flags.MustRegexp("api-webhook-allow-list")
+	a.webhookDenyList = flags.MustRegexp("api-webhook-deny-list")
+	a.webhookErrorAllowList = flags.MustRegexp("api-webhook-error-allow-list")
+	a.webhookErrorDenyList = flags.MustRegexp("api-webhook-error-deny-list")
+	a.webhookMaxRetry = flags.MustInt("api-webhook-max-retry")
+	a.webhookRetryMinWait = flags.MustDuration("api-webhook-retry-min-wait")
+	a.webhookRetryMaxWait = flags.MustDuration("api-webhook-retry-max-wait")
+	a.disableWebhook = flags.MustBool("api-disable-webhook")
+
+	// Port from env?
+	portEnvVar := flags.MustString("api-port-from-env")
+	if portEnvVar != "" {
+		val, ok := os.LookupEnv(portEnvVar)
+
+		if !ok {
+			return fmt.Errorf("environment variable '%s' does not exist", portEnvVar)
+		}
+
+		if val == "" {
+			return fmt.Errorf("environment variable '%s' is empty", portEnvVar)
+		}
+
+		port, err := strconv.Atoi(val)
+		if err != nil {
+			return fmt.Errorf("get int value of environment variable '%s': %w", portEnvVar, err)
+		}
+
+		a.port = port
+	}
+
+	// Get routes from modules.
+	mods, err := ctx.Modules(new(MultipartFormDataRouter))
+	if err != nil {
+		return fmt.Errorf("get multipart/form-data routers: %w", err)
+	}
+
+	routers := make([]MultipartFormDataRouter, len(mods))
+	for i, router := range mods {
+		routers[i] = router.(MultipartFormDataRouter)
+	}
+
+	for _, router := range routers {
+		routes, err := router.Routes()
+		if err != nil {
+			return fmt.Errorf("get routes: %w", err)
+		}
+
+		a.multipartFormDataRoutes = append(a.multipartFormDataRoutes, routes...)
+	}
+
+	// Get middlewares from modules.
+	mods, err = ctx.Modules(new(MiddlewareProvider))
+	if err != nil {
+		return fmt.Errorf("get middleware providers: %w", err)
+	}
+
+	middlewareProviders := make([]MiddlewareProvider, len(mods))
+	for i, middlewareProvider := range mods {
+		middlewareProviders[i] = middlewareProvider.(MiddlewareProvider)
+	}
+
+	for _, middlewareProvider := range middlewareProviders {
+		middlewares, err := middlewareProvider.Middlewares()
+		if err != nil {
+			return fmt.Errorf("get middlewares: %w", err)
+		}
+
+		a.externalMiddlewares = append(a.externalMiddlewares, middlewares...)
+	}
+
+	// Sort middlewares by priority.
+	sort.Slice(a.externalMiddlewares, func(i, j int) bool {
+		return a.externalMiddlewares[i].Priority > a.externalMiddlewares[j].Priority
+	})
+
+	// Get health checks from modules.
+	mods, err = ctx.Modules(new(HealthChecker))
+	if err != nil {
+		return fmt.Errorf("get health checkers: %w", err)
+	}
+
+	healthCheckers := make([]HealthChecker, len(mods))
+	for i, healthChecker := range mods {
+		healthCheckers[i] = healthChecker.(HealthChecker)
+	}
+
+	for _, healthChecker := range healthCheckers {
+		checks, err := healthChecker.Checks()
+		if err != nil {
+			return fmt.Errorf("get health checks: %w", err)
+		}
+
+		a.healthChecks = append(a.healthChecks, checks...)
+	}
+
+	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
+	if err != nil {
+		return fmt.Errorf("get logger provider: %w", err)
+	}
+
+	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(a)
+	if err != nil {
+		return fmt.Errorf("get logger: %w", err)
+	}
+
+	a.logger = logger
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (a API) Validate() error {
+	var err error
+
+	if a.port < 1 || a.port > 65535 {
+		err = multierr.Append(err,
+			errors.New("port must be more than 1 and less than 65535"),
+		)
+	}
+
+	if !strings.HasPrefix(a.rootPath, "/") {
+		err = multierr.Append(err,
+			errors.New("root path must start with /"),
+		)
+	}
+
+	if !strings.HasSuffix(a.rootPath, "/") {
+		err = multierr.Append(err,
+			errors.New("root path must end with /"),
+		)
+	}
+
+	if len(strings.TrimSpace(a.traceHeader)) == 0 {
+		err = multierr.Append(err,
+			errors.New("trace header must not be empty"),
+		)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	routesMap := make(map[string]MultipartFormDataRoute, len(a.multipartFormDataRoutes))
+
+	for _, route := range a.multipartFormDataRoutes {
+		if route.Path == "" {
+			return errors.New("route with empty path cannot be registered")
+		}
+
+		if !strings.HasPrefix(route.Path, "/") {
+			return fmt.Errorf("route %s does not start with /", route.Path)
+		}
+
+		if route.Handler == nil {
+			return fmt.Errorf("route %s has a nil handler", route.Path)
+		}
+
+		if _, ok := routesMap[route.Path]; ok {
+			return fmt.Errorf("route %s is already registered", route.Path)
+		}
+
+		routesMap[route.Path] = route
+	}
+
+	for _, middleware := range a.externalMiddlewares {
+		if middleware.Handler == nil {
+			return errors.New("a middleware has a nil handler")
+		}
+	}
+
+	return nil
+}
+
+// Start starts the HTTP server.
+func (a *API) Start() error {
+	a.srv = echo.New()
+	a.srv.HideBanner = true
+	a.srv.HidePort = true
+	a.srv.Server.ReadTimeout = a.readTimeout
+	a.srv.Server.WriteTimeout = a.writeTimeout
+	a.srv.HTTPErrorHandler = httpErrorHandler(a.traceHeader)
+
+	a.srv.Pre(
+		latencyMiddleware(),
+		rootPathMiddleware(a.rootPath),
+		traceMiddleware(a.traceHeader),
+		loggerMiddleware(a.logger, a.disableHealthCheckLogging),
+	)
+
+	for _, externalMiddleware := range a.externalMiddlewares {
+		if externalMiddleware.RunBeforeRouter {
+			a.srv.Pre(externalMiddleware.Handler)
+
+			continue
+		}
+
+		a.srv.Use(externalMiddleware.Handler)
+	}
+
+	hardTimeout := a.processTimeout + (time.Duration(5) * time.Second)
+
+	a.srv.GET(
+		fmt.Sprintf("%shealth", a.rootPath),
+		func() echo.HandlerFunc {
+			checks := append(a.healthChecks, health.WithTimeout(a.processTimeout))
+			checker := health.NewChecker(checks...)
+
+			return echo.WrapHandler(health.NewHandler(checker))
+		}(),
+		timeoutMiddleware(hardTimeout),
+	)
+
+	formsGroup := a.srv.Group(
+		fmt.Sprintf("%sforms", a.rootPath),
+		contextMiddleware(
+			contextMiddlewareConfig{
+				traceHeader: a.traceHeader,
+				timeout: struct {
+					process time.Duration
+					write   time.Duration
+				}{
+					process: a.processTimeout,
+					write:   a.writeTimeout,
+				},
+				webhook: struct {
+					allowList      *regexp.Regexp
+					denyList       *regexp.Regexp
+					errorAllowList *regexp.Regexp
+					errorDenyList  *regexp.Regexp
+					maxRetry       int
+					retryMinWait   time.Duration
+					retryMaxWait   time.Duration
+					disable        bool
+				}{
+					allowList:      a.webhookAllowList,
+					denyList:       a.webhookDenyList,
+					errorAllowList: a.webhookErrorAllowList,
+					errorDenyList:  a.webhookErrorDenyList,
+					maxRetry:       a.webhookMaxRetry,
+					retryMinWait:   a.webhookRetryMinWait,
+					retryMaxWait:   a.webhookRetryMaxWait,
+					disable:        a.disableWebhook,
+				},
+			},
+		),
+		timeoutMiddleware(hardTimeout),
+	)
+
+	// Add routes from other modules.
+	for _, route := range a.multipartFormDataRoutes {
+		formsGroup.POST(
+			route.Path,
+			func(route MultipartFormDataRoute) echo.HandlerFunc {
+				return func(c echo.Context) error {
+					ctx := c.Get("context").(*Context)
+
+					err := route.Handler(ctx)
+					if err != nil {
+						return fmt.Errorf("handle request: %w", err)
+					}
+
+					return nil
+				}
+			}(route),
+		)
+	}
+
+	// As the listen method is blocking, run it in a goroutine.
+	go func() {
+		err := a.srv.Start(fmt.Sprintf(":%d", a.port))
+		if !errors.Is(err, http.ErrServerClosed) {
+			a.logger.Fatal(err.Error())
+		}
+	}()
+
+	return nil
+}
+
+// StartupMessage returns a custom startup message.
+func (a API) StartupMessage() string {
+	return fmt.Sprintf("server listening on port %d", a.port)
+}
+
+// Stop stops the HTTP server.
+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 {
+	duration := a.readTimeout + a.processTimeout + a.writeTimeout
+
+	if a.disableWebhook {
+		return duration
+	}
+
+	for i := 0; i < a.webhookMaxRetry; i++ {
+		// Yep... Golang does not allow int * time.Duration.
+		duration += a.webhookRetryMaxWait
+	}
+
+	return duration
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module                         = (*API)(nil)
+	_ gotenberg.Provisioner                    = (*API)(nil)
+	_ gotenberg.Validator                      = (*API)(nil)
+	_ gotenberg.App                            = (*API)(nil)
+	_ gc.GarbageCollectorGraceDurationModifier = (*API)(nil)
+)

pkg/modules/api/api_test.go

@@ -0,0 +1,793 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/alexliesenfeld/health"
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoValidator struct {
+	ProtoModule
+	validate func() error
+}
+
+func (mod ProtoValidator) Validate() error {
+	return mod.validate()
+}
+
+type ProtoMultipartFormDataRouter struct {
+	ProtoValidator
+	routes func() ([]MultipartFormDataRoute, error)
+}
+
+func (mod ProtoMultipartFormDataRouter) Routes() ([]MultipartFormDataRoute, error) {
+	return mod.routes()
+}
+
+type ProtoMiddlewareProvider struct {
+	ProtoValidator
+	middlewares func() ([]Middleware, error)
+}
+
+func (mod ProtoMiddlewareProvider) Middlewares() ([]Middleware, error) {
+	return mod.middlewares()
+}
+
+type ProtoHealthChecker struct {
+	ProtoValidator
+	checks func() ([]health.CheckerOption, error)
+}
+
+func (mod ProtoHealthChecker) Checks() ([]health.CheckerOption, error) {
+	return mod.checks()
+}
+
+type ProtoLoggerProvider struct {
+	ProtoModule
+	logger func(mod gotenberg.Module) (*zap.Logger, error)
+}
+
+func (factory ProtoLoggerProvider) Logger(mod gotenberg.Module) (*zap.Logger, error) {
+	return factory.logger(mod)
+}
+
+func TestAPI_Descriptor(t *testing.T) {
+	descriptor := API{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(API))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestAPI_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		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)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			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)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func(i int) {
+				err := os.Setenv("PORT", "")
+				if err != nil {
+					t.Fatalf("test %d: expected no error but got: %v", i, err)
+				}
+			},
+			expectErr: true,
+		},
+		{
+			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)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func(i int) {
+				err := os.Setenv("PORT", "foo")
+				if err != nil {
+					t.Fatalf("test %d: expected no error but got: %v", i, err)
+				}
+			},
+			expectErr: true,
+		},
+		{
+			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)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func(i int) {
+				err := os.Setenv("PORT", "1337")
+				if err != nil {
+					t.Fatalf("test %d: expected no error but got: %v", i, err)
+				}
+			},
+			expectPort: 1337,
+			expectErr:  true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMultipartFormDataRouter }{}
+				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.routes = func() ([]MultipartFormDataRoute, error) {
+					return nil, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMiddlewareProvider }{}
+				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.middlewares = func() ([]Middleware, error) {
+					return nil, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMiddlewareProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.middlewares = func() ([]Middleware, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMultipartFormDataRouter }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.routes = func() ([]MultipartFormDataRoute, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoHealthChecker }{}
+				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.checks = func() ([]health.CheckerOption, error) {
+					return nil, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoHealthChecker }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.checks = func() ([]health.CheckerOption, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoLoggerProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.logger = func(_ gotenberg.Module) (*zap.Logger, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod1 := struct{ ProtoMultipartFormDataRouter }{}
+				mod1.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				}
+				mod1.validate = func() error {
+					return nil
+				}
+				mod1.routes = func() ([]MultipartFormDataRoute, error) {
+					return []MultipartFormDataRoute{{}}, nil
+				}
+
+				mod2 := struct{ ProtoMiddlewareProvider }{}
+				mod2.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
+				}
+				mod2.validate = func() error {
+					return nil
+				}
+				mod2.middlewares = func() ([]Middleware, error) {
+					return []Middleware{
+						{
+							Priority: VeryLowPriority,
+						},
+						{
+							Priority: LowPriority,
+						},
+						{
+							Priority: MediumPriority,
+						},
+						{
+							Priority: HighPriority,
+						},
+						{
+							Priority: VeryHighPriority,
+						},
+					}, nil
+				}
+
+				mod3 := struct{ ProtoHealthChecker }{}
+				mod3.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "baz", New: func() gotenberg.Module { return mod3 }}
+				}
+				mod3.validate = func() error {
+					return nil
+				}
+				mod3.checks = func() ([]health.CheckerOption, error) {
+					return []health.CheckerOption{health.WithDisabledAutostart()}, nil
+				}
+
+				mod4 := struct{ ProtoLoggerProvider }{}
+				mod4.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "qux", New: func() gotenberg.Module { return mod4 }}
+				}
+				mod4.logger = func(_ gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod1.Descriptor(),
+						mod2.Descriptor(),
+						mod3.Descriptor(),
+						mod4.Descriptor(),
+					},
+				)
+			}(),
+			expectMiddlewares: []Middleware{
+				{
+					Priority: VeryHighPriority,
+				},
+				{
+					Priority: HighPriority,
+				},
+				{
+					Priority: MediumPriority,
+				},
+				{
+					Priority: LowPriority,
+				},
+				{
+					Priority: VeryLowPriority,
+				},
+			},
+		},
+	} {
+		if tc.setEnv != nil {
+			tc.setEnv(i)
+		}
+
+		mod := new(API)
+		err := mod.Provision(tc.ctx)
+
+		if tc.expectPort != 0 && mod.port != tc.expectPort {
+			t.Errorf("expected port %d but got %d", tc.expectPort, mod.port)
+		}
+
+		if !reflect.DeepEqual(mod.externalMiddlewares, tc.expectMiddlewares) {
+			t.Errorf("expected %+v, but got: %+v", tc.expectMiddlewares, mod.externalMiddlewares)
+		}
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestAPI_Validate(t *testing.T) {
+	for i, tc := range []struct {
+		port        int
+		rootPath    string
+		traceHeader string
+		routes      []MultipartFormDataRoute
+		middlewares []Middleware
+		expectErr   bool
+	}{
+		{
+			port:      0,
+			expectErr: true,
+		},
+		{
+			port:      65536,
+			rootPath:  "foo",
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []MultipartFormDataRoute{
+				{
+					Path: "",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []MultipartFormDataRoute{
+				{
+					Path: "foo",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []MultipartFormDataRoute{
+				{
+					Path: "/foo",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []MultipartFormDataRoute{
+				{
+					Path:    "/foo",
+					Handler: func(_ *Context) error { return nil },
+				},
+				{
+					Path:    "/foo",
+					Handler: func(_ *Context) error { return nil },
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			middlewares: []Middleware{
+				{
+					Priority: HighPriority,
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []MultipartFormDataRoute{
+				{
+					Path:    "/foo",
+					Handler: func(_ *Context) error { return nil },
+				},
+			},
+			middlewares: []Middleware{
+				{
+					Priority: HighPriority,
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+			},
+		},
+	} {
+		mod := API{
+			port:                    tc.port,
+			rootPath:                tc.rootPath,
+			traceHeader:             tc.traceHeader,
+			multipartFormDataRoutes: tc.routes,
+			externalMiddlewares:     tc.middlewares,
+		}
+
+		err := mod.Validate()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestAPI_Start(t *testing.T) {
+	mod := new(API)
+	mod.port = 3000
+	mod.rootPath = "/"
+	mod.multipartFormDataRoutes = []MultipartFormDataRoute{
+		{
+			Path: "/foo",
+			Handler: func(ctx *Context) error {
+				ctx.outputPaths = []string{
+					"/tests/test/testdata/api/sample1.txt",
+				}
+
+				return nil
+			},
+		},
+		{
+			Path:    "/bar",
+			Handler: func(_ *Context) error { return errors.New("foo") },
+		},
+	}
+	mod.externalMiddlewares = []Middleware{
+		{
+			RunBeforeRouter: true,
+			Handler: func() echo.MiddlewareFunc {
+				return func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						return next(c)
+					}
+				}
+			}(),
+		},
+		{
+			Handler: func() echo.MiddlewareFunc {
+				return func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						return next(c)
+					}
+				}
+			}(),
+		},
+	}
+	mod.logger = zap.NewNop()
+
+	err := mod.Start()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	// health request.
+	recorder := httptest.NewRecorder()
+	healthRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
+
+	mod.srv.ServeHTTP(recorder, healthRequest)
+	if recorder.Code != http.StatusOK {
+		t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+	}
+
+	// "multipart/form-data" request.
+	multipartRequest := func(URL string) *http.Request {
+		body := &bytes.Buffer{}
+
+		writer := multipart.NewWriter(body)
+
+		defer func() {
+			err := writer.Close()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		}()
+
+		err := writer.WriteField("foo", "foo")
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		part, err := writer.CreateFormFile("foo.txt", "foo.txt")
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		_, err = part.Write([]byte("foo"))
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		req := httptest.NewRequest(http.MethodPost, URL, body)
+		req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+
+		return req
+	}
+
+	recorder = httptest.NewRecorder()
+	mod.srv.ServeHTTP(recorder, multipartRequest("/forms/foo"))
+
+	if recorder.Code != http.StatusOK {
+		t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+	}
+
+	recorder = httptest.NewRecorder()
+	mod.srv.ServeHTTP(recorder, multipartRequest("/forms/bar"))
+
+	if recorder.Code != http.StatusInternalServerError {
+		t.Errorf("expected %d status code but got %d", http.StatusInternalServerError, recorder.Code)
+	}
+
+	err = mod.srv.Shutdown(context.TODO())
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestAPI_StartupMessage(t *testing.T) {
+	mod := API{
+		port: 3000,
+	}
+
+	actual := mod.StartupMessage()
+	expect := "server listening on port 3000"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestAPI_Stop(t *testing.T) {
+	mod := API{
+		port: 3000,
+		multipartFormDataRoutes: []MultipartFormDataRoute{
+			{
+				Path:    "/foo",
+				Handler: func(_ *Context) error { return nil },
+			},
+		},
+		logger: zap.NewNop(),
+	}
+
+	err := mod.Start()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	err = mod.Stop(context.TODO())
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestAPI_GraceDuration(t *testing.T) {
+	for i, tc := range []struct {
+		mod    API
+		expect time.Duration
+	}{
+		{
+			mod: API{
+				readTimeout:    time.Duration(1) * time.Second,
+				processTimeout: time.Duration(1) * time.Second,
+				writeTimeout:   time.Duration(1) * time.Second,
+				disableWebhook: true,
+			},
+			expect: time.Duration(3) * time.Second,
+		},
+		{
+			mod: API{
+				readTimeout:         time.Duration(1) * time.Second,
+				processTimeout:      time.Duration(1) * time.Second,
+				writeTimeout:        time.Duration(1) * time.Second,
+				webhookMaxRetry:     5,
+				webhookRetryMaxWait: time.Duration(5) * time.Second,
+			},
+			expect: time.Duration(28) * time.Second,
+		},
+	} {
+		actual := tc.mod.GraceDuration()
+
+		if actual != tc.expect {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expect, actual)
+		}
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module         = (*ProtoModule)(nil)
+	_ gotenberg.Validator      = (*ProtoValidator)(nil)
+	_ gotenberg.Module         = (*ProtoValidator)(nil)
+	_ MultipartFormDataRouter  = (*ProtoMultipartFormDataRouter)(nil)
+	_ gotenberg.Module         = (*ProtoMultipartFormDataRouter)(nil)
+	_ gotenberg.Validator      = (*ProtoMultipartFormDataRouter)(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

@@ -0,0 +1,319 @@
+package api
+
+import (
+	"compress/flate"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+	"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"
+)
+
+var (
+	// ErrContextAlreadyClosed happens when the context has been canceled.
+	ErrContextAlreadyClosed = errors.New("context already closed")
+
+	// ErrOutOfBoundsOutputPath happens when an output path is not within
+	// context's working directory. It enforces having all the files in the
+	// same directory.
+	ErrOutOfBoundsOutputPath = errors.New("output path is not within context's working directory")
+)
+
+// Context is the request context for a "multipart/form-data" requests.
+type Context struct {
+	dirPath string
+	values  map[string][]string
+	files   map[string]string
+
+	outputPaths []string
+
+	cancelled bool
+	logger    *zap.Logger
+	echoCtx   echo.Context
+	context.Context
+}
+
+// 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) {
+	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)
+
+	ctx := &Context{
+		outputPaths: make([]string, 0),
+		cancelled:   false,
+		logger:      logger,
+		echoCtx:     echoCtx,
+		Context:     processCtx,
+	}
+
+	// A custom cancel function which removes the context's working directory
+	// when called.
+	cancel := func() context.CancelFunc {
+		return func() {
+			if ctx.cancelled {
+				return
+			}
+
+			processCancel()
+
+			if ctx.dirPath == "" {
+				return
+			}
+
+			err := os.RemoveAll(ctx.dirPath)
+			if err != nil {
+				ctx.logger.Error(fmt.Sprintf("remove context's working directory: %s", err))
+
+				return
+			}
+
+			ctx.logger.Debug(fmt.Sprintf("'%s' removed", ctx.dirPath))
+			ctx.cancelled = true
+		}
+	}()
+
+	form, err := echoCtx.MultipartForm()
+	if err != nil {
+
+		if errors.Is(err, http.ErrNotMultipart) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHTTPError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: want 'multipart/form-data'"),
+			)
+		}
+
+		if errors.Is(err, http.ErrMissingBoundary) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHTTPError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: no boundary"),
+			)
+		}
+
+		if strings.Contains(err.Error(), io.EOF.Error()) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHTTPError(http.StatusBadRequest, "Malformed body: it does not match the 'Content-Type' header boundaries"),
+			)
+		}
+
+		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
+	}
+
+	dirPath, err := gotenberg.MkdirAll()
+	if err != nil {
+		return nil, cancel, fmt.Errorf("create working directory: %w", err)
+	}
+
+	ctx.dirPath = dirPath
+	ctx.values = form.Value
+	ctx.files = make(map[string]string)
+
+	copyToDisk := func(fh *multipart.FileHeader) error {
+		// Avoid directory traversal and normalize filename.
+		// See https://github.com/gotenberg/gotenberg/issues/104.
+		// See https://github.com/gotenberg/gotenberg/issues/228.
+		t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+
+		filename, _, err := transform.String(t, strings.ToLower(filepath.Base(fh.Filename)))
+		if err != nil {
+			return fmt.Errorf("transform filename: %w", err)
+		}
+
+		in, err := fh.Open()
+		if err != nil {
+			return fmt.Errorf("open multipart file: %w", err)
+		}
+
+		defer func() {
+			err := in.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close file header: %s", err))
+			}
+		}()
+
+		path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+
+		out, err := os.Create(path)
+		if err != nil {
+			return fmt.Errorf("create local file: %w", err)
+		}
+
+		defer func() {
+			err := out.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close local file: %s", err))
+			}
+		}()
+
+		_, err = io.Copy(out, in)
+		if err != nil {
+			return fmt.Errorf("copy multipart file to local file: %w", err)
+		}
+
+		ctx.files[filename] = path
+
+		return nil
+	}
+
+	for _, files := range form.File {
+		for _, fh := range files {
+			err = copyToDisk(fh)
+
+			if err != nil {
+				return ctx, cancel, fmt.Errorf("copy to disk: %w", err)
+			}
+		}
+	}
+
+	ctx.Log().Debug(fmt.Sprintf("form data values: %+v", ctx.values))
+	ctx.Log().Debug(fmt.Sprintf("form data files: %+v", ctx.files))
+
+	return ctx, cancel, err
+}
+
+// Request returns the http.Request.
+func (ctx Context) Request() *http.Request {
+	return ctx.echoCtx.Request()
+}
+
+// FormData return a FormData.
+func (ctx Context) FormData() *FormData {
+	return &FormData{
+		values: ctx.values,
+		files:  ctx.files,
+		errors: nil,
+	}
+}
+
+// GeneratePath generates a path within the context's working directory. It
+// does not create a file.
+func (ctx Context) GeneratePath(extension string) string {
+	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New(), extension)
+}
+
+// AddOutputPaths adds the given paths. Those paths will be used later to build
+// the output file.
+func (ctx *Context) AddOutputPaths(paths ...string) error {
+	if ctx.cancelled {
+		return ErrContextAlreadyClosed
+	}
+
+	for _, path := range paths {
+		if !strings.HasPrefix(path, ctx.dirPath) {
+			return ErrOutOfBoundsOutputPath
+		}
+
+		ctx.outputPaths = append(ctx.outputPaths, path)
+	}
+
+	return nil
+}
+
+// Log returns the context zap.Logger.
+func (ctx Context) Log() *zap.Logger {
+	return ctx.logger
+}
+
+// buildOutputFile builds the output file according to the output paths
+// registered in the context. If many output paths, an archive is created.
+func (ctx Context) buildOutputFile() (string, error) {
+	if ctx.cancelled {
+		return "", ErrContextAlreadyClosed
+	}
+
+	if len(ctx.outputPaths) == 0 {
+		return "", errors.New("no output path")
+	}
+
+	if len(ctx.outputPaths) == 1 {
+		ctx.logger.Debug(fmt.Sprintf("only one output file '%s', skip archive creation", ctx.outputPaths[0]))
+
+		return ctx.outputPaths[0], nil
+	}
+
+	z := archiver.Zip{
+		CompressionLevel:       flate.DefaultCompression,
+		MkdirAll:               true,
+		SelectiveCompression:   true,
+		ContinueOnError:        false,
+		OverwriteExisting:      false,
+		ImplicitTopLevelFolder: false,
+	}
+
+	archivePath := ctx.GeneratePath(".zip")
+
+	err := z.Archive(ctx.outputPaths, archivePath)
+	if err != nil {
+		return "", fmt.Errorf("archive output files: %w", err)
+	}
+
+	ctx.logger.Debug(fmt.Sprintf("archive '%s' created", archivePath))
+
+	return archivePath, nil
+}
+
+// MockContext is a helper for tests.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+type MockContext struct {
+	*Context
+}
+
+// SetDirPath sets the context's working directory path.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.SetDirPath("/foo")
+func (ctx *MockContext) SetDirPath(path string) {
+	ctx.dirPath = path
+}
+
+// SetValues sets the values.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.SetValues(map[string][]string{
+//    "url": {
+//      "foo",
+//    },
+//  })
+func (ctx *MockContext) SetValues(values map[string][]string) {
+	ctx.values = values
+}
+
+// SetFiles sets the files.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.SetFiles(map[string]string{
+//    "foo": "/foo",
+//  })
+func (ctx *MockContext) SetFiles(files map[string]string) {
+	ctx.files = files
+}
+
+// SetCancelled sets if the context is cancelled or not.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.SetCancelled(true)
+func (ctx *MockContext) SetCancelled(cancelled bool) {
+	ctx.cancelled = cancelled
+}
+
+// OutputPaths returns the registered output paths.
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  outputPaths := ctx.OutputPaths()
+func (ctx MockContext) OutputPaths() []string {
+	return ctx.outputPaths
+}

pkg/modules/api/context_test.go

@@ -0,0 +1,373 @@
+package api
+
+import (
+	"bytes"
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+func TestNewContext(t *testing.T) {
+	for i, tc := range []struct {
+		request          *http.Request
+		expectErr        bool
+		expectHTTPErr    bool
+		expectHTTPStatus int
+	}{
+		{
+			request:          httptest.NewRequest(http.MethodPost, "/", nil),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusUnsupportedMediaType,
+		},
+		{
+			request: func() *http.Request {
+				req := httptest.NewRequest(http.MethodPost, "/", nil)
+				req.Header.Set(echo.HeaderContentType, echo.MIMEMultipartForm)
+
+				return req
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusUnsupportedMediaType,
+		},
+		{
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+
+				writer := multipart.NewWriter(body)
+
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+
+				err := writer.WriteField("foo", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				req := httptest.NewRequest(http.MethodPost, "/", nil)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+
+				return req
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+
+				writer := multipart.NewWriter(body)
+
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+
+				err := writer.WriteField("foo", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				part, err := writer.CreateFormFile("foo.txt", "foo.txt")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				_, err = part.Write([]byte("foo"))
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+
+				return req
+			}(),
+		},
+	} {
+		handler := func(c echo.Context) error {
+			_, cancel, err := newContext(c, zap.NewNop(), time.Duration(10)*time.Second)
+			defer cancel()
+			// Context already cancelled.
+			defer cancel()
+
+			if err != nil {
+				return err
+			}
+
+			return nil
+		}
+
+		recorder := httptest.NewRecorder()
+
+		srv := echo.New()
+		srv.HideBanner = true
+		srv.HidePort = true
+
+		c := srv.NewContext(tc.request, recorder)
+		err := handler(c)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+	}
+}
+
+func TestContext_Request(t *testing.T) {
+	request := httptest.NewRequest(http.MethodPost, "/", nil)
+	recorder := httptest.NewRecorder()
+	c := echo.New().NewContext(request, recorder)
+
+	ctx := Context{
+		echoCtx: c,
+	}
+
+	if !reflect.DeepEqual(ctx.Request(), c.Request()) {
+		t.Errorf("expected %v but got %v", ctx.Request(), c.Request())
+	}
+}
+
+func TestContext_FormData(t *testing.T) {
+	ctx := Context{
+		values: map[string][]string{
+			"foo": {"foo"},
+		},
+		files: map[string]string{
+			"foo.txt": "/foo.txt",
+		},
+	}
+
+	actual := ctx.FormData()
+	expect := &FormData{
+		values: ctx.values,
+		files:  ctx.files,
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got %+v", expect, actual)
+	}
+}
+
+func TestContext_GeneratePath(t *testing.T) {
+	ctx := Context{
+		dirPath: "/foo",
+	}
+
+	path := ctx.GeneratePath(".pdf")
+
+	if !strings.HasPrefix(path, ctx.dirPath) {
+		t.Errorf("expected '%s' to start with '%s'", path, ctx.dirPath)
+	}
+}
+
+func TestContext_AddOutputPaths(t *testing.T) {
+	for i, tc := range []struct {
+		ctx         *Context
+		path        string
+		expectCount int
+		expectErr   bool
+	}{
+		{
+			ctx:       &Context{cancelled: true},
+			expectErr: true,
+		},
+		{
+			ctx:       &Context{dirPath: "/foo"},
+			path:      "/bar/foo.txt",
+			expectErr: true,
+		},
+		{
+			ctx:         &Context{dirPath: "/foo"},
+			path:        "/foo/foo.txt",
+			expectCount: 1,
+		},
+	} {
+		err := tc.ctx.AddOutputPaths(tc.path)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		if len(tc.ctx.outputPaths) != tc.expectCount {
+			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectCount, len(tc.ctx.outputPaths))
+		}
+	}
+}
+
+func TestContext_Log(t *testing.T) {
+	expect := zap.NewNop()
+	ctx := Context{logger: expect}
+	actual := ctx.Log()
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestContext_buildOutputFile(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       *Context
+		expectErr bool
+	}{
+		{
+			ctx:       &Context{cancelled: true},
+			expectErr: true,
+		},
+		{
+			ctx:       &Context{},
+			expectErr: true,
+		},
+		{
+			ctx: &Context{outputPaths: []string{"foo.txt"}},
+		},
+		{
+			ctx:       &Context{outputPaths: []string{"foo.txt", "foo.pdf"}},
+			expectErr: true,
+		},
+		{
+			ctx: &Context{
+				outputPaths: []string{
+					"/tests/test/testdata/api/sample1.txt",
+					"/tests/test/testdata/api/sample1.txt",
+				},
+			},
+		},
+	} {
+		dirPath, err := gotenberg.MkdirAll()
+		if err != nil {
+			t.Fatalf("%d: expected no erro but got: %v", i, err)
+		}
+
+		tc.ctx.dirPath = dirPath
+		tc.ctx.logger = zap.NewNop()
+
+		_, err = tc.ctx.buildOutputFile()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		err = os.RemoveAll(dirPath)
+		if err != nil {
+			t.Fatalf("%d: expected no erro but got: %v", i, err)
+		}
+	}
+}
+
+func TestMockContext_SetDirPath(t *testing.T) {
+	mock := &MockContext{&Context{}}
+	mock.SetDirPath("/foo")
+
+	actual := mock.dirPath
+	expect := "/foo"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestMockContext_SetValues(t *testing.T) {
+	mock := &MockContext{&Context{}}
+	mock.SetValues(map[string][]string{
+		"foo": {"foo"},
+	})
+
+	actual := mock.values
+	expect := map[string][]string{
+		"foo": {"foo"},
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}
+
+func TestMockContext_SetFiles(t *testing.T) {
+	mock := &MockContext{&Context{}}
+	mock.SetFiles(map[string]string{
+		"foo": "/foo",
+	})
+
+	actual := mock.files
+	expect := map[string]string{
+		"foo": "/foo",
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}
+
+func TestMockContext_SetCancelled(t *testing.T) {
+	mock := &MockContext{&Context{}}
+	mock.SetCancelled(true)
+
+	actual := mock.cancelled
+
+	if !actual {
+		t.Errorf("expected %t but got %t", true, actual)
+	}
+}
+
+func TestMockContext_OutputPaths(t *testing.T) {
+	mock := MockContext{
+		&Context{
+			outputPaths: []string{"/foo"},
+		},
+	}
+
+	actual := mock.OutputPaths()
+	expect := []string{"/foo"}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}

pkg/modules/api/doc.go

@@ -0,0 +1,3 @@
+// Package api provides a module which is an HTTP server. Other modules may
+// add multipart/form-data routes, middlewares, and health checks.
+package api

pkg/modules/api/errors.go

@@ -0,0 +1,77 @@
+package api
+
+// Credits: https://www.joeshaw.org/error-handling-in-go-http-applications.
+
+// HTTPError is an interface allowing to retrieve the HTTP details of an error.
+type HTTPError interface {
+	HTTPError() (int, string)
+}
+
+// SentinelHTTPError is the HTTP sidekick of an error.
+type SentinelHTTPError struct {
+	status  int
+	message string
+}
+
+// NewSentinelHTTPError creates a SentinelHTTPError. The message will be sent
+// as the response's body if returned from an handler, so make sure to not leak
+// sensible information.
+func NewSentinelHTTPError(status int, message string) SentinelHTTPError {
+	return SentinelHTTPError{
+		status:  status,
+		message: message,
+	}
+}
+
+// Error returns the message.
+func (err SentinelHTTPError) Error() string {
+	return err.message
+}
+
+// HTTPError returns the status and message.
+func (err SentinelHTTPError) HTTPError() (int, string) {
+	return err.status, err.message
+}
+
+// sentinelWrappedError contains both the error which will logged and the
+// sidekick SentinelHTTPError.
+type sentinelWrappedError struct {
+	error
+	sentinel SentinelHTTPError
+}
+
+func (w sentinelWrappedError) Is(err error) bool {
+	return w.sentinel == err
+}
+
+func (w sentinelWrappedError) HTTPError() (int, string) {
+	return w.sentinel.HTTPError()
+}
+
+// WrapError wraps the given error with a SentinelHTTPError. The wrapped error
+// will be displayed in a log, while the SentinelHTTPError will be sent in the
+// response.
+//
+//  return api.WrapError(
+//    // This first error will be logged.
+//    fmt.Errorf("my action: %w", err),
+//    // The HTTP error will be sent as a response.
+//    api.NewSentinelHTTPError(
+//      http.StatusForbidden,
+//      "Hey, you did something wrong!"
+//    ),
+//  )
+func WrapError(err error, sentinel SentinelHTTPError) error {
+	return sentinelWrappedError{
+		error:    err,
+		sentinel: sentinel,
+	}
+}
+
+// Interface guards.
+var (
+	_ error     = (*SentinelHTTPError)(nil)
+	_ HTTPError = (*SentinelHTTPError)(nil)
+	_ error     = (*sentinelWrappedError)(nil)
+	_ HTTPError = (*sentinelWrappedError)(nil)
+)

pkg/modules/api/errors_test.go

@@ -0,0 +1,108 @@
+package api
+
+import (
+	"errors"
+	"net/http"
+	"reflect"
+	"testing"
+)
+
+func TestNewSentinelHTTPError(t *testing.T) {
+	actual := NewSentinelHTTPError(http.StatusInternalServerError, "foo")
+	expect := SentinelHTTPError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestSentinelHTTPError_Error(t *testing.T) {
+	err := SentinelHTTPError{
+		message: "foo",
+	}
+
+	actual := err.Error()
+	expect := "foo"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestSentinelHTTPError_HTTPError(t *testing.T) {
+	actualStatus, actualMessage := SentinelHTTPError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}.HTTPError()
+
+	expectStatus := http.StatusInternalServerError
+	expectMessage := "foo"
+
+	if actualStatus != expectStatus {
+		t.Errorf("expected %d but got %d", expectStatus, actualStatus)
+	}
+
+	if actualMessage != expectMessage {
+		t.Errorf("expected '%s' but got '%s'", expectMessage, actualMessage)
+	}
+}
+
+func TestSentinelWrappedError_Is(t *testing.T) {
+	errSentinel := SentinelHTTPError{}
+
+	err := sentinelWrappedError{
+		error:    errors.New("foo"),
+		sentinel: errSentinel,
+	}
+
+	if !err.Is(errSentinel) {
+		t.Error("expected true")
+	}
+}
+
+func TestSentinelWrappedError_HTTPError(t *testing.T) {
+	expectStatus, expectMessage := SentinelHTTPError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}.HTTPError()
+
+	actualStatus, actualMessage := sentinelWrappedError{
+		error: errors.New("foo"),
+		sentinel: SentinelHTTPError{
+			status:  http.StatusInternalServerError,
+			message: "foo",
+		},
+	}.HTTPError()
+
+	if actualStatus != expectStatus {
+		t.Errorf("expected %d but got %d", expectStatus, actualStatus)
+	}
+
+	if actualMessage != expectMessage {
+		t.Errorf("expected '%s' but got '%s'", expectMessage, actualMessage)
+	}
+}
+
+func TestWrapError(t *testing.T) {
+	errFoo := errors.New("foo")
+
+	expect := sentinelWrappedError{
+		error: errFoo,
+		sentinel: SentinelHTTPError{
+			status:  http.StatusInternalServerError,
+			message: "foo",
+		},
+	}
+
+	actual := WrapError(errFoo, SentinelHTTPError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	})
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}

pkg/modules/api/formdata.go

@@ -0,0 +1,439 @@
+package api
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.uber.org/multierr"
+)
+
+// FormData is a helper for validating and hydrating values from a
+// "multipart/form-data" request.
+//
+//  form := ctx.FormData()
+type FormData struct {
+	values map[string][]string
+	files  map[string]string
+	errors error
+}
+
+// Validate returns nil or an error related to the FormData values, with a
+// SentinelHTTPError (status code 400, errors' details as message) wrapped
+// inside.
+//
+//  var foo string
+//
+//  err := ctx.FormData().
+//     MandatoryString("foo", &foo, "bar").
+//     Validate()
+func (form FormData) Validate() error {
+	if form.errors == nil {
+		return nil
+	}
+
+	return WrapError(
+		form.errors,
+		NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid form data: %s", form.errors)),
+	)
+}
+
+// String binds a form data value to a string variable.
+//
+//  var foo string
+//
+//  ctx.FormData().String("foo", &foo, "bar")
+func (form *FormData) String(key string, target *string, defaultValue string) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryString binds a form data value to a string variable. It populates
+// an error if the value is empty or the "key" does not exist.
+//
+//  var foo string
+//
+//  ctx.FormData().MandatoryString("foo", &foo)
+func (form *FormData) MandatoryString(key string, target *string) *FormData {
+	return form.mustMandatoryValue(key, target)
+}
+
+// Bool binds a form data value to a bool variable. It populates an error if
+// the value is not bool.
+//
+//  var foo bool
+//
+//  ctx.FormData().Bool("foo", &foo, true)
+func (form *FormData) Bool(key string, target *bool, defaultValue bool) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryBool binds a form data value to a bool variable. It populates an
+// error if the value is not bool, is empty, or the "key" does not exist.
+//
+//  var foo bool
+//
+//  ctx.FormData().MandatoryBool("foo", &foo)
+func (form *FormData) MandatoryBool(key string, target *bool) *FormData {
+	return form.mustMandatoryValue(key, target)
+}
+
+// Int binds a form data value to an int variable. It populates an error if the
+// value is not int.
+//
+//  var foo int
+//
+//  ctx.FormData().Int("foo", &foo, 2)
+func (form *FormData) Int(key string, target *int, defaultValue int) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryInt binds a form data value to an int variable. It populates an
+// error if the value is not int, is empty, or the "key" does not exist.
+//
+//  var foo int
+//
+//  ctx.FormData().MandatoryInt("foo", &foo)
+func (form *FormData) MandatoryInt(key string, target *int) *FormData {
+	return form.mustMandatoryValue(key, target)
+}
+
+// Float64 binds a form data value to a float64 variable. It populates an error
+// if the value is not float64.
+//
+//  var foo float64
+//
+//  ctx.FormData().Float64("foo", &foo, 2.0)
+func (form *FormData) Float64(key string, target *float64, defaultValue float64) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryFloat64 binds a form data value to a float64 variable. It populates
+// an error if the is not float64, is empty, or the "key" does not exist.
+//
+//  var foo float64
+//
+//  ctx.FormData().MandatoryFloat64("foo", &foo)
+func (form *FormData) MandatoryFloat64(key string, target *float64) *FormData {
+	return form.mustMandatoryValue(key, target)
+}
+
+// Duration binds a form data value to a time.Duration variable. It populates
+// an error if the form data value is not time.Duration.
+//
+//  var foo time.Duration
+//
+//  ctx.FormData().Duration("foo", &foo, time.Duration(2) * time.Second)
+func (form *FormData) Duration(key string, target *time.Duration, defaultValue time.Duration) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryDuration binds a form data value to a time.Duration variable. It
+// populates an error if the value is not time.Duration, is empty, or the "key"
+// does not exist.
+//
+//  var foo time.Duration
+//
+//  ctx.FormData().MandatoryDuration("foo", &foo)
+func (form *FormData) MandatoryDuration(key string, target *time.Duration) *FormData {
+	return form.mustMandatoryValue(key, target)
+}
+
+// Custom helps to define a custom binding function for a form data value.
+//
+//  var foo map[string]string
+//
+//  ctx.FormData().Custom("foo", func(value string) error {
+//    if value == "" {
+//      foo = "bar"
+//
+//      return nil
+//    }
+//
+//    err := json.Unmarshal([]byte(value), &foo)
+//    if err != nil {
+//      return fmt.Errorf("unmarshal foo: %w", err)
+//    }
+//
+//    return nil
+//  })
+func (form *FormData) Custom(key string, assign func(value string) error) *FormData {
+	var value string
+	form.mustValue(key, &value, "")
+
+	err := assign(value)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// MandatoryCustom helps to define a custom binding function for a form data
+// value. It populates an error if the value is empty or the "key" does not
+// exist.
+//
+//  var foo map[string]string
+//
+//  ctx.FormData().MandatoryCustom("foo", func(value string) error {
+//    err := json.Unmarshal([]byte(value), &foo)
+//    if err != nil {
+//      return fmt.Errorf("unmarshal foo: %w", err)
+//    }
+//
+//    return nil
+//  })
+func (form *FormData) MandatoryCustom(key string, assign func(value string) error) *FormData {
+	var value string
+	form.mustMandatoryValue(key, &value)
+
+	if value == "" {
+		return form
+	}
+
+	err := assign(value)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// Path binds the absolute path of a form data file to a string variable.
+//
+//  var path string
+//
+//  ctx.FormData().Path("foo.txt", &path)
+func (form *FormData) Path(filename string, target *string) *FormData {
+	return form.path(filename, target)
+}
+
+// MandatoryPath binds the absolute path ofa  form data file to a string
+// variable. It populates an error if the file does not exist.
+//
+//  var path string
+//
+//  ctx.FormData().MandatoryPath("foo.txt", &path)
+func (form *FormData) MandatoryPath(filename string, target *string) *FormData {
+	return form.mandatoryPath(filename, target)
+}
+
+// Content binds the content of a form data file to a string variable.
+//
+//  var content string
+//
+//  ctx.FormData().Content("foo.txt", &content, "bar")
+func (form *FormData) Content(filename string, target *string, defaultValue string) *FormData {
+	var path string
+	form.path(filename, &path)
+
+	if path == "" {
+		*target = defaultValue
+
+		return form
+	}
+
+	return form.readFile(path, filename, target)
+}
+
+// MandatoryContent binds the content of a form data file to a string variable.
+// It populates an error if the file does not exist.
+//
+//  var content string
+//
+//  ctx.FormData().MandatoryContent("foo.txt", &content)
+func (form *FormData) MandatoryContent(filename string, target *string) *FormData {
+	var path string
+	form.mandatoryPath(filename, &path)
+
+	if path == "" {
+		return form
+	}
+
+	return form.readFile(path, filename, target)
+}
+
+// Paths binds the absolute paths of form data files, according to a list of
+// file extensions, to a string slice variable.
+//
+//  var paths []string
+//
+//  ctx.FormData().Paths([]string{".txt"}, &paths)
+func (form *FormData) Paths(extensions []string, target *[]string) *FormData {
+	return form.paths(extensions, target)
+}
+
+// MandatoryPaths binds the absolute paths of form data files, according to a
+// list of file extensions, to a string slice variable. It populates an error
+// if there is no file for given file extensions.
+//
+//  var paths []string
+//
+//  ctx.FormData().MandatoryPaths([]string{".txt"}, &paths)
+func (form *FormData) MandatoryPaths(extensions []string, target *[]string) *FormData {
+	form.paths(extensions, target)
+
+	if len(*target) > 0 {
+		return form
+	}
+
+	form.append(
+		fmt.Errorf("no form file found for extensions: %v", extensions),
+	)
+
+	return form
+}
+
+// paths binds the absolute paths of form data files, according to a list of
+// file extensions, to a string slice variable.
+func (form *FormData) paths(extensions []string, target *[]string) *FormData {
+	for filename, path := range form.files {
+		for _, ext := range extensions {
+			// See https://github.com/gotenberg/gotenberg/issues/228.
+			if strings.ToLower(filepath.Ext(filename)) == ext {
+				*target = append(*target, path)
+			}
+		}
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/139.
+	sort.Strings(*target)
+
+	return form
+}
+
+// append adds an error to the list of errors.
+func (form *FormData) append(err error) {
+	form.errors = multierr.Append(form.errors, err)
+}
+
+// mustValue binds the target interface with a form data value. If the value is
+// empty or the "key" does not exist, it binds the default value. Currently,
+// only the string, bool, int, float64 and time.Duration types are bindable.
+func (form *FormData) mustValue(key string, target interface{}, defaultValue interface{}) *FormData {
+	val, ok := form.values[key]
+
+	if !ok || val[0] == "" {
+		switch t := (target).(type) {
+		case *string:
+			*t = defaultValue.(string)
+		case *bool:
+			*t = defaultValue.(bool)
+		case *int:
+			*t = defaultValue.(int)
+		case *float64:
+			*t = defaultValue.(float64)
+		case *time.Duration:
+			*t = defaultValue.(time.Duration)
+		default:
+			panic("target type not supported")
+		}
+
+		return form
+	}
+
+	return form.mustAssign(key, val[0], target)
+}
+
+// mustMandatoryValue binds the target interface with a form data value. It
+// populates an error if the value is empty or the "key" does not exist.
+// Currently, only the string, bool, int, float64 and time.Duration types are
+// bindable.
+func (form *FormData) mustMandatoryValue(key string, target interface{}) *FormData {
+	val, ok := form.values[key]
+
+	if !ok || val[0] == "" {
+		form.append(
+			fmt.Errorf("form value '%s' is required", key),
+		)
+
+		return form
+	}
+
+	form.mustAssign(key, val[0], target)
+
+	return form
+}
+
+// mustAssign parses the string value and tries to convert it to the target
+// interface real type. Currently, only the string, bool, int, float64 and
+// time.Duration types are bindable.
+func (form *FormData) mustAssign(key, value string, target interface{}) *FormData {
+	var err error
+
+	switch t := (target).(type) {
+	case *string:
+		*t = value
+	case *bool:
+		*t, err = strconv.ParseBool(value)
+	case *int:
+		*t, err = strconv.Atoi(value)
+	case *float64:
+		*t, err = strconv.ParseFloat(value, 64)
+	case *time.Duration:
+		*t, err = time.ParseDuration(value)
+	default:
+		panic("target type not supported")
+	}
+
+	if err != nil {
+		form.append(
+			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// path binds the absolute path of a form data file to a string variable.
+func (form *FormData) path(filename string, target *string) *FormData {
+	for name, path := range form.files {
+		if name == filename {
+			*target = path
+			return form
+		}
+	}
+
+	return form
+}
+
+// mandatoryPath binds the absolute path of a form data file to a string
+// variable. It populates an error if the file does not exist.
+func (form *FormData) mandatoryPath(filename string, target *string) *FormData {
+	form.path(filename, target)
+
+	if *target != "" {
+		return form
+	}
+
+	form.append(
+		fmt.Errorf("form file '%s' is required", filename),
+	)
+
+	return form
+}
+
+// readFile binds the content of a file to a string variable. It populates an
+// error if it fails to read the file content.
+func (form *FormData) readFile(path, filename string, target *string) *FormData {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form file '%s' is invalid (%w)", filename, err),
+		)
+
+		return form
+	}
+
+	*target = string(b)
+
+	return form
+}

pkg/modules/api/middlewares.go

@@ -0,0 +1,576 @@
+package api
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+// httpErrorHandler is the centralized HTTP error handler. It parses the error,
+// returns either a response as "text/plain; charset=UTF-8" or, if a webhook
+// client exists in the echo.Context, sends a request to the webhook error URL
+// with a JSON body containing the trace, the status and the error message.
+func httpErrorHandler(traceHeader string) echo.HTTPErrorHandler {
+	return func(err error, c echo.Context) {
+		parseError := func(err error) (int, string) {
+			echoErr, ok := err.(*echo.HTTPError)
+			if ok {
+				return echoErr.Code, http.StatusText(echoErr.Code)
+			}
+
+			if errors.Is(err, context.DeadlineExceeded) {
+				return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
+			}
+
+			var httpErr HTTPError
+			if errors.As(err, &httpErr) {
+				return httpErr.HTTPError()
+			}
+
+			// Default 500 status code.
+			return http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)
+		}
+
+		status, message := parseError(err)
+
+		logger := c.Get("logger").(*zap.Logger)
+		clientOrNil := c.Get("webhookClient")
+
+		// No webhook client, meaning we can send the error as a response.
+		if clientOrNil == nil {
+			c.Response().Header().Add(echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8)
+
+			err = c.String(status, message)
+
+			if err != nil {
+				logger.Error(fmt.Sprintf("send error response: %s", err.Error()))
+			}
+
+			return
+		}
+
+		// We have to send the error to the webhook.
+		client := clientOrNil.(*webhookClient)
+
+		body := struct {
+			Status  int    `json:"status"`
+			Message string `json:"message"`
+		}{
+			Status:  status,
+			Message: message,
+		}
+
+		b, err := json.Marshal(body)
+		if err != nil {
+			logger.Error(fmt.Sprintf("marshal JSON: %s", err.Error()))
+
+			return
+		}
+
+		headers := map[string]string{
+			echo.HeaderContentType: echo.MIMEApplicationJSONCharsetUTF8,
+			traceHeader:            c.Get("trace").(string),
+		}
+
+		err = client.send(bytes.NewReader(b), headers, true)
+		if err != nil {
+			logger.Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
+		}
+	}
+}
+
+// latencyMiddleware sets the start time in the echo.Context under "startTime".
+// Its value will be used later to calculate a request latency.
+//
+//  startTime := c.Get("startTime").(time.Time)
+func latencyMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			// First piece for calculating the latency.
+			startTime := time.Now()
+			c.Set("startTime", startTime)
+
+			// Call the next middleware in the chain.
+			return next(c)
+		}
+	}
+}
+
+// rootPathMiddleware sets the root path in the echo.Context under "rootPath".
+// Its value may be used to skip a middleware execution based on a request
+// URI.
+//
+//  rootPath := c.Get("rootPath").(string)
+//  healthURI := fmt.Sprintf("%shealth", rootPath)
+//
+//  // Skip the middleware if health check URI.
+//  if c.Request().RequestURI == healthURI {
+//    // Call the next middleware in the chain.
+//    return next(c)
+//  }
+func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			c.Set("rootPath", rootPath)
+
+			// Call the next middleware in the chain.
+			return next(c)
+		}
+	}
+}
+
+// traceMiddleware sets the request identifier in the echo.Context under
+// "trace". Its value is either retrieved from the trace header or generated if
+// the header is not present / its value is empty.
+//
+//  trace := c.Get("trace").(string)
+func traceMiddleware(header string) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			// Get or create the request identifier.
+			trace := c.Request().Header.Get(header)
+
+			if trace == "" {
+				trace = uuid.New().String()
+			}
+
+			c.Set("trace", trace)
+			c.Response().Header().Add(header, trace)
+
+			// Call the next middleware in the chain.
+			return next(c)
+		}
+	}
+}
+
+// loggerMiddleware sets the logger in the echo.Context under "logger" and logs
+// a request result (but does not log a webhook call result, which is the job
+// of the webhookClient).
+//
+//  logger := c.Get("logger").(*zap.Logger)
+func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			startTime := c.Get("startTime").(time.Time)
+			trace := c.Get("trace").(string)
+
+			// Create the request logger and add it to our locals.
+			reqLogger := logger.With(zap.String("trace", trace))
+			c.Set("logger", reqLogger)
+
+			// Call the next middleware in the chain.
+			err := next(c)
+			if err != nil {
+				c.Error(err)
+			}
+
+			if skipHealthRouteLogging {
+				rootPath := c.Get("rootPath").(string)
+				healthURI := fmt.Sprintf("%shealth", rootPath)
+
+				if c.Request().RequestURI == healthURI {
+					return nil
+				}
+			}
+
+			// Last piece for calculating the latency.
+			finishTime := time.Now()
+
+			// Now, let's log!
+			fields := make([]zap.Field, 12)
+			fields[0] = zap.String("remote_ip", c.RealIP())
+			fields[1] = zap.String("host", c.Request().Host)
+			fields[2] = zap.String("uri", c.Request().RequestURI)
+			fields[3] = zap.String("method", c.Request().Method)
+			fields[4] = zap.String("path", func() string {
+				path := c.Request().URL.Path
+
+				if path == "" {
+					path = "/"
+				}
+
+				return path
+			}())
+			fields[5] = zap.String("referer", c.Request().Referer())
+			fields[6] = zap.String("user_agent", c.Request().UserAgent())
+			fields[7] = zap.Int("status", c.Response().Status)
+			fields[8] = zap.Int64("latency", int64(finishTime.Sub(startTime)))
+			fields[9] = zap.String("latency_human", finishTime.Sub(startTime).String())
+			fields[10] = zap.Int64("bytes_in", c.Request().ContentLength)
+			fields[11] = zap.Int64("bytes_out", c.Response().Size)
+
+			if err != nil {
+				reqLogger.Error(err.Error(), fields...)
+			} else {
+				reqLogger.Info("request handled", fields...)
+			}
+
+			return nil
+		}
+	}
+}
+
+type contextMiddlewareConfig struct {
+	traceHeader string
+	timeout     struct {
+		process time.Duration
+		write   time.Duration
+	}
+	webhook struct {
+		allowList      *regexp.Regexp
+		denyList       *regexp.Regexp
+		errorAllowList *regexp.Regexp
+		errorDenyList  *regexp.Regexp
+		maxRetry       int
+		retryMinWait   time.Duration
+		retryMaxWait   time.Duration
+		disable        bool
+	}
+}
+
+// contextMiddleware handles the result of a "multipart/form-data" request. If
+// a webhook URL is present in the headers, exit early and process the result
+// in a goroutine.
+func contextMiddleware(cfg contextMiddlewareConfig) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			webhookURL := c.Request().Header.Get("Gotenberg-Webhook-Url")
+			logger := c.Get("logger").(*zap.Logger).With(zap.Bool("webhook", webhookURL != ""))
+
+			// 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, cfg.timeout.process)
+			if err != nil {
+				cancel()
+
+				return fmt.Errorf("create request context: %w", err)
+			}
+			c.Set("context", ctx)
+
+			// Helper function for retrieving/creating the output filename.
+			outputFilename := func(outputPath string) string {
+				filename := c.Request().Header.Get("Gotenberg-Output-Filename")
+
+				if filename == "" {
+					return filepath.Base(outputPath)
+				}
+
+				return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
+			}
+
+			if webhookURL == "" {
+				defer cancel()
+
+				// No webhook URL, call the next middleware in the chain.
+				err := next(c)
+
+				if err != nil {
+					return err
+				}
+
+				// No error, let's build the output file.
+				outputPath, err := ctx.buildOutputFile()
+				if err != nil {
+					return fmt.Errorf("build output file: %w", err)
+				}
+
+				// Send the output file.
+				err = c.Attachment(outputPath, outputFilename(outputPath))
+				if err != nil {
+					return fmt.Errorf("send response: %w", err)
+				}
+
+				return nil
+			}
+
+			// Ok, we got a webhook URL.
+
+			if cfg.webhook.disable {
+				// The client requested the webhook feature, but it has been
+				// disabled. Let's tell the client about that.
+				cancel()
+
+				return WrapError(
+					errors.New("webhook feature requested but it is disabled"),
+					NewSentinelHTTPError(http.StatusForbidden, "Invalid 'Gotenberg-Webhook-Url' header: feature is disabled"),
+				)
+			}
+
+			// Do we have a webhook error URL in case of... error?
+			webhookErrorURL := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
+
+			if webhookErrorURL == "" {
+				cancel()
+
+				return WrapError(
+					errors.New("empty webhook error URL"),
+					NewSentinelHTTPError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
+				)
+			}
+
+			// Let's check if the webhook URLs are acceptable according to our
+			// allowed/denied lists.
+			filter := func(URL, header string, allowList, denyList *regexp.Regexp) error {
+				if !allowList.MatchString(URL) {
+					return WrapError(
+						fmt.Errorf("'%s' does not match the expression from the allowed list", URL),
+						NewSentinelHTTPError(
+							http.StatusForbidden,
+							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
+						),
+					)
+				}
+
+				if denyList.String() != "" && denyList.MatchString(URL) {
+					return WrapError(
+						fmt.Errorf("'%s' matches the expression from the denied list", URL),
+						NewSentinelHTTPError(
+							http.StatusForbidden,
+							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
+						),
+					)
+				}
+
+				return nil
+			}
+
+			err = filter(webhookURL, "Gotenberg-Webhook-Url", cfg.webhook.allowList, cfg.webhook.denyList)
+			if err != nil {
+				cancel()
+
+				return fmt.Errorf("filter webhook URL: %w", err)
+			}
+
+			err = filter(webhookErrorURL, "Gotenberg-Webhook-Error-Url", cfg.webhook.errorAllowList, cfg.webhook.errorDenyList)
+			if err != nil {
+				cancel()
+
+				return fmt.Errorf("filter webhook error URL: %w", err)
+			}
+
+			// Let's check the HTTP methods for calling the webhook URLs.
+			methodFromHeader := func(header string) (string, error) {
+				method := c.Request().Header.Get(header)
+
+				if method == "" {
+					return http.MethodPost, nil
+				}
+
+				method = strings.ToUpper(method)
+
+				switch method {
+				case http.MethodPost:
+					return method, nil
+				case http.MethodPatch:
+					return method, nil
+				case http.MethodPut:
+					return method, nil
+				}
+
+				return "", WrapError(
+					fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
+					NewSentinelHTTPError(
+						http.StatusBadRequest,
+						fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method),
+					),
+				)
+			}
+
+			webhookMethod, err := methodFromHeader("Gotenberg-Webhook-Method")
+			if err != nil {
+				cancel()
+
+				return fmt.Errorf("get method to use for webhook: %w", err)
+			}
+
+			webhookErrorMethod, err := methodFromHeader("Gotenberg-Webhook-Error-Method")
+			if err != nil {
+				cancel()
+
+				return fmt.Errorf("get method to use for webhook error: %w", err)
+			}
+
+			// What about extra HTTP headers?
+			var extraHTTPHeaders map[string]string
+
+			extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
+			if extraHTTPHeadersJSON != "" {
+				err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
+				if err != nil {
+					cancel()
+
+					return WrapError(
+						fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
+						NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
+					)
+				}
+			}
+
+			client := &webhookClient{
+				url:              webhookURL,
+				method:           webhookMethod,
+				errorURL:         webhookErrorURL,
+				errorMethod:      webhookErrorMethod,
+				extraHTTPHeaders: extraHTTPHeaders,
+				startTime:        c.Get("startTime").(time.Time),
+
+				client: &retryablehttp.Client{
+					HTTPClient: &http.Client{
+						Timeout: cfg.timeout.write,
+					},
+					RetryMax:     cfg.webhook.maxRetry,
+					RetryWaitMin: cfg.webhook.retryMinWait,
+					RetryWaitMax: cfg.webhook.retryMaxWait,
+					Logger: leveledLogger{
+						logger: logger,
+					},
+					CheckRetry: retryablehttp.DefaultRetryPolicy,
+					Backoff:    retryablehttp.DefaultBackoff,
+				},
+				logger: logger,
+			}
+
+			c.Set("webhookClient", client)
+
+			// As a webhook URL has been given, we handle the request in a
+			// goroutine and return immediately.
+			go func() {
+				defer cancel()
+
+				// Call the next middleware in the chain.
+				err := next(c)
+
+				if err != nil {
+					// The process failed for whatever reason. Let's send the
+					// details to the webhook.
+					ctx.Log().Error(err.Error())
+					c.Error(err)
+
+					return
+				}
+
+				// No error, let's get build the output file.
+				outputPath, err := ctx.buildOutputFile()
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
+					c.Error(err)
+
+					return
+				}
+
+				outputFile, err := os.Open(outputPath)
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("open output file: %s", err))
+					c.Error(err)
+
+					return
+				}
+
+				defer func() {
+					err := outputFile.Close()
+					if err != nil {
+						ctx.Log().Error(fmt.Sprintf("close output file: %s", err))
+					}
+				}()
+
+				fileHeader := make([]byte, 512)
+				_, err = outputFile.Read(fileHeader)
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("read header of output file: %s", err))
+					c.Error(err)
+
+					return
+				}
+
+				fileStat, err := outputFile.Stat()
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("get stat from output file: %s", err))
+					c.Error(err)
+
+					return
+				}
+
+				_, err = outputFile.Seek(0, 0)
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("reset output file reader: %s", err))
+					c.Error(err)
+
+					return
+				}
+
+				headers := map[string]string{
+					echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", outputFilename(outputPath)),
+					echo.HeaderContentType:        http.DetectContentType(fileHeader),
+					echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
+					cfg.traceHeader:               c.Get("trace").(string),
+				}
+
+				// Send the output file to the webhook.
+				err = client.send(bufio.NewReader(outputFile), headers, false)
+				if err != nil {
+					ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
+					c.Error(err)
+				}
+			}()
+
+			return c.NoContent(http.StatusNoContent)
+		}
+	}
+}
+
+// timeoutMiddleware manages hard timeout scenarios, i.e., when a route handler
+// fails to timeout as expected.
+func timeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			logger := c.Get("logger").(*zap.Logger)
+
+			// Define a hard timeout if the route handler fails to timeout as
+			// expected.
+			hardTimeoutCtx, hardTimeoutCancel := context.WithTimeout(
+				context.Background(),
+				hardTimeout,
+			)
+			defer hardTimeoutCancel()
+
+			errChan := make(chan error, 1)
+
+			go func() {
+				// In case of hard timeout, a panic may occur.
+				// This deferred function allows us to recover from such scenarios.
+				defer func() {
+					if r := recover(); r != nil {
+						logger.Debug(fmt.Sprintf("recovering from a panic (possible cause being a hard timeout): %s", r))
+					}
+				}()
+
+				// Call the next middleware in the chain.
+				errChan <- next(c)
+			}()
+
+			select {
+			case err := <-errChan:
+				return err
+			case <-hardTimeoutCtx.Done():
+				logger.Debug("hard timeout as the route handler did not timeout as expected")
+
+				return fmt.Errorf("hard timeout: %w", hardTimeoutCtx.Err())
+			}
+		}
+	}
+}

pkg/modules/api/webhook.go

@@ -0,0 +1,139 @@
+package api
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+// webhookClient gathers all the data required to send a request to a webhook.
+type webhookClient struct {
+	url              string
+	method           string
+	errorURL         string
+	errorMethod      string
+	extraHTTPHeaders map[string]string
+	startTime        time.Time
+
+	client *retryablehttp.Client
+	logger *zap.Logger
+}
+
+// send call the webhook either to send the success response or the error response.
+func (webhook webhookClient) send(body io.Reader, headers map[string]string, erroed bool) error {
+	URL := webhook.url
+	if erroed {
+		URL = webhook.errorURL
+	}
+
+	method := webhook.method
+	if erroed {
+		method = webhook.errorMethod
+	}
+
+	req, err := retryablehttp.NewRequest(method, URL, body)
+	if err != nil {
+		return fmt.Errorf("create '%s' request to '%s': %w", method, URL, err)
+	}
+
+	req.Header.Set("User-Agent", "Gotenberg")
+
+	// Extra HTTP headers are the custom headers from the user.
+	for key, value := range webhook.extraHTTPHeaders {
+		req.Header.Set(key, value)
+	}
+
+	// Middleware caller's headers > extra HTTP headers from the user.
+
+	contentLength, ok := headers[echo.HeaderContentLength]
+	if ok {
+		// Golang "http" package should automatically calculate the size of the
+		// body. But, when using a buffered file reader, it does not work.
+		// Worse, the "Content-Length" header is also removed. Therefore, in
+		// order to keep this valuable information, we have to trust the caller
+		// by reading the value of the "Content-Length" entry and set it as the
+		// content length of the request. It's kinda sub-optimal, but hey, at
+		// least it works.
+
+		bodySize, err := strconv.ParseInt(contentLength, 10, 64)
+
+		if err != nil {
+			return fmt.Errorf("parse content length entry: %w", err)
+		}
+
+		req.ContentLength = bodySize
+	}
+
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+
+	resp, err := webhook.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("send '%s' request to '%s': %w", method, URL, err)
+	}
+
+	defer func() {
+		err := resp.Body.Close()
+		if err != nil {
+			webhook.logger.Error(fmt.Sprintf("close response body from '%s': %s", URL, err))
+		}
+	}()
+
+	// Last piece for calculating the latency.
+	finishTime := time.Now()
+
+	// Now let's log!
+	fields := make([]zap.Field, 5)
+	fields[0] = zap.String("webhook_url", URL)
+	fields[1] = zap.String("method", method)
+	fields[2] = zap.Int64("latency", int64(finishTime.Sub(webhook.startTime)))
+	fields[3] = zap.String("latency_human", finishTime.Sub(webhook.startTime).String())
+	fields[4] = zap.Int64("bytes_out", req.ContentLength)
+
+	if erroed {
+		webhook.logger.Warn("request to webhook with error details handled", fields...)
+
+		return nil
+	}
+
+	webhook.logger.Info("request to webhook handled", fields...)
+
+	return nil
+}
+
+// leveledLogger is wrapper around a zap.Logger which is used by the
+// retryablehttp.Client.
+type leveledLogger struct {
+	logger *zap.Logger
+}
+
+// Error logs a message at error level using the wrapped zap.Logger.
+func (leveled leveledLogger) Error(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Warn logs a message at warning level using the wrapped zap.Logger.
+func (leveled leveledLogger) Warn(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Info logs a message at info level using the wrapped zap.Logger.
+func (leveled leveledLogger) Info(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Debug logs a message at debug level using the wrapped zap.Logger.
+func (leveled leveledLogger) Debug(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Interface guards.
+var (
+	_ retryablehttp.LeveledLogger = (*leveledLogger)(nil)
+)

pkg/modules/api/webhook_test.go

@@ -0,0 +1,23 @@
+package api
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestLeveledLogger_Error(t *testing.T) {
+	leveledLogger{logger: zap.NewNop()}.Error("foo")
+}
+
+func TestLeveledLogger_Warn(t *testing.T) {
+	leveledLogger{logger: zap.NewNop()}.Warn("foo")
+}
+
+func TestLeveledLogger_Info(t *testing.T) {
+	leveledLogger{logger: zap.NewNop()}.Info("foo")
+}
+
+func TestLeveledLogger_Debug(t *testing.T) {
+	leveledLogger{logger: zap.NewNop()}.Debug("foo")
+}

pkg/modules/chromium/chromium.go

@@ -0,0 +1,492 @@
+package chromium
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/chromedp/cdproto/fetch"
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/chromedp"
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/zap"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(Chromium{})
+}
+
+var (
+	// ErrURLNotAuthorized happens if a URL is not acceptable according to the
+	// allowed/denied lists.
+	ErrURLNotAuthorized = errors.New("URL not authorized")
+
+	// ErrInvalidPrinterSettings happens if the Options have one or more
+	// aberrant values.
+	ErrInvalidPrinterSettings = errors.New("invalid printer settings")
+
+	// ErrPageRangesSyntaxError happens if the Options have an invalid page
+	// ranges.
+	ErrPageRangesSyntaxError = errors.New("page ranges syntax error")
+
+	// ErrRpccMessageTooLarge happens when the messages received by
+	// ChromeDevTools are larger than 100 MB.
+	ErrRpccMessageTooLarge = errors.New("rpcc message too large")
+)
+
+// Chromium is a module which provides both an API and routes for converting
+// HTML document to PDF.
+type Chromium struct {
+	binPath                 string
+	engine                  gotenberg.PDFEngine
+	userAgent               string
+	incognito               bool
+	ignoreCertificateErrors bool
+	allowList               *regexp.Regexp
+	denyList                *regexp.Regexp
+	disableRoutes           bool
+}
+
+// Options are the available options for converting HTML document to PDF.
+type Options struct {
+	// WaitDelay is the duration to wait when loading an HTML document before
+	// converting it to PDF.
+	// Optional.
+	WaitDelay time.Duration
+
+	// WaitWindowStatus is the window.status value to wait for before
+	// converting an HTML document to PDF.
+	// Optional.
+	WaitWindowStatus string
+
+	// ExtraHTTPHeaders are the HTTP headers to send by Chromium while loading
+	// the HTML document.
+	// Optional.
+	ExtraHTTPHeaders map[string]string
+
+	// Landscape sets the paper orientation.
+	// Optional.
+	Landscape bool
+
+	// PrintBackground prints the background graphics.
+	// Optional.
+	PrintBackground bool
+
+	// Scale is the scale of the page rendering.
+	// Optional.
+	Scale float64
+
+	// PaperWidth is the paper width, in inches.
+	// Optional.
+	PaperWidth float64
+
+	// PaperHeight is the paper height, in inches.
+	// Optional.
+	PaperHeight float64
+
+	// MarginTop is the top margin, in inches.
+	// Optional.
+	MarginTop float64
+
+	// MarginBottom is the bottom margin, in inches.
+	// Optional.
+	MarginBottom float64
+
+	// MarginLeft is the left margin, in inches.
+	// Optional.
+	MarginLeft float64
+
+	// MarginRight is the right margin, in inches.
+	// Optional.
+	MarginRight float64
+
+	// Page ranges to print, e.g., '1-5, 8, 11-13'. Empty means all pages.
+	// Optional.
+	PageRanges string
+
+	// HeaderTemplate is the HTML template of the header. It should be valid
+	// HTML  markup with following classes used to inject printing values into
+	// them:
+	// - date: formatted print date
+	// - title: document title
+	// - url: document location
+	// - pageNumber: current page number
+	// - totalPages: total pages in the document
+	// For example, <span class=title></span> would generate span containing
+	// the title.
+	// Optional.
+	HeaderTemplate string
+
+	// FooterTemplate is the HTML template of the footer. It should use the
+	// same format as the HeaderTemplate.
+	// Optional.
+	FooterTemplate string
+
+	// PreferCSSPageSize defines whether to prefer page size as defined by CSS.
+	// If false, the content will be scaled to fit the paper size.
+	// Optional.
+	PreferCSSPageSize bool
+}
+
+// DefaultOptions returns the default values for Options.
+func DefaultOptions() Options {
+	return Options{
+		WaitDelay:         0,
+		WaitWindowStatus:  "",
+		ExtraHTTPHeaders:  nil,
+		Landscape:         false,
+		PrintBackground:   false,
+		Scale:             1.0,
+		PaperWidth:        8.5,
+		PaperHeight:       11,
+		MarginTop:         0.39,
+		MarginBottom:      0.39,
+		MarginLeft:        0.39,
+		MarginRight:       0.39,
+		PageRanges:        "",
+		HeaderTemplate:    "<html><head></head><body></body></html>",
+		FooterTemplate:    "<html><head></head><body></body></html>",
+		PreferCSSPageSize: false,
+	}
+}
+
+// API helps to interact with Chromium for converting HTML documents to PDF.
+type API interface {
+	PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error
+}
+
+// Provider is a module interface which exposes a method for creating an API
+// for other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(chromium.Provider))
+//		chromium, _ := provider.(chromium.Provider).Chromium()
+//	}
+type Provider interface {
+	Chromium() (API, error)
+}
+
+// Descriptor returns a Chromium's module descriptor.
+func (mod Chromium) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "chromium",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("chromium", flag.ExitOnError)
+			fs.String("chromium-user-agent", "", "Override the default User-Agent header")
+			fs.Bool("chromium-incognito", false, "Start Chromium with incognito mode")
+			fs.Bool("chromium-ignore-certificate-errors", false, "Ignore the certificate errors")
+			fs.String("chromium-allow-list", "", "Set the allowed URLs for Chromium using a regular expression")
+			fs.String("chromium-deny-list", "^file:///[^tmp].*", "Set the denied URLs for Chromium using a regular expression")
+			fs.Bool("chromium-disable-routes", false, "Disable the routes")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(Chromium) },
+	}
+}
+
+// Provision sets the module properties.
+func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	mod.ignoreCertificateErrors = flags.MustBool("chromium-ignore-certificate-errors")
+	mod.allowList = flags.MustRegexp("chromium-allow-list")
+	mod.denyList = flags.MustRegexp("chromium-deny-list")
+	mod.disableRoutes = flags.MustBool("chromium-disable-routes")
+
+	binPath, ok := os.LookupEnv("CHROMIUM_BIN_PATH")
+	if !ok {
+		return errors.New("CHROMIUM_BIN_PATH environment variable is not set")
+	}
+
+	mod.binPath = binPath
+
+	provider, err := ctx.Module(new(gotenberg.PDFEngineProvider))
+	if err != nil {
+		return fmt.Errorf("get PDF engine provider: %w", err)
+	}
+
+	engine, err := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+	if err != nil {
+		return fmt.Errorf("get PDF engine: %w", err)
+	}
+
+	mod.engine = engine
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (mod Chromium) Validate() error {
+	_, err := os.Stat(mod.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("chromium binary path does not exist: %w", err)
+	}
+
+	return nil
+}
+
+// Chromium returns an API for interacting with Chromium for converting HTML
+// documents to PDF.
+func (mod Chromium) Chromium() (API, error) {
+	return mod, nil
+}
+
+// Routes returns the API routes.
+func (mod Chromium) Routes() ([]api.MultipartFormDataRoute, error) {
+	if mod.disableRoutes {
+		return nil, nil
+	}
+
+	return []api.MultipartFormDataRoute{
+		convertURLRoute(mod, mod.engine),
+		convertHTMLRoute(mod, mod.engine),
+		convertMarkdownRoute(mod, mod.engine),
+	}, nil
+}
+
+// PDF converts a URL to PDF. It creates a dedicated Chromium instance.
+// Substantial calls to this method may increase CPU and memory usage
+// drastically. In such a scenario, the given context may also be done before
+// the end of the conversion.
+func (mod Chromium) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error {
+	debug := debugLogger{logger: logger.Named("chromium.debug")}
+	userProfileDirPath := gotenberg.NewDirPath()
+
+	args := append(chromedp.DefaultExecAllocatorOptions[:],
+		chromedp.CombinedOutput(debug),
+		chromedp.ExecPath(mod.binPath),
+		chromedp.NoSandbox,
+		// See:
+		// https://github.com/gotenberg/gotenberg/issues/327
+		// https://github.com/chromedp/chromedp/issues/904
+		chromedp.DisableGPU,
+		// See:
+		// https://github.com/puppeteer/puppeteer/issues/661
+		// https://github.com/puppeteer/puppeteer/issues/2410
+		chromedp.Flag("font-render-hinting", "none"),
+		chromedp.UserDataDir(userProfileDirPath),
+	)
+
+	if mod.userAgent != "" {
+		args = append(args, chromedp.UserAgent(mod.userAgent))
+	}
+
+	if mod.incognito {
+		args = append(args, chromedp.Flag("incognito", mod.incognito))
+	}
+
+	if mod.ignoreCertificateErrors {
+		args = append(args, chromedp.IgnoreCertErrors)
+	}
+
+	allocatorCtx, cancel := chromedp.NewExecAllocator(ctx, args...)
+	defer cancel()
+
+	taskCtx, cancel := chromedp.NewContext(allocatorCtx,
+		chromedp.WithDebugf(debug.Printf),
+	)
+	defer cancel()
+
+	// We validate the "main" URL against our allow / deny lists.
+	if !mod.allowList.MatchString(URL) {
+		return fmt.Errorf("'%s' does not match the expression from the allowed list: %w", URL, ErrURLNotAuthorized)
+	}
+
+	if mod.denyList.String() != "" && mod.denyList.MatchString(URL) {
+		return fmt.Errorf("'%s' matches the expression from the denied list: %w", URL, ErrURLNotAuthorized)
+	}
+
+	printToPDF := func(URL string, options Options, result *[]byte) chromedp.Tasks {
+		// We validate the underlying requests against our allow / deny lists.
+		// If a request does not pass the validation, we make it fail.
+		listenForEventRequestPaused(taskCtx, logger, mod.allowList, mod.denyList)
+
+		return chromedp.Tasks{
+			network.Enable(),
+			fetch.Enable(),
+			chromedp.ActionFunc(func(ctx context.Context) error {
+				if len(options.ExtraHTTPHeaders) == 0 {
+					logger.Debug("no extra HTTP headers")
+
+					return nil
+				}
+
+				logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", options.ExtraHTTPHeaders))
+
+				headers := make(network.Headers, len(options.ExtraHTTPHeaders))
+				for key, value := range options.ExtraHTTPHeaders {
+					headers[key] = value
+				}
+
+				err := network.SetExtraHTTPHeaders(headers).Do(ctx)
+				if err == nil {
+					return nil
+				}
+
+				return fmt.Errorf("set extra HTTP headers: %w", err)
+			}),
+			chromedp.ActionFunc(func(ctx context.Context) error {
+				logger.Debug(fmt.Sprintf("navigate to '%s'", URL))
+
+				_, _, _, err := page.Navigate(URL).Do(ctx)
+				if err != nil {
+					return fmt.Errorf("navigate to '%s': %w", URL, err)
+				}
+
+				err = runBatch(
+					ctx,
+					waitForEventDomContentEventFired(ctx, logger),
+					waitForEventLoadEventFired(ctx, logger),
+					waitForEventNetworkIdle(ctx, logger),
+					waitForEventLoadingFinished(ctx, logger),
+				)
+
+				if err == nil {
+					return nil
+				}
+
+				return fmt.Errorf("wait for events: %w", err)
+			}),
+			chromedp.ActionFunc(func(ctx context.Context) error {
+				if options.WaitDelay > 0 {
+					// We wait for a given amount of time so that JavaScript
+					// scripts have a chance to finish before printing the page
+					// to PDF.
+					logger.Debug(fmt.Sprintf("wait '%s' before print", options.WaitDelay))
+
+					select {
+					case <-ctx.Done():
+						return fmt.Errorf("wait delay: %w", ctx.Err())
+					case <-time.After(options.WaitDelay):
+						return nil
+					}
+				}
+
+				return nil
+			}),
+			chromedp.ActionFunc(func(ctx context.Context) error {
+				if options.WaitWindowStatus == "" {
+					return nil
+				}
+
+				// We wait until the evaluation of
+				// "window.status === options.WaitWindowStatus" is true or
+				// until the context is done.
+				logger.Debug(fmt.Sprintf("wait for window.status === '%s' before print", options.WaitWindowStatus))
+
+				ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
+
+				for {
+					select {
+					case <-ctx.Done():
+						ticker.Stop()
+
+						return fmt.Errorf("wait for window.status === '%s': %w", options.WaitWindowStatus, ctx.Err())
+					case <-ticker.C:
+						var ok bool
+
+						evaluate := chromedp.Evaluate(fmt.Sprintf("window.status === '%s'", options.WaitWindowStatus), &ok)
+						err := evaluate.Do(ctx)
+
+						if err != nil {
+							return fmt.Errorf("evaluate: %w", err)
+						}
+
+						if ok {
+							ticker.Stop()
+
+							return nil
+						}
+
+						continue
+					}
+				}
+			}),
+			chromedp.ActionFunc(func(ctx context.Context) error {
+				printToPDF := page.PrintToPDF().
+					WithLandscape(options.Landscape).
+					WithPrintBackground(options.PrintBackground).
+					WithScale(options.Scale).
+					WithPaperWidth(options.PaperWidth).
+					WithPaperHeight(options.PaperHeight).
+					WithMarginTop(options.MarginTop).
+					WithMarginBottom(options.MarginBottom).
+					WithMarginLeft(options.MarginLeft).
+					WithMarginRight(options.MarginRight).
+					WithIgnoreInvalidPageRanges(false).
+					WithPageRanges(options.PageRanges).
+					WithDisplayHeaderFooter(true).
+					WithHeaderTemplate(options.HeaderTemplate).
+					WithFooterTemplate(options.FooterTemplate).
+					WithPreferCSSPageSize(options.PreferCSSPageSize)
+
+				logger.Debug(fmt.Sprintf("print to PDF with: %+v", printToPDF))
+
+				data, _, err := printToPDF.Do(ctx)
+				if err != nil {
+					return fmt.Errorf("print to PDF: %w", err)
+				}
+
+				*result = data
+
+				return nil
+			}),
+		}
+	}
+
+	var buffer []byte
+	err := chromedp.Run(taskCtx, printToPDF(URL, options, &buffer))
+
+	// Always remove the user profile directory created by Chromium.
+	go func() {
+		logger.Debug(fmt.Sprintf("remove user profile directory '%s'", userProfileDirPath))
+
+		err := os.RemoveAll(userProfileDirPath)
+		if err != nil {
+			logger.Error(fmt.Sprintf("remove user profile directory: %s", err))
+		}
+	}()
+
+	if err != nil {
+		errMessage := err.Error()
+
+		if strings.Contains(errMessage, "Show invalid printer settings error (-32000)") {
+			return ErrInvalidPrinterSettings
+		}
+
+		if strings.Contains(errMessage, "Page range syntax error") {
+			return ErrPageRangesSyntaxError
+		}
+
+		if strings.Contains(errMessage, "rpcc: message too large") {
+			return ErrRpccMessageTooLarge
+		}
+
+		return fmt.Errorf("chromium PDF: %w", err)
+	}
+
+	err = ioutil.WriteFile(outputPath, buffer, 0600)
+	if err != nil {
+		return fmt.Errorf("write result to output path: %w", err)
+	}
+
+	return nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module            = (*Chromium)(nil)
+	_ gotenberg.Provisioner       = (*Chromium)(nil)
+	_ gotenberg.Validator         = (*Chromium)(nil)
+	_ api.MultipartFormDataRouter = (*Chromium)(nil)
+	_ API                         = (*Chromium)(nil)
+	_ Provider                    = (*Chromium)(nil)
+)

pkg/modules/chromium/chromium_test.go

@@ -0,0 +1,373 @@
+package chromium
+
+import (
+	"context"
+	"errors"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"regexp"
+	"testing"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"go.uber.org/zap"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoAPI struct {
+	pdf func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error
+}
+
+func (mod ProtoAPI) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error {
+	return mod.pdf(ctx, logger, URL, outputPath, options)
+}
+
+type ProtoPDFEngineProvider struct {
+	ProtoModule
+	pdfEngine func() (gotenberg.PDFEngine, error)
+}
+
+func (mod ProtoPDFEngineProvider) PDFEngine() (gotenberg.PDFEngine, error) {
+	return mod.pdfEngine()
+}
+
+type ProtoPDFEngine struct {
+	merge   func(_ context.Context, _ *zap.Logger, _ []string, _ string) error
+	convert func(_ context.Context, _ *zap.Logger, _, _, _ string) error
+}
+
+func (mod ProtoPDFEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return mod.merge(ctx, logger, inputPaths, outputPath)
+}
+
+func (mod ProtoPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
+	return mod.convert(ctx, logger, format, inputPath, outputPath)
+}
+
+func TestDefaultOptions(t *testing.T) {
+	actual := DefaultOptions()
+	notExpect := Options{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
+func TestChromium_Descriptor(t *testing.T) {
+	descriptor := Chromium{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Chromium))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestChromium_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       *gotenberg.Context
+		expectErr bool
+	}{
+		{
+			ctx: func() *gotenberg.Context {
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Chromium).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoPDFEngineProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.pdfEngine = func() (gotenberg.PDFEngine, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Chromium).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoPDFEngineProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.pdfEngine = func() (gotenberg.PDFEngine, error) {
+					return struct{ ProtoPDFEngine }{}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Chromium).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+		},
+	} {
+		mod := new(Chromium)
+		err := mod.Provision(tc.ctx)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestChromium_Validate(t *testing.T) {
+	for i, tc := range []struct {
+		binPath   string
+		expectErr bool
+	}{
+		{
+			expectErr: true,
+		},
+		{
+			binPath:   "/foo",
+			expectErr: true,
+		},
+		{
+			binPath: os.Getenv("CHROMIUM_BIN_PATH"),
+		},
+	} {
+		mod := new(Chromium)
+		mod.binPath = tc.binPath
+		err := mod.Validate()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestChromium_Chromium(t *testing.T) {
+	mod := new(Chromium)
+
+	_, err := mod.Chromium()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestChromium_Routes(t *testing.T) {
+	for i, tc := range []struct {
+		expectRoutes  int
+		disableRoutes bool
+	}{
+		{
+			expectRoutes: 3,
+		},
+		{
+			disableRoutes: true,
+		},
+	} {
+		mod := new(Chromium)
+		mod.disableRoutes = tc.disableRoutes
+
+		routes, err := mod.Routes()
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		if tc.expectRoutes != len(routes) {
+			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
+		}
+	}
+}
+
+func TestChromium_PDF(t *testing.T) {
+	for i, tc := range []struct {
+		timeout                 time.Duration
+		cancel                  context.CancelFunc
+		URL                     string
+		options                 Options
+		userAgent               string
+		incognito               bool
+		ignoreCertificateErrors bool
+		allowList               *regexp.Regexp
+		denyList                *regexp.Regexp
+		expectErr               bool
+	}{
+		{
+			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			allowList: regexp.MustCompile("file:///tmp/*"),
+			expectErr: true,
+		},
+		{
+			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			denyList:  regexp.MustCompile("file:///tests/*"),
+			expectErr: true,
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			options: Options{
+				ExtraHTTPHeaders: map[string]string{
+					"foo": "bar",
+				},
+			},
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			options: Options{
+				WaitDelay: time.Duration(1) * time.Nanosecond,
+			},
+		},
+		{
+			timeout: time.Duration(3) * time.Second,
+			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
+			options: Options{
+				WaitWindowStatus: "foo",
+			},
+			expectErr: true,
+		},
+		{
+			timeout: time.Duration(3) * time.Second,
+			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
+			options: Options{
+				WaitWindowStatus: "ready",
+			},
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			options: Options{
+				MarginBottom: 100,
+			},
+			expectErr: true,
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			options: Options{
+				PageRanges: "foo",
+			},
+			expectErr: true,
+		},
+		{
+			URL:                     "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			userAgent:               "foo",
+			incognito:               true,
+			ignoreCertificateErrors: true,
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample1/index.html",
+		},
+		{
+			URL:       "file:///tests/test/testdata/chromium/html/sample3/index.html",
+			allowList: regexp.MustCompile("file:///tests/*"),
+		},
+		{
+			URL:      "file:///tests/test/testdata/chromium/html/sample3/index.html",
+			denyList: regexp.MustCompile("file:///etc/*"),
+		},
+		{
+			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
+			options: Options{
+				HeaderTemplate: func() string {
+					b, err := ioutil.ReadFile("/tests/test/testdata/chromium/url/sample2/header.html")
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+
+					return string(b)
+				}(),
+				FooterTemplate: func() string {
+					b, err := ioutil.ReadFile("/tests/test/testdata/chromium/url/sample2/footer.html")
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+
+					return string(b)
+				}(),
+			},
+		},
+	} {
+		func() {
+			mod := new(Chromium)
+			mod.binPath = os.Getenv("CHROMIUM_BIN_PATH")
+			mod.userAgent = tc.userAgent
+			mod.incognito = tc.incognito
+			mod.ignoreCertificateErrors = tc.ignoreCertificateErrors
+
+			if tc.allowList == nil {
+				tc.allowList = regexp.MustCompile("")
+			}
+
+			if tc.denyList == nil {
+				tc.denyList = regexp.MustCompile("")
+			}
+
+			mod.allowList = tc.allowList
+			mod.denyList = tc.denyList
+
+			outputDir, err := gotenberg.MkdirAll()
+			if err != nil {
+				t.Fatalf("test %d: expected error but got: %v", i, err)
+			}
+
+			defer func() {
+				err := os.RemoveAll(outputDir)
+				if err != nil {
+					t.Fatalf("test %d: expected no error but got: %v", i, err)
+				}
+			}()
+
+			if tc.timeout == 0 {
+				err = mod.PDF(context.Background(), zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
+			} else {
+				ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
+				defer cancel()
+
+				err = mod.PDF(ctx, zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
+			}
+
+			if tc.expectErr && err == nil {
+				t.Errorf("test %d: expected error but got: %v", i, err)
+			}
+
+			if !tc.expectErr && err != nil {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+		}()
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module            = (*ProtoModule)(nil)
+	_ API                         = (*ProtoAPI)(nil)
+	_ gotenberg.PDFEngineProvider = (*ProtoPDFEngineProvider)(nil)
+	_ gotenberg.Module            = (*ProtoPDFEngineProvider)(nil)
+	_ gotenberg.PDFEngine         = (*ProtoPDFEngine)(nil)
+)

pkg/modules/chromium/debug.go

@@ -0,0 +1,31 @@
+package chromium
+
+import (
+	"fmt"
+	"io"
+
+	"go.uber.org/zap"
+)
+
+// debugLogger is wrapper around a zap.Logger which is used for debugging
+// Chromium.
+type debugLogger struct {
+	logger *zap.Logger
+}
+
+// Write logs the bytes in a debug message.
+func (debug debugLogger) Write(p []byte) (n int, err error) {
+	debug.logger.Debug(string(p))
+
+	return len(p), nil
+}
+
+// Printf logs a debug message.
+func (debug debugLogger) Printf(format string, v ...interface{}) {
+	debug.logger.Debug(fmt.Sprintf(format, v...))
+}
+
+// Interface guards.
+var (
+	_ io.Writer = (*debugLogger)(nil)
+)

pkg/modules/chromium/debug_test.go

@@ -0,0 +1,24 @@
+package chromium
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestDebugLogger_Write(t *testing.T) {
+	actual, err := debugLogger{logger: zap.NewNop()}.Write([]byte("foo"))
+	expected := len([]byte("foo"))
+
+	if actual != expected {
+		t.Errorf("expected %d but got %d", expected, actual)
+	}
+
+	if err != nil {
+		t.Errorf("expected not error but got: %v", err)
+	}
+}
+
+func TestDebugLogger_Printf(t *testing.T) {
+	debugLogger{logger: zap.NewNop()}.Printf("%s", "foo")
+}

pkg/modules/chromium/doc.go

@@ -0,0 +1,4 @@
+// Package chromium provides a module which adds routes for converting HTML
+// documents to PDF. Other modules may also retrieve the API provided by this
+// module.
+package chromium

pkg/modules/chromium/events.go

@@ -0,0 +1,170 @@
+package chromium
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+
+	"github.com/chromedp/cdproto/cdp"
+	"github.com/chromedp/cdproto/fetch"
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/chromedp"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+)
+
+// listenForEventRequestPaused listens for requests to check if they are
+// allowed or not.
+func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowList *regexp.Regexp, denyList *regexp.Regexp) {
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch e := ev.(type) {
+		case *fetch.EventRequestPaused:
+			go func() {
+				logger.Debug(fmt.Sprintf("event EventRequestPaused fired for '%s'", e.Request.URL))
+				allow := true
+
+				if !allowList.MatchString(e.Request.URL) {
+					logger.Warn(fmt.Sprintf("'%s' does not match the expression from the allowed list", e.Request.URL))
+					allow = false
+				}
+
+				if denyList.String() != "" && denyList.MatchString(e.Request.URL) {
+					logger.Warn(fmt.Sprintf("'%s' matches the expression from the denied list", e.Request.URL))
+					allow = false
+				}
+
+				cctx := chromedp.FromContext(ctx)
+				executorCtx := cdp.WithExecutor(ctx, cctx.Target)
+
+				if allow {
+					req := fetch.ContinueRequest(e.RequestID)
+					err := req.Do(executorCtx)
+
+					if err != nil {
+						logger.Error(fmt.Sprintf("continue request: %s", err))
+					}
+
+					return
+				}
+
+				req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
+				err := req.Do(executorCtx)
+
+				if err != nil {
+					logger.Error(fmt.Sprintf("fail request: %s", err))
+				}
+			}()
+		}
+	})
+}
+
+// waitForEventDomContentEventFired waits until the event DomContentEventFired
+// is fired or the context timeout.
+func waitForEventDomContentEventFired(ctx context.Context, logger *zap.Logger) func() error {
+	return func() error {
+		ch := make(chan struct{})
+		cctx, cancel := context.WithCancel(ctx)
+		chromedp.ListenTarget(cctx, func(ev interface{}) {
+			switch ev.(type) {
+			case *page.EventDomContentEventFired:
+				cancel()
+				close(ch)
+			}
+		})
+
+		select {
+		case <-ch:
+			logger.Debug("event DomContentEventFired fired")
+			return nil
+		case <-ctx.Done():
+			return fmt.Errorf("wait for event DomContentEventFired: %w", ctx.Err())
+		}
+	}
+}
+
+// waitForEventLoadEventFired waits until the event LoadEventFired is fired or
+// the context timeout.
+func waitForEventLoadEventFired(ctx context.Context, logger *zap.Logger) func() error {
+	return func() error {
+		ch := make(chan struct{})
+		cctx, cancel := context.WithCancel(ctx)
+		chromedp.ListenTarget(cctx, func(ev interface{}) {
+			switch ev.(type) {
+			case *page.EventLoadEventFired:
+				cancel()
+				close(ch)
+			}
+		})
+
+		select {
+		case <-ch:
+			logger.Debug("event LoadEventFired fired")
+			return nil
+		case <-ctx.Done():
+			return fmt.Errorf("wait for event LoadEventFired: %w", ctx.Err())
+		}
+	}
+}
+
+// waitForEventNetworkIdle waits until the event networkIdle is fired or the
+// context timeout.
+func waitForEventNetworkIdle(ctx context.Context, logger *zap.Logger) func() error {
+	return func() error {
+		ch := make(chan struct{})
+		cctx, cancel := context.WithCancel(ctx)
+		chromedp.ListenTarget(cctx, func(ev interface{}) {
+			switch e := ev.(type) {
+			case *page.EventLifecycleEvent:
+				if e.Name == "networkIdle" {
+					cancel()
+					close(ch)
+				}
+			}
+		})
+
+		select {
+		case <-ch:
+			logger.Debug("event networkIdle fired")
+			return nil
+		case <-ctx.Done():
+			return fmt.Errorf("wait for event networkIdle: %w", ctx.Err())
+		}
+	}
+}
+
+// waitForEventLoadingFinished waits until the event LoadingFinished is fired
+// or the context timeout.
+func waitForEventLoadingFinished(ctx context.Context, logger *zap.Logger) func() error {
+	return func() error {
+		ch := make(chan struct{})
+		cctx, cancel := context.WithCancel(ctx)
+		chromedp.ListenTarget(cctx, func(ev interface{}) {
+			switch ev.(type) {
+			case *network.EventLoadingFinished:
+				cancel()
+				close(ch)
+			}
+		})
+
+		select {
+		case <-ch:
+			logger.Debug("event LoadingFinished fired")
+			return nil
+		case <-ctx.Done():
+			return fmt.Errorf("wait for event LoadingFinished: %w", ctx.Err())
+		}
+	}
+}
+
+// runBatch runs all functions simultaneously and waits until all of them are
+// completed or an error is encountered.
+func runBatch(ctx context.Context, fn ...func() error) error {
+	eg, _ := errgroup.WithContext(ctx)
+
+	for _, f := range fn {
+		eg.Go(f)
+	}
+
+	return eg.Wait()
+}

pkg/modules/chromium/routes.go

@@ -0,0 +1,340 @@
+package chromium
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html/template"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/microcosm-cc/bluemonday"
+	"github.com/russross/blackfriday/v2"
+	"go.uber.org/multierr"
+)
+
+// FormDataChromiumPDFOptions creates Options form the form data. Fallback to
+// default value if the considered key is not present.
+func FormDataChromiumPDFOptions(ctx *api.Context) (*api.FormData, Options) {
+	defaultOptions := DefaultOptions()
+
+	var (
+		waitDelay                                        time.Duration
+		waitWindowStatus                                 string
+		extraHTTPHeaders                                 map[string]string
+		landscape, printBackground                       bool
+		scale, paperWidth, paperHeight                   float64
+		marginTop, marginBottom, marginLeft, marginRight float64
+		pageRanges                                       string
+		headerTemplate, footerTemplate                   string
+		preferCSSPageSize                                bool
+	)
+
+	form := ctx.FormData().
+		Duration("waitDelay", &waitDelay, defaultOptions.WaitDelay).
+		String("waitWindowStatus", &waitWindowStatus, defaultOptions.WaitWindowStatus).
+		Custom("extraHttpHeaders", func(value string) error {
+			if value == "" {
+				extraHTTPHeaders = defaultOptions.ExtraHTTPHeaders
+
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &extraHTTPHeaders)
+			if err != nil {
+				return fmt.Errorf("unmarshal extra HTTP headers: %w", err)
+			}
+
+			return nil
+		}).
+		Bool("landscape", &landscape, defaultOptions.Landscape).
+		Bool("printBackground", &printBackground, defaultOptions.PrintBackground).
+		Float64("scale", &scale, defaultOptions.Scale).
+		Float64("paperWidth", &paperWidth, defaultOptions.PaperWidth).
+		Float64("paperHeight", &paperHeight, defaultOptions.PaperHeight).
+		Float64("marginTop", &marginTop, defaultOptions.MarginTop).
+		Float64("marginBottom", &marginBottom, defaultOptions.MarginBottom).
+		Float64("marginLeft", &marginLeft, defaultOptions.MarginLeft).
+		Float64("marginRight", &marginRight, defaultOptions.MarginRight).
+		String("nativePageRanges", &pageRanges, defaultOptions.PageRanges).
+		Content("header.html", &headerTemplate, defaultOptions.HeaderTemplate).
+		Content("footer.html", &footerTemplate, defaultOptions.FooterTemplate).
+		Bool("preferCssPageSize", &preferCSSPageSize, defaultOptions.PreferCSSPageSize)
+
+	options := Options{
+		WaitDelay:         waitDelay,
+		WaitWindowStatus:  waitWindowStatus,
+		ExtraHTTPHeaders:  extraHTTPHeaders,
+		Landscape:         landscape,
+		PrintBackground:   printBackground,
+		Scale:             scale,
+		PaperWidth:        paperWidth,
+		PaperHeight:       paperHeight,
+		MarginTop:         marginTop,
+		MarginBottom:      marginBottom,
+		MarginLeft:        marginLeft,
+		MarginRight:       marginRight,
+		PageRanges:        pageRanges,
+		HeaderTemplate:    headerTemplate,
+		FooterTemplate:    footerTemplate,
+		PreferCSSPageSize: preferCSSPageSize,
+	}
+
+	return form, options
+}
+
+// convertURLRoute returns an api.MultipartFormDataRoute route which can
+// convert a URL to PDF.
+func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
+	return api.MultipartFormDataRoute{
+		Path: "/chromium/convert/url",
+		Handler: func(ctx *api.Context) error {
+			form, options := FormDataChromiumPDFOptions(ctx)
+
+			var (
+				URL       string
+				PDFformat string
+			)
+
+			err := form.
+				MandatoryString("url", &URL).
+				String("pdfFormat", &PDFformat, "").
+				Validate()
+
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			if err != nil {
+				return fmt.Errorf("convert URL to PDF: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+// convertHTMLRoute returns an api.MultipartFormDataRoute route which can
+// convert an HTML file to PDF.
+func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
+	return api.MultipartFormDataRoute{
+		Path: "/chromium/convert/html",
+		Handler: func(ctx *api.Context) error {
+			form, options := FormDataChromiumPDFOptions(ctx)
+
+			var (
+				inputPath string
+				PDFformat string
+			)
+
+			err := form.
+				MandatoryPath("index.html", &inputPath).
+				String("pdfFormat", &PDFformat, "").
+				Validate()
+
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			URL := fmt.Sprintf("file://%s", inputPath)
+
+			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			if err != nil {
+				return fmt.Errorf("convert HTML to PDF: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+// convertMarkdownRoute returns an api.MultipartFormDataRoute route which can
+// convert markdown files to PDF.
+func convertMarkdownRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
+	return api.MultipartFormDataRoute{
+		Path: "/chromium/convert/markdown",
+		Handler: func(ctx *api.Context) error {
+			form, options := FormDataChromiumPDFOptions(ctx)
+
+			var (
+				inputPath     string
+				markdownPaths []string
+				PDFformat     string
+			)
+
+			err := form.
+				MandatoryPath("index.html", &inputPath).
+				MandatoryPaths([]string{".md"}, &markdownPaths).
+				String("pdfFormat", &PDFformat, "").
+				Validate()
+
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			// We have to convert each markdown file referenced in the HTML
+			// file to... HTML. Thanks to the "html/template" package, we are
+			// able to provide the "toHTML" function which the user may call
+			// directly inside the HTML file.
+
+			var markdownFilesNotFoundErr error
+
+			tmpl, err := template.
+				New(filepath.Base(inputPath)).
+				Funcs(template.FuncMap{
+					"toHTML": func(filename string) (template.HTML, error) {
+						var path string
+
+						for _, markdownPath := range markdownPaths {
+							markdownFilename := filepath.Base(markdownPath)
+
+							if filename == markdownFilename {
+								path = markdownPath
+								break
+							}
+						}
+
+						if path == "" {
+							markdownFilesNotFoundErr = multierr.Append(
+								markdownFilesNotFoundErr,
+								fmt.Errorf("'%s'", filename),
+							)
+
+							return "", nil
+						}
+
+						b, err := ioutil.ReadFile(path)
+						if err != nil {
+							return "", fmt.Errorf("read markdown file '%s': %w", filename, err)
+						}
+
+						unsafe := blackfriday.Run(b)
+						sanitized := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
+
+						// #nosec
+						return template.HTML(sanitized), nil
+					},
+				}).ParseFiles(inputPath)
+
+			if err != nil {
+				return fmt.Errorf("parse template file: %w", err)
+			}
+
+			var buffer bytes.Buffer
+
+			err = tmpl.Execute(&buffer, &struct{}{})
+			if err != nil {
+				return fmt.Errorf("execute template: %w", err)
+			}
+
+			if markdownFilesNotFoundErr != nil {
+				return api.WrapError(
+					fmt.Errorf("markdown files not found: %w", markdownFilesNotFoundErr),
+					api.NewSentinelHTTPError(
+						http.StatusBadRequest,
+						fmt.Sprintf("Markdown file(s) not found: %s", markdownFilesNotFoundErr),
+					),
+				)
+			}
+
+			inputPath = ctx.GeneratePath(".html")
+
+			err = os.WriteFile(inputPath, buffer.Bytes(), 0600)
+			if err != nil {
+				return fmt.Errorf("write template result: %w", err)
+			}
+
+			URL := fmt.Sprintf("file://%s", inputPath)
+
+			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			if err != nil {
+				return fmt.Errorf("convert markdown to PDF: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+// convertURL is a stub which is called by the other methods of this file.
+func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL, PDFformat string, options Options) error {
+	outputPath := ctx.GeneratePath(".pdf")
+
+	err := chromium.PDF(ctx, ctx.Log(), URL, outputPath, options)
+	if err != nil {
+
+		if errors.Is(err, ErrURLNotAuthorized) {
+			return api.WrapError(
+				fmt.Errorf("convert to PDF: %w", err),
+				api.NewSentinelHTTPError(
+					http.StatusForbidden,
+					fmt.Sprintf("'%s' does not match the authorized URLs", URL),
+				),
+			)
+		}
+
+		if errors.Is(err, ErrInvalidPrinterSettings) {
+			return api.WrapError(
+				fmt.Errorf("convert to PDF: %w", err),
+				api.NewSentinelHTTPError(
+					http.StatusBadRequest,
+					"Chromium does not handle the provided settings; please check for aberrant form values",
+				),
+			)
+		}
+
+		if errors.Is(err, ErrPageRangesSyntaxError) {
+			return api.WrapError(
+				fmt.Errorf("convert to PDF: %w", err),
+				api.NewSentinelHTTPError(
+					http.StatusBadRequest,
+					fmt.Sprintf("Chromium does not handle the page ranges '%s' (nativePageRanges)", options.PageRanges),
+				),
+			)
+		}
+
+		return fmt.Errorf("convert to PDF: %w", err)
+	}
+
+	// So far so good, the URL has been converted to PDF.
+	// Now, let's check if the client want to convert this result PDF
+	// to a specific PDF format.
+
+	if PDFformat != "" {
+		convertInputPath := outputPath
+		convertOutputPath := ctx.GeneratePath(".pdf")
+
+		err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPath)
+
+		if err != nil {
+			if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+				return api.WrapError(
+					fmt.Errorf("convert PDF: %w", err),
+					api.NewSentinelHTTPError(
+						http.StatusBadRequest,
+						fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+					),
+				)
+			}
+
+			return fmt.Errorf("convert PDF: %w", err)
+		}
+
+		// Important: the output path is now the converted file.
+		outputPath = convertOutputPath
+	}
+
+	err = ctx.AddOutputPaths(outputPath)
+	if err != nil {
+		return fmt.Errorf("add output path: %w", err)
+	}
+
+	return nil
+}

pkg/modules/chromium/routes_test.go

@@ -0,0 +1,699 @@
+package chromium
+
+import (
+	"context"
+	"errors"
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"net/http"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"go.uber.org/zap"
+)
+
+func TestFormDataChromiumPDFOptions(t *testing.T) {
+	for i, tc := range []struct {
+		ctx     *api.MockContext
+		options Options
+	}{
+		{
+			ctx:     &api.MockContext{Context: &api.Context{}},
+			options: DefaultOptions(),
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			options: DefaultOptions(),
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						`{"foo":"bar"}`,
+					},
+				})
+
+				return ctx
+			}(),
+			options: func() Options {
+				options := DefaultOptions()
+				options.ExtraHTTPHeaders = map[string]string{
+					"foo": "bar",
+				}
+
+				return options
+			}(),
+		},
+	} {
+		_, actual := FormDataChromiumPDFOptions(tc.ctx.Context)
+
+		if !reflect.DeepEqual(actual, tc.options) {
+			t.Errorf("test %d: expected %v but got: %v", i, tc.options, actual)
+		}
+	}
+}
+
+func TestConvertURLHandler(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                    *api.MockContext
+		api                    API
+		expectErr              bool
+		expectHTTPErr          bool
+		expectHTTPStatus       int
+		expectOutputPathsCount int
+	}{
+		{
+			ctx:              &api.MockContext{Context: &api.Context{}},
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetValues(map[string][]string{
+					"url": {
+						"",
+					},
+				})
+
+				return ctx
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetValues(map[string][]string{
+					"url": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetValues(map[string][]string{
+					"url": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			expectOutputPathsCount: 1,
+		},
+	} {
+		err := convertURLRoute(tc.api, nil).Handler(tc.ctx.Context)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr api.HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+
+		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+		}
+	}
+}
+
+func TestConvertHTMLHandler(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                    *api.MockContext
+		api                    API
+		expectErr              bool
+		expectHTTPErr          bool
+		expectHTTPStatus       int
+		expectOutputPathsCount int
+	}{
+		{
+			ctx:              &api.MockContext{Context: &api.Context{}},
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"foo.html": "/foo/foo.html",
+				})
+
+				return ctx
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html": "/foo/foo.html",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html": "/foo/foo.html",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			expectOutputPathsCount: 1,
+		},
+	} {
+		err := convertHTMLRoute(tc.api, nil).Handler(tc.ctx.Context)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr api.HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+
+		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+		}
+	}
+}
+
+func TestConvertMarkdownHandler(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                    *api.MockContext
+		api                    API
+		outputDir              string
+		expectErr              bool
+		expectHTTPErr          bool
+		expectHTTPStatus       int
+		expectOutputPathsCount int
+	}{
+		{
+			ctx:              &api.MockContext{Context: &api.Context{}},
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"foo.html": "/foo/foo.html",
+				})
+
+				return ctx
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html": "/foo/foo.html",
+				})
+
+				return ctx
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html":  "/foo/foo.html",
+					"markdown.md": "/foo/markdown.md",
+				})
+
+				return ctx
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample2/index.html",
+					"markdown1.md": "/foo/markdown1.md",
+				})
+
+				return ctx
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample1/index.html",
+					"markdown1.md": "/foo/markdown1.md",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample1/index.html",
+					"markdown1.md": "/tests/test/testdata/chromium/markdown/sample1/markdown1.md",
+					"markdown2.md": "/tests/test/testdata/chromium/markdown/sample1/markdown2.md",
+					"markdown3.md": "/tests/test/testdata/chromium/markdown/sample1/markdown3.md",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetDirPath("/tmp/foo")
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample1/index.html",
+					"markdown1.md": "/tests/test/testdata/chromium/markdown/sample1/markdown1.md",
+					"markdown2.md": "/tests/test/testdata/chromium/markdown/sample1/markdown2.md",
+					"markdown3.md": "/tests/test/testdata/chromium/markdown/sample1/markdown3.md",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			outputDir: "/tmp/foo",
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetDirPath("/tmp/foo")
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample1/index.html",
+					"markdown1.md": "/tests/test/testdata/chromium/markdown/sample1/markdown1.md",
+					"markdown2.md": "/tests/test/testdata/chromium/markdown/sample1/markdown2.md",
+					"markdown3.md": "/tests/test/testdata/chromium/markdown/sample1/markdown3.md",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			outputDir:              "/tmp/foo",
+			expectOutputPathsCount: 1,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetDirPath("/tmp/foo")
+				ctx.SetFiles(map[string]string{
+					"index.html":   "/tests/test/testdata/chromium/markdown/sample3/index.html",
+					"markdown1.md": "/tests/test/testdata/chromium/markdown/sample3/markdown.md",
+				})
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			outputDir:              "/tmp/foo",
+			expectOutputPathsCount: 1,
+		},
+	} {
+		func() {
+			if tc.outputDir != "" {
+				err := os.MkdirAll(tc.outputDir, 0755)
+
+				if err != nil {
+					t.Fatalf("test %d: expected error but got: %v", i, err)
+				}
+
+				defer func() {
+					err := os.RemoveAll(tc.outputDir)
+					if err != nil {
+						t.Fatalf("test %d: expected no error but got: %v", i, err)
+					}
+				}()
+			}
+
+			err := convertMarkdownRoute(tc.api, nil).Handler(tc.ctx.Context)
+
+			if tc.expectErr && err == nil {
+				t.Errorf("test %d: expected error but got: %v", i, err)
+			}
+
+			if !tc.expectErr && err != nil {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+
+			var httpErr api.HTTPError
+			isHTTPErr := errors.As(err, &httpErr)
+
+			if tc.expectHTTPErr && !isHTTPErr {
+				t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+			}
+
+			if !tc.expectHTTPErr && isHTTPErr {
+				t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+			}
+
+			if err != nil && tc.expectHTTPErr && isHTTPErr {
+				status, _ := httpErr.HTTPError()
+				if status != tc.expectHTTPStatus {
+					t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+				}
+			}
+
+			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+				t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+			}
+		}()
+	}
+}
+
+func TestConvertURL(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                    *api.MockContext
+		api                    API
+		engine                 gotenberg.PDFEngine
+		PDFformat              string
+		expectErr              bool
+		expectHTTPErr          bool
+		expectHTTPStatus       int
+		expectOutputPathsCount int
+	}{
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return ErrURLNotAuthorized
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusForbidden,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return ErrInvalidPrinterSettings
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return ErrPageRangesSyntaxError
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return errors.New("foo")
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return gotenberg.ErrPDFFormatNotAvailable
+					},
+				}
+			}(),
+			PDFformat:        "foo",
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return errors.New("foo")
+					},
+				}
+			}(),
+			PDFformat: "foo",
+			expectErr: true,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return nil
+					},
+				}
+			}(),
+			PDFformat:              "foo",
+			expectOutputPathsCount: 1,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+				ctx.SetCancelled(true)
+
+				return ctx
+			}(),
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() API {
+				chromiumAPI := struct{ ProtoAPI }{}
+				chromiumAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error {
+					return nil
+				}
+
+				return chromiumAPI
+			}(),
+			expectOutputPathsCount: 1,
+		},
+	} {
+		err := convertURL(tc.ctx.Context, tc.api, tc.engine, "", tc.PDFformat, DefaultOptions())
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr api.HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+
+		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+		}
+	}
+}

pkg/modules/gc/doc.go

@@ -0,0 +1,3 @@
+// Package gc provides a module for removing files and directories that have
+// expired.
+package gc