Merge pull request #303 from thecodingmachine/missing-fonts

Add missing fonts from 6.4.1

.github/CODE_OF_CONDUCT.md

@@ -43,4 +43,4 @@ Project maintainers who do not follow or enforce the Code of Conduct in good fai
 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/
+[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -8,7 +8,7 @@ find below useful information about how to contribute to the Gotenberg project.
 ### Install from sources
 
 1. Install and run the latest version of Docker
-2. Verify your Go version (>= 1.12)
+2. Verify your Go version (>= 1.14)
 3. Fork this repository
 4. Clone it outside of your `GOPATH` (we're using Go modules)
 
@@ -36,4 +36,4 @@ add a new one!
 
 * [Code of conduct](CODE_OF_CONDUCT.md)
 * [Issue template](ISSUE_TEMPLATE.md)
-* [Pull request template](PULL_REQUEST_TEMPLATE.md)
+* [Pull request template](PULL_REQUEST_TEMPLATE.md)

.github/ISSUE_TEMPLATE.md

@@ -21,6 +21,9 @@ Please search on the [issue tracker](../../../issues) before creating one.
 3.
 4.
 
+## Logs (LOG_LEVEL="DEBUG")
+<!--- Include here a relevant snippet of the log entries of your Gotenberg instance -->
+
 ## 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 -->
@@ -29,4 +32,4 @@ Please search on the [issue tracker](../../../issues) before creating one.
 <!--- Include as many relevant details about the environment you experienced the bug in -->
 * Version used:
 * Operating System and version:
-* Link to your project:
+* Link to your project:

.github/PULL_REQUEST_TEMPLATE.md

@@ -40,6 +40,6 @@ Fixes #
 - [ ] Have you lint your code locally prior to submission (`make lint`)?
 - [ ] Have you written new tests for your core changes, as applicable?
 - [ ] Have you successfully ran tests with your changes locally (`make tests`)?
-- [ ] Have you updated the documentation (`make doc`)?
+- [ ] Have you updated the documentation (Markdown files under `build > docs > content` and then `make doc`)?
 - [ ] I have squashed any insignificant commits
-- [ ] This change has comments for package types, values, functions, and non-obvious lines of code
+- [ ] This change has comments for package types, values, functions, and non-obvious lines of code

.github/workflows/tests_maybe_release.yml

@@ -0,0 +1,26 @@
+name: tests_maybe_release
+
+on:
+  push:
+  pull_request:
+  release:
+    types: [published]
+
+jobs:
+  tests_maybe_release:
+    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
+      - uses: actions/checkout@v1
+      - name: Lint code
+        run: make lint
+      - name: Run tests
+        run: |
+          make tests CODE_COVERAGE=1
+          bash <(curl -s https://codecov.io/bash)
+      - name: Release
+        if: ${{ github.event_name == 'release' }}
+        run: make publish VERSION=${{ github.event.release.tag_name }} DOCKER_USER=${{ secrets.DOCKER_USER }} DOCKER_PASSWORD=${{ secrets.DOCKER_PASSWORD }}

.gitignore

@@ -0,0 +1,2 @@
+.idea
+coverage.txt

.travis.yml

@@ -1,25 +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=
-
-stages:
-  - tests
-  - publish
-
-jobs:
-  include:
-    - stage: tests
-      script: make lint
-    - stage: tests
-      script: make tests
-    - stage: publish
-      if: tag IS present
-      script: make publish VERSION=$TRAVIS_TAG DOCKER_USER=$DOCKER_USER DOCKER_PASSWORD=$DOCKER_PASS

Makefile

@@ -1,12 +1,34 @@
-GOLANG_VERSION=1.12
+GOLANG_VERSION=1.14
 VERSION=snapshot
 DOCKER_USER=
 DOCKER_PASSWORD=
+DOCKER_REGISTRY=thecodingmachine
+GOTENBERG_USER_GID=1001
+GOTENBERG_USER_UID=1001
+GOLANGCI_LINT_VERSION=1.27.0
+CODE_COVERAGE=0
+TINI_VERSION=0.19.0
+MAXIMUM_WAIT_TIMEOUT=30.0
+MAXIMUM_WAIT_DELAY=10.0
+MAXIMUM_WEBHOOK_URL_TIMEOUT=30.0
+DEFAULT_WAIT_TIMEOUT=10.0
+DEFAULT_WEBHOOK_URL_TIMEOUT=10.0
+DEFAULT_LISTEN_PORT=3000
+DISABLE_GOOGLE_CHROME=0
+DISABLE_UNOCONV=0
+LOG_LEVEL=INFO
+ROOT_PATH=/
+DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE=1048576
+GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS=0
 
-# generate documentation.
-doc:
-	docker build --build-arg GOLANG_VERSION=$(GOLANG_VERSION) -t thecodingmachine/gotenberg:docs -f build/docs/Dockerfile . 
-	docker run --rm -it -v "$(PWD):/docs" thecodingmachine/gotenberg:docs
+# build the base Docker image.
+base:
+	docker build --build-arg GOTENBERG_USER_GID=$(GOTENBERG_USER_GID) --build-arg GOTENBERG_USER_UID=$(GOTENBERG_USER_UID) -t $(DOCKER_REGISTRY)/gotenberg:base -f build/base/Dockerfile .
+
+# build the workspace Docker image.
+workspace:
+	make base
+	docker build --build-arg GOLANG_VERSION=$(GOLANG_VERSION) -t $(DOCKER_REGISTRY)/gotenberg:workspace -f build/workspace/Dockerfile . 
 
 # gofmt and goimports all go files.
 fmt:
@@ -15,24 +37,30 @@ fmt:
 
 # run all linters.
 lint:
-	docker build --build-arg GOLANG_VERSION=$(GOLANG_VERSION) -t thecodingmachine/gotenberg:lint -f build/lint/Dockerfile .
-	docker run --rm -it -v "$(PWD):/lint" thecodingmachine/gotenberg:lint
+	docker build --build-arg GOLANGCI_LINT_VERSION=$(GOLANGCI_LINT_VERSION) -t $(DOCKER_REGISTRY)/gotenberg:lint -f build/lint/Dockerfile .
+	docker run --rm $(DOCKER_REGISTRY)/gotenberg:lint
 
 # run all tests.
 tests:
-	docker build -t thecodingmachine/gotenberg:base -f build/base/Dockerfile .
-	docker build --build-arg GOLANG_VERSION=$(GOLANG_VERSION) -t thecodingmachine/gotenberg:tests -f build/tests/Dockerfile .
-	docker run --rm -it -v "$(PWD):/tests" thecodingmachine/gotenberg:tests
+	make workspace
+	./scripts/tests.sh $(DOCKER_REGISTRY) $(CODE_COVERAGE)
 
-# build Docker image.
+# generate documentation.
+doc:
+	make workspace
+	docker build -t $(DOCKER_REGISTRY)/gotenberg:docs -f build/docs/Dockerfile . 
+	docker run --rm -it -v "$(PWD):/gotenberg/docs" $(DOCKER_REGISTRY)/gotenberg:docs
+
+# build Gotenberg Docker image.
 image:
-	docker build -t thecodingmachine/gotenberg:base -f build/base/Dockerfile .
-	docker build --build-arg GOLANG_VERSION=$(GOLANG_VERSION) --build-arg VERSION=$(VERSION) -t thecodingmachine/gotenberg:$(VERSION) -f build/package/Dockerfile .
+	make workspace
+	docker build --build-arg VERSION=$(VERSION) --build-arg TINI_VERSION=$(TINI_VERSION) -t $(DOCKER_REGISTRY)/gotenberg:$(VERSION) -f build/package/Dockerfile .
 
 # start the API using previously built Docker image.
 gotenberg:
-	docker run -it --rm -p "3000:3000" thecodingmachine/gotenberg:$(VERSION)
+	docker run -it --rm -e MAXIMUM_WAIT_TIMEOUT=$(MAXIMUM_WAIT_TIMEOUT) -e MAXIMUM_WAIT_DELAY=$(MAXIMUM_WAIT_DELAY) -e MAXIMUM_WEBHOOK_URL_TIMEOUT=$(MAXIMUM_WEBHOOK_URL_TIMEOUT) -e DEFAULT_WEBHOOK_URL_TIMEOUT=$(DEFAULT_WEBHOOK_URL_TIMEOUT) -e MAXIMUM_WEBHOOK_URL_TIMEOUT=$(MAXIMUM_WEBHOOK_URL_TIMEOUT) -e DEFAULT_LISTEN_PORT=$(DEFAULT_LISTEN_PORT) -e DISABLE_GOOGLE_CHROME=$(DISABLE_GOOGLE_CHROME) -e DISABLE_UNOCONV=$(DISABLE_UNOCONV) -e LOG_LEVEL=$(LOG_LEVEL) -e ROOT_PATH=$(ROOT_PATH) -e DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE=$(DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE) -e GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS=$(GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS)  -p "$(DEFAULT_LISTEN_PORT):$(DEFAULT_LISTEN_PORT)" $(DOCKER_REGISTRY)/gotenberg:$(VERSION)
 
 # publish Gotenberg images according to version.
 publish:
-	./scripts/publish.sh $(GOLANG_VERSION) $(VERSION) $(DOCKER_USER) $(DOCKER_PASSWORD)
+	make workspace
+	./scripts/publish.sh $(GOLANG_VERSION) $(TINI_VERSION) $(DOCKER_REGISTRY) $(VERSION) $(DOCKER_USER) $(DOCKER_PASSWORD)

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-    <img src="https://user-images.githubusercontent.com/8983173/50009948-84b01e00-ffb8-11e8-850b-fc240382c626.png" alt="Gotenberg logo" width="250" height="250" />
+    <img src="https://user-images.githubusercontent.com/8983173/69229423-ac731300-0b85-11ea-8c2e-2cc00ecdb269.PNG" alt="Gotenberg logo" width="250" height="250" />
 </p>
 <h3 align="center">Gotenberg</h3>
 <p align="center">A Docker-powered stateless API for converting HTML, Markdown and Office documents to PDF.</p>
@@ -13,9 +13,7 @@ At TheCodingMachine, we build a lot of web applications (intranets, extranets an
 
 * HTML and Markdown conversions using Google Chrome headless
 * Office conversions (.txt, .rtf, .docx, .doc, .odt, .pptx, .ppt, .odp and so on) using [unoconv](https://github.com/dagwieers/unoconv)
-* Performance :zap:: Google Chrome and LibreOffice (unoconv) started once in the background thanks to PM2
-* Failure prevention :broken_heart:: PM2 automatically restarts previous processes if they fail
-* Assets :package:: send your header, footer, images, fonts, stylesheets and so on for converting your HTML and Markdown to beaufitul PDFs!
+* Assets :package:: send your header, footer, images, fonts, stylesheets and so on for converting your HTML and Markdown to beautiful PDFs!
 * Easily interact with the API using our [Go](https://github.com/thecodingmachine/gotenberg-go-client) and [PHP](https://github.com/thecodingmachine/gotenberg-php-client) libraries
 
 ## Quick start
@@ -23,7 +21,7 @@ At TheCodingMachine, we build a lot of web applications (intranets, extranets an
 Open a terminal and run the following command:
 
 ```bash
-$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:5
+$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:6
 ```
 
 The API is now available on your host at `http://localhost:3000`.
@@ -33,11 +31,15 @@ to learn how to interact with it!
 
 ## Badges
 
-[![Docker image layers](https://images.microbadger.com/badges/image/thecodingmachine/gotenberg:5.svg)](https://microbadger.com/images/thecodingmachine/gotenberg:5)
-[![Travis CI](https://travis-ci.org/thecodingmachine/gotenberg.svg?branch=master)](https://travis-ci.org/thecodingmachine/gotenberg)
+[![Docker pulls](https://img.shields.io/docker/pulls/thecodingmachine/gotenberg)](https://hub.docker.com/r/thecodingmachine/gotenberg)
+[![Docker image layers](https://images.microbadger.com/badges/image/thecodingmachine/gotenberg:6.svg)](https://microbadger.com/images/thecodingmachine/gotenberg:6)
+[![GitHub Actions](https://github.com/thecodingmachine/gotenberg/workflows/tests_maybe_release/badge.svg)](https://github.com/thecodingmachine/gotenberg/workflows/tests_maybe_release)
 [![GoDoc](https://godoc.org/github.com/thecodingmachine/gotenberg?status.svg)](https://godoc.org/github.com/thecodingmachine/gotenberg)
+[![Codecov](https://codecov.io/gh/thecodingmachine/gotenberg/branch/master/graph/badge.svg)](https://codecov.io/gh/thecodingmachine/gotenberg)
 [![Go Report Card](https://goreportcard.com/badge/github.com/thecodingmachine/gotenberg)](https://goreportcard.com/report/thecodingmachine/gotenberg)
 
 ---
 
-Psst: TheCodingMachine is always looking for [talented coders](https://coders.thecodingmachine.com).
+<p align="center">
+    <img src="https://user-images.githubusercontent.com/8983173/50009948-84b01e00-ffb8-11e8-850b-fc240382c626.png" alt="Gotenberg logo" width="150" height="150" />
+</p>

build/base/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:9.5-slim
+FROM debian:buster-slim
 
 # |--------------------------------------------------------------------------
 # | Common libraries
@@ -6,22 +6,17 @@ FROM debian:9.5-slim
 # |
 # | Libraries used in the build process of this image.
 # |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y curl wget python3-pip ttf-mscorefonts-installer
+RUN apt-get update &&\
+    apt-get --no-install-recommends install -y ca-certificates curl gnupg procps &&\
+    rm -rf /var/lib/apt/lists/*
 
 # |--------------------------------------------------------------------------
-# | PM2
+# | Microsoft font installer
 # |--------------------------------------------------------------------------
-# |
-# | Installs PM2 for launching programs in background and with failure 
-# | recovering. In our case: Chrome (headless) and Office (headless). 
-# |
-
-RUN curl -sL https://deb.nodesource.com/setup_9.x | bash - &&\
-    apt-get install -y nodejs &&\
-    npm install -g pm2
+RUN apt-get update &&\
+    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 &&\
+    apt --no-install-recommends install -y ./ttf-mscorefonts-installer_3.8_all.deb && rm ./ttf-mscorefonts-installer_3.8_all.deb &&\
+    rm -rf /var/lib/apt/lists/*
 
 # |--------------------------------------------------------------------------
 # | Chrome
@@ -29,23 +24,39 @@ RUN curl -sL https://deb.nodesource.com/setup_9.x | bash - &&\
 # |
 # | Installs Chrome.
 # |
-
-RUN wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | apt-key add - &&\
+RUN 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 &&\
-    apt-get -y --allow-unauthenticated install google-chrome-stable
+    apt-get install --no-install-recommends -y --allow-unauthenticated google-chrome-stable &&\
+    rm -rf /var/lib/apt/lists/*
+
+# |--------------------------------------------------------------------------
+# | LibreOffice
+# |--------------------------------------------------------------------------
+# |
+# | Installs LibreOffice.
+# |
+
+# https://github.com/nextcloud/docker/issues/380
+RUN mkdir -p /usr/share/man/man1mkdir -p /usr/share/man/man1 &&\ 
+    echo "deb http://httpredir.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list &&\
+    apt-get update &&\
+    apt-get --no-install-recommends -t buster-backports -y install libreoffice &&\
+    rm -rf /var/lib/apt/lists/*
 
 # |--------------------------------------------------------------------------
 # | Unoconv
 # |--------------------------------------------------------------------------
 # |
-# | Installs unoconv and LibreOffice.
+# | Installs unoconv.
 # |
 
-RUN pip3 install unoconv &&\
-    # https://github.com/nextcloud/docker/issues/380
-    mkdir -p /usr/share/man/man1mkdir -p /usr/share/man/man1 &&\
-    apt-get -y install libreoffice
+ENV UNO_URL=https://raw.githubusercontent.com/dagwieers/unoconv/master/unoconv
+
+RUN curl -Ls $UNO_URL -o /usr/bin/unoconv &&\
+    chmod +x /usr/bin/unoconv &&\
+    ln -s /usr/bin/python3 /usr/bin/python &&\
+    unoconv --version
 
 # |--------------------------------------------------------------------------
 # | PDFtk
@@ -55,7 +66,10 @@ RUN pip3 install unoconv &&\
 # | https://github.com/thecodingmachine/gotenberg/issues/29
 # |
 
-RUN apt-get -y install pdftk
+ARG PDFTK_VERSION=924565150
+
+RUN curl -o /usr/bin/pdftk "https://gitlab.com/pdftk-java/pdftk/-/jobs/${PDFTK_VERSION}/artifacts/raw/build/native-image/pdftk" \
+    && chmod a+x /usr/bin/pdftk
 
 # |--------------------------------------------------------------------------
 # | Fonts
@@ -68,7 +82,8 @@ RUN apt-get -y install pdftk
 # 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
-RUN apt-get install -y \
+RUN apt-get update &&\
+    apt-get install --no-install-recommends -y \
     culmus \
     fonts-beng \
     fonts-hosny-amiri \
@@ -83,11 +98,41 @@ RUN apt-get install -y \
     fonts-sil-padauk \
     fonts-telu \
     fonts-thai-tlwg \
-    ttf-liberation \
     ttf-wqy-zenhei \
     fonts-arphic-uming \
     fonts-ipafont-mincho \
     fonts-ipafont-gothic \
-    fonts-unfonts-core
+    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 -rf /var/lib/apt/lists/*
 
+COPY build/base/fonts/* /usr/local/share/fonts/
 COPY build/base/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
+
+# |--------------------------------------------------------------------------
+# | Default user
+# |--------------------------------------------------------------------------
+# |
+# | All processes in the Docker container will run as a dedicated 
+# | non-root user.
+# |
+
+ARG GOTENBERG_USER_GID=1001
+ARG GOTENBERG_USER_UID=1001
+
+RUN groupadd --gid ${GOTENBERG_USER_GID} gotenberg \
+  && useradd --uid ${GOTENBERG_USER_UID} --gid gotenberg --shell /bin/bash --home /gotenberg --no-create-home gotenberg \
+  && mkdir /gotenberg \
+  && chown gotenberg: /gotenberg

build/docs/Dockerfile

@@ -1,6 +1,4 @@
-ARG GOLANG_VERSION
-
-FROM golang:${GOLANG_VERSION}-stretch
+FROM thecodingmachine/gotenberg:workspace
 
 # |--------------------------------------------------------------------------
 # | static
@@ -19,6 +17,6 @@ RUN go get github.com/apex/static/cmd/static-docs
 # | Last instructions of this build.
 # |
 
-WORKDIR /docs
+WORKDIR /gotenberg/docs
 
 CMD [ "static-docs", "--in", "build/docs/content", "--out", "docs", "--theme", "gotenberg", "--title", "Gotenberg", "--subtitle", "A Docker-powered stateless API for converting HTML, Markdown and Office documents to PDF." ]

build/docs/content/00-introduction.md

@@ -6,7 +6,5 @@ title: Introduction
 
 * HTML and Markdown conversions using Google Chrome headless
 * Office conversions (.txt, .rtf, .docx, .doc, .odt, .pptx, .ppt, .odp and so on) using [unoconv](https://github.com/dagwieers/unoconv)
-* Performance: Google Chrome and LibreOffice (unoconv) started once in the background thanks to PM2
-* Failure prevention: PM2 automatically restarts previous processes if they fail
 * Assets: send your header, footer, images, fonts, stylesheets and so on for converting your HTML and Markdown to beaufitul PDFs!
-* Easily interact with the API using our [Go](https://github.com/thecodingmachine/gotenberg-go-client) and [PHP](https://github.com/thecodingmachine/gotenberg-php-client) libraries
+* Easily interact with the API using our [Go](https://github.com/thecodingmachine/gotenberg-go-client) and [PHP](https://github.com/thecodingmachine/gotenberg-php-client) libraries

build/docs/content/01-install.md

@@ -4,14 +4,33 @@ title: Install
 
 Gotenberg is shipped within a Docker image.
 
+**[Gotenberg should ONLY be used in a trusted network by trusted applications. Do NOT expose Gotenberg to the external world.](https://blazej-adamczyk.medium.com/0-day-bug-breaks-multi-million-dollar-system-38c9e31b27e9)**
+
 You may start it with:
 
 ```bash
-$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:5
+$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:6
 ```
 
 > The API will be available at [http://localhost:3000](http://localhost:3000).
 
+The image uses a dedicated non-root user called `gotenberg` with uid and gid `1001`.
+
+If you wish to change those uid and gid, you will have to:
+
+* clone the project
+* re-build the image
+* publish the image in your own Docker registry
+
+For instance:
+
+```bash
+$ git clone https://github.com/thecodingmachine/gotenberg.git
+$ make publish GOTENBERG_USER_GID=your_custom_gid GOTENBERG_USER_UID=your_custom_uid DOCKER_REGISTRY=your_registry DOCKER_USER=registry_user DOCKER_PASSWORD=registry_password VERSION=version
+```
+
+> `master` branch is always up-to-date with the latest version of the API.
+
 ## Docker Compose
 
 You may also add it in your Docker Compose stack:
@@ -21,10 +40,10 @@ version: '3'
 
 services:
 
-  # your others services
+  # your other services
 
   gotenberg:
-    image: thecodingmachine/gotenberg:5
+    image: thecodingmachine/gotenberg:6
 ```
 
 > The API will be available under `gotenberg:3000` in your Docker Compose network.
@@ -34,9 +53,21 @@ services:
 It may also be deployed with Kubernetes.
 
 Make sure to provide enough memory and CPU requests (for instance `512Mi` and `0.2` CPU).
-Otherwise the API will not be able to launch Google Chrome and LibreOffice (unoconv).
 
 > The more resources are granted, the quicker will be the conversions.
 
+In the deployment specification of the pod, also specify the uid of the user `gotenberg`:
+
+```
+securityContext:
+  privileged: false
+  runAsUser: 1001
+```
+
+## Cloud Run (Google Cloud)
+
+If you're looking for cost savings, you might be interested by [Cloud Run](https://cloud.google.com/run).
+However, according to some users, doing asynchronous conversion (with a webhook) might not working.
+
 In the following examples, we will assume your
-Gotenberg API is available at [http://localhost:3000](http://localhost:3000).
+Gotenberg API is available at [http://localhost:3000](http://localhost:3000).

build/docs/content/02-clients.md

@@ -7,9 +7,11 @@ We provide clients in various languages for easing the interactions with the API
 ## Go client
 
 ```bash
-$ go get -u github.com/thecodingmachine/gotenberg-go-client/v5
+$ go get -u github.com/thecodingmachine/gotenberg-go-client/v7
 ```
 
+See also the example from the [README](https://github.com/thecodingmachine/gotenberg-go-client/blob/master/README.md).
+
 ## PHP client
 
 Unless your project already has a PSR7 `HttpClient`, install `php-http/guzzle6-adapter`:
@@ -18,8 +20,15 @@ Unless your project already has a PSR7 `HttpClient`, install `php-http/guzzle6-a
 $ composer require php-http/guzzle6-adapter
 ```
 
-Then the PHP client:
+Then the [PHP client](https://github.com/thecodingmachine/gotenberg-php-client):
 
 ```bash
 $ composer require thecodingmachine/gotenberg-php-client
-```
+```
+
+See also the example from the [README](https://github.com/thecodingmachine/gotenberg-php-client/blob/master/README.md).
+
+## Community clients
+
+* [JavaScript/TypeScript client](https://github.com/yumauri/gotenberg-js-client) by [yumauri](https://github.com/yumauri)
+* [C# client](https://github.com/ChangemakerStudios/GotenbergSharpApiClient) by [ChangemakerStudios](https://github.com/ChangemakerStudios)

build/docs/content/03-environment-variables.md

@@ -4,15 +4,68 @@ title: Environment variables
 
 You may customize the API behaviour thanks to environment variables.
 
+## Log level
+
+The API provides structured logging allowing you to have relevant information
+about what's going on.
+
+> If a TTY is attached, the log entries are displayed in text format with colors, otherwise in JSON format.
+
+You may customize the severity of the log entries thanks to the environment variable `LOG_LEVEL`.
+
+It accepts one of the following severities: `"DEBUG"`, `"INFO"` (default) and `"ERROR"`.
+
+## Default listen port
+
+By default, the API will listen on port `3000`.
+
+You may customize this value with the environment variable `DEFAULT_LISTEN_PORT`.
+
+This environment variable accepts any string that can be turned into a port number.
+
+## Root path
+
+By default, the API root path is `/`.
+
+You may customize this value with the environment variable `ROOT_PATH`.
+
+This environment variable accepts a string starting and ending with `/`.
+
+For instance, `/gotenberg/` is a valid value while `gotenberg` is not.
+
+> This is useful if you wish to do service discovery via URL paths.
+
 ## Disable Google Chrome
 
-In order to save some resources, the Gotenberg image accepts the environment variable `DISABLE_GOOGLE_CHROME`.
+In order to save some resources, the Gotenberg image accepts the environment variable `DISABLE_GOOGLE_CHROME`
+for disabling Google Chrome.
 
-It takes the strings `"0"` or `"1"` as value.
+It takes the strings `"0"` or `"1"` as value where `1` means `true`
 
 > If Google Chrome is disabled, the following conversions will **not** be available anymore:
 > [HTML](#html), [URL](#url) and [Markdown](#markdown)
 
+## Default Google Chrome rpcc buffer size
+
+When performing a [HTML](#html), [URL](#url) or [Markdown](#markdown) conversion, the API might return
+a `400` HTTP code with the message `increase the Google Chrome rpcc buffer size`.
+
+If so, you may increase this buffer size with the environment variable `DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE`.
+
+It takes a string representation of an int as value (e.g. `"1048576"` for 1 MB).
+The hard limit is 100 MB and is defined by Google Chrome itself.
+
+> The default Google Chrome rpcc buffer size may also be overridden per request thanks to the form field `googleChromeRpccBufferSize`.
+> See the [rpcc buffer size section](#html.rpcc_buffer_size).
+
+## Google Chrome ignore certificate errors
+
+When performing a [URL](#url) conversion, Google Chrome will not accept certificate errors. 
+
+You may allow insecure connections by setting the `GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS` environment variable to `"1"`.
+
+**You should be careful with this feature and only enable it in your development environment.**
+
 ## Disable LibreOffice (unoconv)
 
 You may also disable LibreOffice (unoconv) with `DISABLE_UNOCONV`.
@@ -23,6 +76,7 @@ You may also disable LibreOffice (unoconv) with `DISABLE_UNOCONV`.
 ## Default wait timeout
 
 By default, the API will wait 10 seconds before it considers the conversion to be unsuccessful.
+If unsucessful, it returns a `504` HTTP code.
 
 You may customize this timeout thanks to the environment variable `DEFAULT_WAIT_TIMEOUT`.
 
@@ -31,18 +85,41 @@ It takes a string representation of a float as value (e.g `"2.5"` for 2.5 second
 > The default timeout may also be overridden per request thanks to the form field `waitTimeout`.
 > See the [timeout section](#timeout).
 
-## Disable logging on healthcheck
+## Maximum wait timeout
 
-By default, the API will add a log entry when the [healthcheck endpoint](#ping) is called.
+By default, the value of the form field `waitTimeout` cannot be more than 30 seconds.
 
-You may turn off this logging so as to avoid unnecessary entries in your logs with the environment variable `DISABLE_HEALTHCHECK_LOGGING`.
+You may increase or decrease this limit thanks to the environment variable `MAXIMUM_WAIT_TIMEOUT`.
 
-This environment variable operates in the same manner as the `DISABLE_GOOGLE_CHROME` and `DISABLE_UNOCONV` variables operate in that it accepts the strings `"0"` or `"1"` as values. 
+It takes a string representation of a float as value (e.g `"2.5"` for 2.5 seconds).
 
-## Default listen port
+## Default webhook URL timeout
 
-By default, the API will listen on port `3000`. For most use cases this is perfectly fine, but at times there may be cases where you need to change this due to port conflicts.
+By default, the API will wait 10 seconds before it considers the sending of the resulting PDF to be unsuccessful.
 
-You may customize this port location with the environment variable `DEFAULT_LISTEN_PORT`.
+> See the [webhook section](#webhook).
 
-This environment variable accepts any string that can be turned into a port number (e.g., the string `"0"` up to the string `"65535"`).
+You may customize this timeout thanks to the environment variable `DEFAULT_WEBHOOK_URL_TIMEOUT`.
+
+It takes a string representation of a float as value (e.g `"2.5"` for 2.5 seconds).
+
+> The default timeout may also be overridden per request thanks to the form field `webhookURLTimeout`.
+> See the [webhook timeout section](#webhook.timeout).
+
+## Maximum webhook URL timeout
+
+By default, the value of the form field `webhookURLTimeout` cannot be more than 30 seconds.
+
+You may increase or decrease this limit thanks to the environment variable `MAXIMUM_WEBHOOK_URL_TIMEOUT`.
+
+It takes a string representation of a float as value (e.g `"2.5"` for 2.5 seconds).
+
+## Maximum wait delay
+
+By default, the value of the form field `waitDelay` cannot be more than 10 seconds.
+
+> See the [wait delay section](#html.wait_delay).
+
+You may increase or decrease this limit thanks to the environment variable `MAXIMUM_WAIT_DELAY`.
+
+It takes a string representation of a float as value (e.g `"2.5"` for 2.5 seconds).

build/docs/content/04-html.md

@@ -39,14 +39,13 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -57,10 +56,10 @@ use TheCodingMachine\Gotenberg\DocumentFactory;
 use TheCodingMachine\Gotenberg\HTMLRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
-$dirPath = "/foo";
-$filename = $client->store($request, $dirPath);
+$dest = 'result.pdf';
+$client->store($request, $dest);
 ```
 
 ## Header and footer
@@ -95,8 +94,15 @@ The following classes allow you to inject printing values:
 * `pageNumber`: current page number
 * `totalPage`: total pages in the document
 
-> **Attention:** the CSS properties are independant of the ones used in the `index.html` file.
-> Also, `footer.html` CSS properties override the ones from `header.html`.
+There are some limitations:
+
+* JavaScript is not executed
+* external resources are not loaded
+* the CSS properties are independant of the ones used in the `index.html` file
+* `footer.html` CSS properties override the ones from `header.html`
+* only fonts installed in the Docker image are loaded (see the [fonts section](#fonts))
+* images only work using a `base64` encoded source (`<img src="data:image/png;base64, iVBORw0K... />`)
+* `background-color` and `color` CSS properties require an additional `-webkit-print-color-adjust: exact` CSS property in order to work
 
 ### cURL
 
@@ -113,16 +119,17 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.Header("header.html")
-    req.Footer("footer.html")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+header, _ := gotenberg.NewDocumentFromPath("header.html", "/path/to/file")
+footer, _ := gotenberg.NewDocumentFromPath("footer.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.Header(header)
+req.Footer(footer)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -133,14 +140,14 @@ use TheCodingMachine\Gotenberg\DocumentFactory;
 use TheCodingMachine\Gotenberg\HTMLRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
-$header = DocumentFactory::makeFromPath('header.html', 'header.html');
-$footer = DocumentFactory::makeFromPath('footer.html', 'footer.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
+$header = DocumentFactory::makeFromPath('header.html', '/path/to/file');
+$footer = DocumentFactory::makeFromPath('footer.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setHeader($header);
 $request->setFooter($footer);
-$dirPath = "/foo";
-$filename = $client->store($request, $dirPath);
+$dest = 'result.pdf';
+$client->store($request, $dest);
 ```
 
 ## Assets
@@ -150,7 +157,7 @@ You may also send additional files. For instance: images, fonts, stylesheets and
 The only requirement is to make sure that their paths
 are on the same level as the `index.html` file.
 
-In others words, this will work:
+In other words, this will work:
 
 ```html
 <!doctype html>
@@ -203,15 +210,17 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.Assets("font.woff", "img.gif", "style.css")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+style, _ := gotenberg.NewDocumentFromPath("style.css", "/path/to/file")
+img, _ := gotenberg.NewDocumentFromPath("img.png", "/path/to/file")
+font, _ := gotenberg.NewDocumentFromPath("font.woff", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.Assets(style, img, font)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -222,23 +231,23 @@ use TheCodingMachine\Gotenberg\DocumentFactory;
 use TheCodingMachine\Gotenberg\HTMLRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $assets = [
-    DocumentFactory::makeFromPath('style.css', 'style.css'),
-    DocumentFactory::makeFromPath('img.png', 'img.png'),
-    DocumentFactory::makeFromPath('font.woff', 'font.woff'),
+    DocumentFactory::makeFromPath('style.css', '/path/to/file'),
+    DocumentFactory::makeFromPath('img.png', '/path/to/file'),
+    DocumentFactory::makeFromPath('font.woff', '/path/to/file'),
 ];
 $request = new HTMLRequest($index);
 $request->setAssets($assets);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```
 
-## Paper size, margins, orientation
+## Paper size, margins, orientation, scaling
 
 You may also customize the resulting PDF format.
 
-By default, it will be rendered with `A4` size, `1 inch` margins and `portrait` orientation.
+By default, it will be rendered with `A4` size, `1 inch` margins and `portrait` orientation and 100% (`1.0`) page scale.
 
 > Paper size and margins have to be provided in `inches`. Same for margins.
 
@@ -250,29 +259,30 @@ $ curl --request POST \
     --header 'Content-Type: multipart/form-data' \
     --form files=@index.html \
     --form paperWidth=8.27 \
-    --form paperHeight=11.27 \
+    --form paperHeight=11.69 \
     --form marginTop=0 \
     --form marginBottom=0 \
     --form marginLeft=0 \
     --form marginRight=0 \
     --form landscape=true \
+    --form scale=0.75 \
     -o result.pdf
 ```
 
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.PaperSize(gotenberg.A4)
-    req.Margins(gotenberg.NoMargins)
-    req.Landscape(true)
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.PaperSize(gotenberg.A4)
+req.Margins(gotenberg.NoMargins)
+req.Landscape(true)
+req.Scale(0.75)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -284,19 +294,68 @@ use TheCodingMachine\Gotenberg\HTMLRequest;
 use TheCodingMachine\Gotenberg\Request;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setPaperSize(Request::A4);
 $request->setMargins(Request::NO_MARGINS);
 $request->setLandscape(true);
-$dest = "result.pdf";
+$request->setScale(0.75);
+$dest = 'result.pdf';
+$client->store($request, $dest);
+```
+
+## Page ranges
+
+You may specify the page ranges to convert.
+
+The format is the same as the one from the print options
+of Google Chrome, e.g. `1-5,8,11-13`.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/html \
+    --header 'Content-Type: multipart/form-data' \
+    --form files=@index.html \
+    --form pageRanges='1-3,5' \
+    -o result.pdf
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.PageRanges("1-3,5")
+dest := "result.pdf"
+c.Store(req, dest)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\DocumentFactory;
+use TheCodingMachine\Gotenberg\HTMLRequest;
+use TheCodingMachine\Gotenberg\Request;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
+$request = new HTMLRequest($index);
+$request->setPageRanges('1-3,5');
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```
 
 ## Wait delay
 
 In some cases, you may want to wait a certain amount of time to make sure the
-page you're trying to generate is fully rendered.
+page you're trying to generate is fully rendered. For instance, if your page relies
+a lot on JavaScript for rendering.
 
 > The wait delay is a duration in **seconds** (e.g `2.5` for 2.5 seconds).
 
@@ -314,15 +373,14 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.WaitDelay(5.5)
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.WaitDelay(5.5)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -334,9 +392,60 @@ use TheCodingMachine\Gotenberg\HTMLRequest;
 use TheCodingMachine\Gotenberg\Request;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setWaitDelay(5.5);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
-```
+```
+
+## Rpcc buffer size
+
+The API might return a `400` HTTP code with the message `increase the Google Chrome rpcc buffer size`.
+
+If so, you may increase this buffer size with a form field named `googleChromeRpccBufferSize`.
+
+It takes an int as value (e.g. `1048576` for 1 MB).
+The hard limit is 100 MB and is defined by Google Chrome itself.
+
+> You may also define this value globally: see the [environment variables](#environment_variables.default_google_chrome_rpcc_buffer_size) section.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/html \
+    --header 'Content-Type: multipart/form-data' \
+    --form files=@index.html \
+    --form googleChromeRpccBufferSize=1048576 \
+    -o result.pdf
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.GoogleChromeRpccBufferSize(1048576)
+dest := "result.pdf"
+c.Store(req, dest)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\DocumentFactory;
+use TheCodingMachine\Gotenberg\HTMLRequest;
+use TheCodingMachine\Gotenberg\Request;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
+$request = new HTMLRequest($index);
+$request->setGoogleChromeRpccBufferSize(1048576);
+$dest = 'result.pdf';
+$client->store($request, $dest);
+```

build/docs/content/05-url.md

@@ -14,6 +14,9 @@ named `remoteURL` instead. Otherwise, URL conversions work the same as HTML conv
 > **Attention:** when converting a website to PDF, you should remove all margins.
 > If not, some of the content of the page might be hidden.
 
+> **Attention:** if you try to convert a URL from a Docker Compose service named `app` (i.e. `removeURL` = `http://app/an/entrypoint`),
+> the resulting PDF will be blank. Make sure to rename your service to avoid this issue.
+
 ### cURL
 
 ```bash
@@ -31,15 +34,13 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req := gotenberg.NewURLRequest("https://google.com")
-    req.Margins(gotenberg.NoMargins)
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+req := gotenberg.NewURLRequest("https://google.com")
+req.Margins(gotenberg.NoMargins)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -51,6 +52,55 @@ use TheCodingMachine\Gotenberg\URLRequest;
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
 $request = new URLRequest('https://google.com');
 $request->setMargins(Request::NO_MARGINS);
-$dest = "result.pdf";
+$dest = 'result.pdf';
+$client->store($request, $dest);
+```
+
+## Custom HTTP headers
+
+You may send your own HTTP headers to the `remoteURL`.
+
+For instance, by adding the HTTP header `Gotenberg-Remoteurl-Your-Header` to your request,
+the API will send a request to the `remoteURL` with the HTTP header `Your-Header`.
+
+> **Attention:** the API uses a canonical format for the HTTP headers:
+> it transforms the first
+> letter and any letter following a hyphen to upper case;
+> the rest are converted to lowercase. For example, the
+> canonical key for `accept-encoding` is `Accept-Encoding`.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/url \
+    --header 'Content-Type: multipart/form-data' \
+    --header 'Gotenberg-Remoteurl-Your-Header: Foo' \
+    --form remoteURL=https://google.com \
+    -o result.pdf
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+req := gotenberg.NewURLRequest("https://google.com")
+req.AddRemoteURLHTTPHeader("Your-Header", "Foo")
+dest := "result.pdf"
+c.Store(req, dest)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\URLRequest;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$request = new URLRequest('https://google.com');
+$request->addRemoteURLHTTPHeader('Your-Header', 'Foo')
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```

build/docs/content/06-markdown.md

@@ -42,14 +42,14 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewMarkdownRequest("index.html", "file.md")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+markdown, _ := gotenberg.NewDocumentFromPath("file.md", "/path/to/file")
+req := gotenberg.NewMarkdownRequest(index, markdown)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -60,11 +60,11 @@ use TheCodingMachine\Gotenberg\DocumentFactory;
 use TheCodingMachine\Gotenberg\MarkdownRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $markdowns = [
-    DocumentFactory::makeFromPath('file.md', 'file.md'),
+    DocumentFactory::makeFromPath('file.md', '/path/to/file'),
 ];
 $request = new MarkdownRequest($index, $markdowns);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```

build/docs/content/07-office.md

@@ -25,9 +25,7 @@ You may send one or more Office documents. Following file extensions are accepte
 
 All files will be merged into a single resulting PDF.
 
-> **Attention:** currently, `unoconv` cannot perform concurrent conversions.
-> That's why for Office conversions, the API does only one conversion at a time.
-> See the [scalability section](#scalability) to find how to mitigate this issue.
+> **Attention:** Gotenberg merges the PDF files alphabetically.
 
 ### cURL
 
@@ -43,14 +41,14 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewOfficeRequest("document.docx", "document2.docx")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+doc, _ := gotenberg.NewDocumentFromPath("document.docx", "/path/to/file")
+doc2, _ := gotenberg.NewDocumentFromPath("document2.docx", "/path/to/file")
+req := gotenberg.NewOfficeRequest(doc, doc2)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -62,11 +60,11 @@ use TheCodingMachine\Gotenberg\OfficeRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
 $files = [
-    DocumentFactory::makeFromPath('document.docx', 'document.docx'),
-    DocumentFactory::makeFromPath('document2.docx', 'document2.docx'),
+    DocumentFactory::makeFromPath('document.docx', '/path/to/file'),
+    DocumentFactory::makeFromPath('document2.docx', '/path/to/file'),
 ];
 $request = new OfficeRequest($files);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```
 
@@ -90,15 +88,14 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewOfficeRequest("document.docx")
-    req.Landscape(true)
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+doc, _ := gotenberg.NewDocumentFromPath("document.docx", "/path/to/file")
+req := gotenberg.NewOfficeRequest(doc)
+req.Landscape(true)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -110,10 +107,61 @@ use TheCodingMachine\Gotenberg\OfficeRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
 $files = [
-    DocumentFactory::makeFromPath('document.docx', 'document.docx'),
+    DocumentFactory::makeFromPath('document.docx', '/path/to/file'),
 ];
 $request = new OfficeRequest($files);
 $request->setLandscape(true);
-$dest = "result.pdf";
+$dest = 'result.pdf';
+$client->store($request, $dest);
+```
+
+## Page ranges
+
+You may specify the page ranges to convert.
+
+The format is the same as the one from the print options
+of LibreOffice, e.g. `1-1` or `1-4`.
+
+> **Attention:** if more than one document, the page ranges will be
+> applied for each document.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/office \
+    --header 'Content-Type: multipart/form-data' \
+    --form files=@document.docx \
+    --form pageRanges='1-3' \
+    -o result.pdf
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+doc, _ := gotenberg.NewDocumentFromPath("document.docx", "/path/to/file")
+req := gotenberg.NewOfficeRequest(doc)
+req.PageRanges("1-3")
+dest := "result.pdf"
+c.Store(req, dest)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\DocumentFactory;
+use TheCodingMachine\Gotenberg\OfficeRequest;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$files = [
+    DocumentFactory::makeFromPath('document.docx', '/path/to/file'),
+];
+$request = new OfficeRequest($files);
+$request->setPageRanges('1-3');
+$dest = 'result.pdf';
 $client->store($request, $dest);
 ```

build/docs/content/08-merge.md

@@ -2,7 +2,7 @@
 title: Merge
 ---
 
-Gotenberg provides the endpoint `/convert/merge` for merging PDFs.
+Gotenberg provides the endpoint `/merge` for merging PDFs.
 
 It accepts `POST` requests with a `multipart/form-data` Content-Type.
 
@@ -17,7 +17,7 @@ will merge them and return the resulting PDF file.
 
 ```bash
 $ curl --request POST \
-    --url http://localhost:3000/convert/merge \
+    --url http://localhost:3000/merge \
     --header 'Content-Type: multipart/form-data' \
     --form files=@file.pdf \
     --form files=@file2.pdf \
@@ -27,14 +27,14 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewMergeRequest("file.pdf", "file2.pdf")
-    dest := "result.pdf"
-    c.Store(req, dest)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+pdf, _ := gotenberg.NewDocumentFromPath("file.pdf", "/path/to/file")
+pdf2, _ := gotenberg.NewDocumentFromPath("file2.pdf", "/path/to/file")
+req := gotenberg.NewMergeRequest(pdf, pdf2)
+dest := "result.pdf"
+c.Store(req, dest)
 ```
 
 ### PHP
@@ -46,10 +46,10 @@ use TheCodingMachine\Gotenberg\MergeRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
 $files = [
-    DocumentFactory::makeFromPath('file.pdf', 'file.pdf'),
-    DocumentFactory::makeFromPath('file2.pdf', 'file2.pdf'),
+    DocumentFactory::makeFromPath('file.pdf', '/path/to/file'),
+    DocumentFactory::makeFromPath('file2.pdf', '/path/to/file'),
 ];
 $request = new MergeRequest($files);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
-```
+```

build/docs/content/09-timeout.md

@@ -5,6 +5,7 @@ title: Timeout
 All endpoints accept a form field named `waitTimeout`.
 
 The API will wait the given **seconds** before it considers the conversion to be unsucessful.
+If unsucessful, it returns a `504` HTTP code.
 
 It takes a float as value (e.g `2.5` for 2.5 seconds).
 
@@ -25,14 +26,13 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.WaitTimeout(2.5)
-    resp, _ := c.Post(req)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.WaitTimeout(2.5)
+resp, _ := c.Post(req)
 ```
 
 ### PHP
@@ -44,9 +44,9 @@ use TheCodingMachine\Gotenberg\HTMLRequest;
 use TheCodingMachine\Gotenberg\Request;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setWaitTimeout(2.5);
-$dest = "result.pdf";
+$dest = 'result.pdf';
 $client->store($request, $dest);
-```
+```

build/docs/content/10-webhook.md

@@ -24,14 +24,13 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.WebhookURL("http://myapp.com/webhook/")
-    resp, _ := c.Post(req)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.WebhookURL("http://myapp.com/webhook/")
+resp, _ := c.Post(req)
 ```
 
 ### PHP
@@ -42,8 +41,109 @@ use TheCodingMachine\Gotenberg\DocumentFactory;
 use TheCodingMachine\Gotenberg\HTMLRequest;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setWebhookURL('http://myapp.com/webhook/');
 $resp = $client->post($request);
+```
+
+## Timeout
+
+If a `webhookURL` is provided, you may also send a form field named `webhookURLTimeout`.
+
+The API will wait the given **seconds** before it considers the sending of the resulting PDF to be unsucessful.
+
+It takes a float as value (e.g `2.5` for 2.5 seconds).
+
+> You may also define this value globally: see the [environment variables](#environment_variables.default_webhook_url_timeout) section.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/html \
+    --header 'Content-Type: multipart/form-data' \
+    --form files=@index.html \
+    --form webhookURL='http://myapp.com/webhook/' \
+    --form webhookURLTimeout=2.5
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.WebhookURL("http://myapp.com/webhook/")
+req.WebhookURLTimeout(2.5)
+resp, _ := c.Post(req)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\DocumentFactory;
+use TheCodingMachine\Gotenberg\HTMLRequest;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
+$request = new HTMLRequest($index);
+$request->setWebhookURL('http://myapp.com/webhook/');
+$request->setWebhookURLTimeout(2.5);
+$resp = $client->post($request);
+```
+
+## Custom HTTP headers
+
+You may send your own HTTP headers to the `webhookURL`.
+
+For instance, by adding the HTTP header `Gotenberg-Webhookurl-Your-Header` to your request,
+the API will send a request to the `webhookURL` with the HTTP header `Your-Header`.
+
+> **Attention:** the API uses a canonical format for the HTTP headers:
+> it transforms the first
+> letter and any letter following a hyphen to upper case;
+> the rest are converted to lowercase. For example, the
+> canonical key for `accept-encoding` is `Accept-Encoding`.
+
+### cURL
+
+```bash
+$ curl --request POST \
+    --url http://localhost:3000/convert/html \
+    --header 'Content-Type: multipart/form-data' \
+    --header 'Gotenberg-Webhookurl-Your-Header: Foo' \
+    --form files=@index.html \
+    --form webhookURL='http://myapp.com/webhook/'
+```
+
+### Go
+
+```golang
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
+
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.WebhookURL("http://myapp.com/webhook/")
+req.AddWebhookURLHTTPHeader("Your-Header", "Foo")
+resp, _ := c.Post(req)
+```
+
+### PHP
+
+```php
+use TheCodingMachine\Gotenberg\Client;
+use TheCodingMachine\Gotenberg\DocumentFactory;
+use TheCodingMachine\Gotenberg\HTMLRequest;
+
+$client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
+$request = new HTMLRequest($index);
+$request->setWebhookURL('http://myapp.com/webhook/');
+$request->addWebhookURLHTTPHeader('Your-Header', 'Foo');
+$resp = $client->post($request);
 ```

build/docs/content/11-result-filename.md

@@ -24,14 +24,13 @@ $ curl --request POST \
 ### Go
 
 ```golang
-import "github.com/thecodingmachine/gotenberg-go-client/v5"
+import "github.com/thecodingmachine/gotenberg-go-client/v7"
 
-func main() {
-    c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req, _ := gotenberg.NewHTMLRequest("index.html")
-    req.ResultFilename("foo.pdf")
-    resp, _ := c.Post(req)
-}
+c := &gotenberg.Client{Hostname: "http://localhost:3000"}
+index, _ := gotenberg.NewDocumentFromPath("index.html", "/path/to/file")
+req := gotenberg.NewHTMLRequest(index)
+req.ResultFilename("foo.pdf")
+resp, _ := c.Post(req)
 ```
 
 ### PHP
@@ -43,8 +42,8 @@ use TheCodingMachine\Gotenberg\HTMLRequest;
 use TheCodingMachine\Gotenberg\Request;
 
 $client = new Client('http://localhost:3000', new \Http\Adapter\Guzzle6\Client());
-$index = DocumentFactory::makeFromPath('index.html', 'index.html');
+$index = DocumentFactory::makeFromPath('index.html', '/path/to/file');
 $request = new HTMLRequest($index);
 $request->setResultFilename('foo.pdf');
 $resp = $client->post($request);
-```
+```

build/docs/content/12-scalability.md

@@ -2,6 +2,32 @@
 title: Scalability
 ---
 
+The API uses under the hood intricate programs.
+
+Gotenberg tries to abstract as much complexity as possible but it can
+only do it to a certain extent.
+
+For instance, [Office](#office) and [Merge](#merge) endpoints will start respectively as many LibreOffice (unoconv) and PDTk
+instances as there are requests. The limitation here is the available memory and CPU usage.
+
+On another hand, for the [HTML](#html), [URL](#url) and [Markdown](#markdown) endpoints, the API does only 6 conversions in parallel.
+Indeed, Google Chrome misbehaves if there are too many concurrent conversions.
+
+**The more concurrent requests, the more `504` HTTP codes the API will return.**
+
+> See our [load testing use case](https://github.com/thecodingmachine/gotenberg/tree/master/loadtesting) for more details about the API behaviour under heavy load.
+
+## Strategies
+
+### Increase timeout
+
+You may increase the conversion timeout. In other words, you accept that a conversion takes more time
+if the API is under heavy load.
+
+> See [timeout section](#timeout).
+
+### Scaling
+
 The API being stateless, you may scale it as much as you want.
 
 For instance, using the following Docker Compose file:
@@ -11,10 +37,10 @@ version: '3'
 
 services:
 
-  # your others services
+  # your other services
 
   gotenberg:
-    image: thecodingmachine/gotenberg:5
+    image: thecodingmachine/gotenberg:6
 ```
 
 You may now launch your services using:
@@ -24,4 +50,4 @@ $ 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.
+redirect a request to a Gotenberg container according to the round-robin strategy.

build/docs/content/13-ping.md

@@ -5,7 +5,8 @@ title: Ping
 Gotenberg provides the endpoint `/ping` for checking the API availability with
 a simple `GET` request.
 
-This feature is especially useful for liveness/readiness probes in Kubernetes:
+Currently this endpoint does nothing special. A better way to monitor
+Gotenberg would be by checking the memory usage.
 
-* [Pod lifecycle](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes)
-* [Configure Liveness and Readiness Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/)
+Also, as the API uses under the hood intricate programs, you should
+restart your Gotenberg instances from time to time to ensure a nominal behaviour.

build/docs/content/14-fonts.md

@@ -7,7 +7,11 @@ By default, a handful of fonts are installed. Asian characters are also supporte
 If you wish to use more fonts, you will have to create your own image:
 
 ```Dockerfile
-FROM thecodingmachine/gotenberg:5
+FROM thecodingmachine/gotenberg:6
+
+USER root
 
 RUN apt-get -y install yourfonts
-```
+
+USER gotenberg
+```

build/docs/content/15-links.md

@@ -2,7 +2,11 @@
 title: Links
 ---
 
+<p align="center">
+    <img src="https://user-images.githubusercontent.com/8983173/50009948-84b01e00-ffb8-11e8-850b-fc240382c626.png" alt="Gotenberg logo" width="150" height="150" />
+</p>
+
 * Follow the progress on the [GitHub repository](https://github.com/thecodingmachine/gotenberg)
 * Follow [@gulnap](https://twitter.com/gulnap) on Twitter
-
-Psst: TheCodingMachine is always looking for [talented coders](https://coders.thecodingmachine.com).
+* Thanks to [@mafredri](https://github.com/mafredri) for his help and his wonderful [cdp](https://github.com/mafredri/cdp) library
+* OpenAPI documentation for the API can be found [on GitHub](https://github.com/thecodingmachine/gotenberg/blob/master/docs/openapi.yaml)

build/lint/Dockerfile

@@ -1,19 +1,6 @@
-ARG GOLANG_VERSION
+ARG GOLANGCI_LINT_VERSION
 
-FROM golang:${GOLANG_VERSION}-stretch
-
-# |--------------------------------------------------------------------------
-# | GolangCI-Lint
-# |--------------------------------------------------------------------------
-# |
-# | Installs GolangCI-Lint, a linters Runner for Go. 5x faster 
-# | than gometalinter.
-# |
-
-ENV GOLANGCI_LINT_VERSION 1.16.0
-
-RUN curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b /usr/local/bin v${GOLANGCI_LINT_VERSION} &&\
-    golangci-lint --version
+FROM golangci/golangci-lint:v$GOLANGCI_LINT_VERSION
 
 # |--------------------------------------------------------------------------
 # | Final touch
@@ -22,14 +9,14 @@ RUN curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.s
 # | Last instructions of this build.
 # |
 
-# Define our workding outside of $GOPATH (we're using go modules).
-WORKDIR /lint
+# Define our working directory outside of $GOPATH (we're using go modules).
+WORKDIR /gotenberg/lint
 
-# Copy our module dependencies definitions.
-COPY go.mod .
-COPY go.sum .
+# Copy our code source.
+COPY . .
 
 # Install module dependencies.
-RUN go mod download
+RUN go mod download &&\
+    go mod verify
 
-CMD ["golangci-lint", "run" ,"--tests=false", "--enable-all", "--disable=dupl" ]
+CMD ["golangci-lint", "run" ,"--tests=false", "--enable-all", "--disable=dupl", "--disable=funlen", "--disable=wsl", "--disable=gocognit", "--disable=gomnd", "--disable=goimports" ]

build/package/Dockerfile

@@ -1,28 +1,50 @@
-ARG GOLANG_VERSION
-
 # |--------------------------------------------------------------------------
 # | Binary
 # |--------------------------------------------------------------------------
 # |
-# | Buils Gotenberg binary.
+# | Builds Gotenberg binary.
 # |
 
-FROM golang:${GOLANG_VERSION}-stretch AS golang
+FROM thecodingmachine/gotenberg:workspace AS workspace
 
 ARG VERSION
 
 ENV GOOS=linux \
-    GOARCH=amd64 \
+    GOARCH=amd64 \
     CGO_ENABLED=0
 
 # Define our workding outside of $GOPATH (we're using go modules).
-WORKDIR /gotenberg
+WORKDIR /gotenberg/package
+
+# Install module dependencies.
+COPY go.mod go.sum ./
+
+RUN go mod download &&\
+    go mod verify
 
 # Copy our source code.
-COPY . .
+COPY internal ./internal
+COPY cmd ./cmd
 
 # Build our binary.
-RUN go build -o /gotenberg/gotenberg -ldflags "-X main.version=${VERSION}" cmd/gotenberg/main.go
+RUN go build -o gotenberg -ldflags "-X main.version=${VERSION}" cmd/gotenberg/main.go
+
+FROM thecodingmachine/gotenberg:base
+
+LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
+
+# |--------------------------------------------------------------------------
+# | Tini
+# |--------------------------------------------------------------------------
+# |
+# | An helper for reaping zombie processes.
+# |
+
+ARG TINI_VERSION
+
+ADD https://github.com/krallin/tini/releases/download/v${TINI_VERSION}/tini-static /tini
+RUN chmod +x /tini
+ENTRYPOINT [ "/tini", "--" ]
 
 # |--------------------------------------------------------------------------
 # | Final touch
@@ -31,13 +53,10 @@ RUN go build -o /gotenberg/gotenberg -ldflags "-X main.version=${VERSION}" cmd/g
 # | Last instructions of this build.
 # |
 
-FROM thecodingmachine/gotenberg:base
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-COPY --from=golang /gotenberg/gotenberg /usr/local/bin/
+COPY --from=workspace /gotenberg/package/gotenberg /usr/local/bin/
 
+USER gotenberg
 WORKDIR /gotenberg
 
 EXPOSE 3000
-CMD [ "gotenberg" ]
+CMD [ "gotenberg" ]

build/tests/Dockerfile

@@ -1,48 +1,16 @@
-ARG GOLANG_VERSION
-
-FROM golang:${GOLANG_VERSION}-stretch AS golang
-
-FROM thecodingmachine/gotenberg:base
-
-# |--------------------------------------------------------------------------
-# | Common libraries
-# |--------------------------------------------------------------------------
-# |
-# | Libraries used in the build process of this image.
-# |
-
-RUN apt-get install -y git gcc
-
-# |--------------------------------------------------------------------------
-# | Golang
-# |--------------------------------------------------------------------------
-# |
-# | Installs Golang.
-# |
-
-COPY --from=golang /usr/local/go /usr/local/go
-
-RUN export PATH="/usr/local/go/bin:$PATH" &&\
-    go version
-
-ENV GOPATH /go
-ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
-
-# |--------------------------------------------------------------------------
-# | Final touch
-# |--------------------------------------------------------------------------
-# |
-# | Last instructions of this build.
-# |
+FROM thecodingmachine/gotenberg:workspace
 
 # Define our workding outside of $GOPATH (we're using go modules).
-WORKDIR /tests
-
-# Copy our module dependencies definitions.
-COPY go.mod .
-COPY go.sum .
+USER gotenberg
+WORKDIR /gotenberg/tests
 
 # Install module dependencies.
-RUN go mod download
+COPY --chown=gotenberg:gotenberg go.mod go.sum ./
+
+RUN go mod download &&\
+    go mod verify
+
+# Copy our code source.
+COPY --chown=gotenberg:gotenberg . .
 
 ENTRYPOINT [ "build/tests/docker-entrypoint.sh" ]

build/tests/docker-entrypoint.sh

@@ -2,16 +2,19 @@
 
 set -xe
 
-# Testing PM2 processes launch separatly for avoiding
-# spending to much time on each tests depending on
-# them.
-go test github.com/thecodingmachine/gotenberg/internal/pkg/pm2 -run TestChromeStart
-go test github.com/thecodingmachine/gotenberg/internal/pkg/pm2 -run TestUnoconvStart
+# Make sure the user running the
+# tests is the Gotenberg user.
+CURRENT_USER=$(whoami)
+if [ "$CURRENT_USER" != "gotenberg" ]; then
+    exit 1
+fi
 
-# Running others tests.
-go test -race -cover -covermode=atomic github.com/thecodingmachine/gotenberg/internal/app/api
-go test -race -cover -covermode=atomic github.com/thecodingmachine/gotenberg/internal/pkg/rand
+# Start Google Chrome headless.
+go run test/cmd/chrome.go
 
-# Finally testing processes shutdown.
-go test github.com/thecodingmachine/gotenberg/internal/pkg/pm2 -run TestChromeShutdown
-go test github.com/thecodingmachine/gotenberg/internal/pkg/pm2 -run TestUnoconvShutdown
+# Run our tests.
+if [ "$CODE_COVERAGE" = "1" ]; then
+    go test -race -coverprofile=coverage.txt -covermode=atomic ./...
+else
+    go test -race -cover ./...
+fi

build/workspace/Dockerfile

@@ -0,0 +1,52 @@
+ARG GOLANG_VERSION
+
+FROM golang:${GOLANG_VERSION}-stretch as golang
+
+FROM thecodingmachine/gotenberg:base
+
+# |--------------------------------------------------------------------------
+# | Common libraries
+# |--------------------------------------------------------------------------
+# |
+# | Libraries used in the build process of this image.
+# |
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git \
+		g++ \
+		gcc \
+		libc6-dev \
+		make \
+		pkg-config \
+	&& rm -rf /var/lib/apt/lists/*
+
+# |--------------------------------------------------------------------------
+# | Golang
+# |--------------------------------------------------------------------------
+# |
+# | Installs Golang.
+# |
+
+COPY --from=golang /usr/local/go /usr/local/go
+
+ENV GOPATH /gotenberg/go
+ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
+
+RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" &&\
+    chmod -R 777 "$GOPATH"
+
+# |--------------------------------------------------------------------------
+# | Final touch
+# |--------------------------------------------------------------------------
+# |
+# | Last instructions of this build.
+# |
+
+# Make sure the Gotenber user is able to
+# call the Go binary.
+USER gotenberg
+
+RUN go version &&\
+    go env
+
+USER root

cmd/gotenberg/main.go

@@ -1,137 +1,48 @@
 package main
 
 import (
-	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"os"
 	"os/signal"
-	"strconv"
-	"time"
 
-	"github.com/labstack/echo/v4"
-	"github.com/thecodingmachine/gotenberg/internal/app/api"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/notify"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/pm2"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/chrome"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xcontext"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
 )
 
 // version will be set on build time.
 // nolint: gochecknoglobals
 var version = "snapshot"
 
-const (
-	defaultWaitTimeoutEnvVar        = "DEFAULT_WAIT_TIMEOUT"
-	defaultListenPortEnvVar         = "DEFAULT_LISTEN_PORT"
-	disableGoogleChromeEnvVar       = "DISABLE_GOOGLE_CHROME"
-	disableUnoconvEnvVar            = "DISABLE_UNOCONV"
-	disableHealthcheckLoggingEnvVar = "DISABLE_HEALTHCHECK_LOGGING"
-)
-
-func mustParseEnvVar() *api.Options {
-	opts := api.DefaultOptions()
-	if os.Getenv(defaultWaitTimeoutEnvVar) != "" {
-		defaultWaitTimeout, err := strconv.ParseFloat(os.Getenv(defaultWaitTimeoutEnvVar), 64)
-		if err != nil {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want float got %v", defaultWaitTimeoutEnvVar, err))
-			os.Exit(1)
-		}
-		opts.DefaultWaitTimeout = defaultWaitTimeout
-	}
-	if v, ok := os.LookupEnv(defaultListenPortEnvVar); ok {
-		defaultListener, err := strconv.ParseUint(os.Getenv(defaultListenPortEnvVar), 10, 64)
-		if err != nil {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want uint got %v", defaultListenPortEnvVar, err))
-			os.Exit(1)
-		}
-		if defaultListener > 65535 {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want uint < 65535 got %v", defaultListenPortEnvVar, defaultListener))
-			os.Exit(1)
-		}
-		opts.DefaultListenPort = v
-	}
-	if v, ok := os.LookupEnv(disableGoogleChromeEnvVar); ok {
-		if v != "1" && v != "0" {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want \"0\" or \"1\" got %v", disableGoogleChromeEnvVar, v))
-			os.Exit(1)
-		}
-		opts.EnableChromeEndpoints = v != "1"
-	}
-	if v, ok := os.LookupEnv(disableUnoconvEnvVar); ok {
-		if v != "1" && v != "0" {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want \"0\" or \"1\" got %v", disableUnoconvEnvVar, v))
-			os.Exit(1)
-		}
-		opts.EnableUnoconvEndpoints = v != "1"
-	}
-	if v, ok := os.LookupEnv(disableHealthcheckLoggingEnvVar); ok {
-		if v != "1" && v != "0" {
-			notify.ErrPrint(fmt.Errorf("%s: wrong value: want \"0\" or \"1\" got %v", disableHealthcheckLoggingEnvVar, v))
-			os.Exit(1)
-		}
-		opts.EnableHealthcheckLogging = v != "1"
-	}
-	return opts
-}
-
-func mustStartProcesses(opts *api.Options) []pm2.Process {
-	var processes []pm2.Process
-	if opts.EnableChromeEndpoints {
-		processes = append(processes, pm2.NewChrome())
-	}
-	if opts.EnableUnoconvEndpoints {
-		processes = append(processes, pm2.NewUnoconv())
-	}
-	for _, p := range processes {
-		notify.Printf("starting %s with PM2...", p.Fullname())
-		if err := p.Start(); err != nil {
-			notify.ErrPrint(err)
-			os.Exit(1)
-		}
-	}
-	return processes
-}
-
-func mustStartAPI(srv *echo.Echo, port string) {
-	notify.Printf("http server started on port %v", port)
-	if err := srv.Start(fmt.Sprintf(":%v", port)); err != nil {
-		if err != http.ErrServerClosed {
-			notify.ErrPrint(err)
-			os.Exit(1)
-		}
-	}
-}
-
-func mustShutdownProcesses(processes []pm2.Process) {
-	for _, p := range processes {
-		notify.Printf("shutting down %s with PM2... (Ctrl+C to force)", p.Fullname())
-		if err := p.Shutdown(); err != nil {
-			notify.ErrPrint(err)
-			os.Exit(1)
-		}
-	}
-}
-
-func mustShutdownAPI(srv *echo.Echo) {
-	// create a deadline to wait for.
-	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
-	defer cancel()
-	// doesn't block if no connections, but will otherwise wait
-	// until the timeout deadline.
-	notify.Print("shutting down http server... (Ctrl+C to force)")
-	if err := srv.Shutdown(ctx); err != nil {
-		notify.ErrPrint(err)
-		os.Exit(1)
-	}
-}
-
 func main() {
-	notify.Printf("Gotenberg %s", version)
-	opts := mustParseEnvVar()
-	srv := api.New(opts)
-	processes := mustStartProcesses(opts)
-	// run our API in a goroutine so that it doesn't block.s
+	const op string = "main"
+	config, err := conf.FromEnv()
+	systemLogger := xlog.New(config.LogLevel(), "system")
+	if err != nil {
+		systemLogger.FatalOp(op, err)
+	}
+	systemLogger.InfoOpf(op, "Gotenberg %s", version)
+	systemLogger.DebugOpf(op, "configuration: %+v", config)
+	if !config.DisableGoogleChrome() {
+		// start Google Chrome headless.
+		if err := chrome.Start(systemLogger, config.GoogleChromeIgnoreCertificateErrors()); err != nil {
+			systemLogger.FatalOp(op, err)
+		}
+	}
+	// create our API.
+	srv := xhttp.New(config)
+	// run our API in a goroutine so that it doesn't block.
 	go func() {
-		mustStartAPI(srv, opts.DefaultListenPort)
+		systemLogger.InfoOpf(op, "http server started on port '%d'", config.DefaultListenPort())
+		if err := srv.Start(fmt.Sprintf(":%d", config.DefaultListenPort())); err != nil {
+			if errors.Is(err, http.ErrServerClosed) {
+				systemLogger.FatalOp(op, err)
+			}
+		}
 	}()
 	quit := make(chan os.Signal, 1)
 	// we'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
@@ -139,8 +50,15 @@ func main() {
 	signal.Notify(quit, os.Interrupt)
 	// block until we receive our signal.
 	<-quit
-	mustShutdownAPI(srv)
-	mustShutdownProcesses(processes)
-	notify.Print("bye!")
+	// create a deadline to wait for.
+	ctx, cancel := xcontext.WithTimeout(systemLogger, 120)
+	defer cancel()
+	// doesn't block if no connections, but will otherwise wait
+	// until the timeout deadline.
+	systemLogger.InfoOp(op, "shutting down http server...")
+	if err := srv.Shutdown(ctx); err != nil {
+		systemLogger.FatalOp(op, err)
+	}
+	systemLogger.InfoOp(op, "bye!")
 	os.Exit(0)
 }

docs/openapi.yaml

@@ -0,0 +1,558 @@
+openapi: 3.0.0
+info:
+  title: Gotenberg
+  version: 6.3.1
+  license:
+    name: MIT
+    url: 'https://github.com/thecodingmachine/gotenberg/blob/master/LICENSE'
+  contact:
+    url: 'https://github.com/thecodingmachine/gotenberg'
+  description: >-
+    A Docker-powered stateless API for converting HTML, Markdown and Office
+    documents to PDF.
+servers:
+  - url: 'http://localhost:3000'
+    description: Local server with the default Docker image and port
+paths:
+  /convert/html:
+    post:
+      summary: Convert a given HTML file to PDF
+      description: >-
+        Send an HTML file called `index.html` as a multipart form request, and
+        get the resulting PDF file. You can optionally include `header.html` and
+        `footer.html` files as part of the request as well.
+
+
+        An example `index.html` file can be as follows:
+
+        ```html
+
+        <!doctype html>
+
+        <html lang="en">
+          <head>
+            <meta charset="utf-8">
+            <title>My PDF</title>
+          </head>
+          <body>
+            <h1>Hello world!</h1>
+          </body>
+        </html>
+
+        ```
+
+
+        You may also add a header and/or a footer in the resulting PDF  by
+        sending a file named `header.html` and `footer.html` respectively. Both
+        the header and the footer files has to be a complete HTML document. An
+        example `footer.html` can be as follows:
+
+        ```html
+
+        <html>
+            <head>
+                <style>
+                    body {
+                        font-size: 8rem;
+                        margin: 4rem auto;
+                    }
+                </style>
+            </head>
+            <body>
+                <p>
+                    <span class="pageNumber"></span> of <span class="totalPages"></span>
+                </p>
+            </body>
+        </html>
+
+        ```
+
+
+        The following classes will allow you to inject printing values in your
+        document:
+
+        - `date`: Formatted print date.
+
+        - `title`: Document title.
+
+        - `pageNumber`: Current page number.
+
+        - `totalPage`: Total pages in the document.
+
+
+        There are some limitations with header and footer files:
+
+        - JavaScript is not executed.
+
+        - External resources are not loaded.
+
+        - The CSS properties are independant of the ones used in the
+        `index.html` file.
+
+        - `footer.html` CSS properties override the ones from `header.html`.
+
+        - Only fonts installed in the Docker image are loaded (see the fonts
+        section)
+
+        - Images only work using a `base64` encoded source, e.g. `<img
+        src="data:image/png;base64, iVBORw0K... />`
+
+        - `background-color` and `color` CSS properties require an additional
+        `-webkit-print-color-adjust: exact` CSS property in order to work.
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              $ref: '#/components/schemas/HTMLConvertRequestBody'
+        description: >-
+          The request body must have an `index.html` file in the `files` array,
+          as well as all the referred resources on the same level as the
+          `index.html` file. The request can also include `header.html` and
+          `footer.html`, given the limitations in the API description above.
+      responses:
+        '200':
+          $ref: '#/components/responses/SuccessfulPDF'
+  /convert/url:
+    post:
+      summary: Convert the contents of a given URL to PDF
+      description: >-
+        Send a remote URL in your API request via the `remoteURL` parameter, and
+        get the resulting PDF file. The API will fetch the given URL and render
+        the page to PDF using the underlying headless Chrome instance.
+      requestBody:
+        required: true
+        description: >-
+          The URL conversion request has to be a `multipart/form-data` request
+          that includes a `remoteURL`. The API uses a headless Chrome instance
+          to do the conversion, therefore print parameter such as margins and
+          paper size are also accepted as optional parameters.
+        content:
+          multipart/form-data:
+            schema:
+              $ref: '#/components/schemas/URLConvertRequestBody'
+            examples: {}
+      responses:
+        '200':
+          $ref: '#/components/responses/SuccessfulPDF'
+  /convert/markdown:
+    post:
+      summary: Convert a Markdown file to PDF
+      description: >-
+        Send an HTML file called `index.html` as a multipart form request and
+        embed a markdown file into the HTML file using the Golang template
+        function `toHTML`, the API will convert the markdown and embed it into
+        the HTML this way and render the resulting page. Markdown conversion
+        works almost exactly the same way as HTML conversion, therefore refer to
+        the HTML conversion page for all the options you can use when converting
+        Markdown documents as well. You can optionally include `header.html` and
+        `footer.html` files as part of the request as well.
+
+
+        An example `index.html` file can be as follows:
+
+        ```html
+
+        <!doctype html>
+
+        <html lang="en">
+          <head>
+            <meta charset="utf-8">
+            <title>My PDF</title>
+          </head>
+          <body>
+            {{ toHTML .DirPath "file.md" }}
+          </body>
+        </html>
+
+        ```
+
+
+        Whereas your `file.md` file in the same level would be like:
+
+        ```md
+
+        # Title
+
+        Content
+
+        ```
+
+
+        The API will convert the markdown to HTML and embed it into your
+        `index.html` file, then render the resulting page. You can include your
+        own styling and more in your HTML file.
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              $ref: '#/components/schemas/MarkdownConvertRequestBody'
+        description: >-
+          The request body must have an `index.html` file in the `files` array,
+          as well as all the referred markdown resources on the same level as
+          the `index.html` file.
+      responses:
+        '200':
+          $ref: '#/components/responses/SuccessfulPDF'
+  /convert/office:
+    post:
+      summary: Convert an Office document to PDF
+      description: >-
+        Send one or more Office documents and get the resulting PDF file by
+        merging all the files. The following file extensions are accepted:
+
+        - `.txt`
+
+        - `.rtf`
+
+        - `.fodt`
+
+        - `.doc`
+
+        - `.docx`
+
+        - `.odt`
+
+        - `.xls`
+
+        - `.xlsx`
+
+        - `.ods`
+
+        - `.ppt`
+
+        - `.pptx`
+
+        - `.odp`
+
+
+        All files will be merged into a single PDF.
+
+        > **Attention:** The files will be merged alphabetically for the
+        resulting PDF.
+
+
+        You may also specify the page ranges to convert from the incoming Office
+        documents. The expected format is the same as the one from the print
+        options of LibreOffice, e.g. `1-1` or `1-4`.
+
+
+        > **Attention:** if more than one document, the page ranges will be
+        applied for each document.
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              $ref: '#/components/schemas/OfficeConvertRequestBody'
+        description: >-
+          The request body must have an `index.html` file in the `files` array,
+          as well as all the referred markdown resources on the same level as
+          the `index.html` file.
+      responses:
+        '200':
+          $ref: '#/components/responses/SuccessfulPDF'
+          content:
+            application/json:
+              schema:
+                type: object
+                properties: {}
+  /convert/merge:
+    post:
+      summary: Merge multiple PDFs into a single PDF
+      description: >-
+        You can send multiple PDF files to this endpoint, the API will merge
+        them into a single PDF and return the resulting PDF file.
+
+
+        > **Attention:** The PDF files will be merged alphabetically.
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                files:
+                  type: array
+                  description: >-
+                    List of HTML files to be converted to PDF. An `index.html`
+                    file is required, and any other resources that are
+                    referenced through the HTML file must be included as well.
+                    All the referenced files must be on the same level as the
+                    `index.html` file.
+                  items:
+                    type: string
+                    format: binary
+                resultFilename:
+                  type: string
+                  example: output.pdf
+                  description: >-
+                    If provided, the API will return the resulting PDF file with
+                    the given filename. Otherwise a random filename is used.
+              required:
+                - files
+        description: >-
+          The request body must have an `index.html` file in the `files` array,
+          as well as all the referred markdown resources on the same level as
+          the `index.html` file.
+      responses:
+        '200':
+          $ref: '#/components/responses/SuccessfulPDF'
+  /ping:
+    get:
+      summary: Your GET endpoint
+      tags: []
+      responses:
+        '200':
+          description: The API is working fine.
+      operationId: ''
+      description: >-
+        A simple endpoint to use as a healthcheck for the API availability with
+        a simple request.
+components:
+  schemas:
+    HTMLConvertRequestBody:
+      title: HTML Conversion Request Body
+      type: object
+      properties:
+        files:
+          type: array
+          description: >-
+            List of HTML files to be converted to PDF. An `index.html` file is
+            required, and any other resources that are referenced through the
+            HTML file must be included as well. All the referenced files must be
+            on the same level as the `index.html` file.
+          items:
+            type: string
+            format: binary
+        marginTop:
+          type: number
+          example: 0
+          default: 1
+          description: Top margin for the page in inches.
+        marginBottom:
+          type: number
+          example: 0
+          default: 1
+          description: Bottom margin for the page in inches.
+        marginLeft:
+          type: number
+          example: 0
+          default: 1
+          description: Left margin for the page in inches.
+        marginRight:
+          type: number
+          example: 0
+          default: 1
+          description: Right margin for the page in inches.
+        paperWidth:
+          type: number
+          example: 8.27
+          description: >-
+            Paper width to be used while rendering the PDF. The default page
+            size is A4.
+        paperHeight:
+          type: number
+          example: 11.69
+          description: >-
+            Paper height to be used while rendering the PDF. The default page
+            size is A4.
+        landscape:
+          type: boolean
+          example: true
+          default: false
+          description: >-
+            The default orientation for rendering the page is "portrait" mode.
+            By sending "landscape" parameter, you can ask the output to be
+            landscape.
+        resultFilename:
+          type: string
+          example: output.pdf
+          description: >-
+            If provided, the API will return the resulting PDF file with the
+            given filename. Otherwise a random filename is used.
+      required:
+        - files
+    MarkdownConvertRequestBody:
+      title: Markdown Conversion Request Body
+      type: object
+      properties:
+        files:
+          type: array
+          description: >-
+            List of HTML files to be converted to PDF. An `index.html` file is
+            required, and any other resources that are referenced through the
+            HTML file must be included as well. All the referenced files must be
+            on the same level as the `index.html` file.
+          items:
+            type: string
+            format: binary
+        marginTop:
+          type: number
+          example: 0
+          default: 1
+          description: Top margin for the page in inches.
+        marginBottom:
+          type: number
+          example: 0
+          default: 1
+          description: Bottom margin for the page in inches.
+        marginLeft:
+          type: number
+          example: 0
+          default: 1
+          description: Left margin for the page in inches.
+        marginRight:
+          type: number
+          example: 0
+          default: 1
+          description: Right margin for the page in inches.
+        paperWidth:
+          type: number
+          example: 8.27
+          description: >-
+            Paper width to be used while rendering the PDF. The default page
+            size is A4.
+        paperHeight:
+          type: number
+          example: 11.69
+          description: >-
+            Paper height to be used while rendering the PDF. The default page
+            size is A4.
+        landscape:
+          type: boolean
+          example: true
+          default: false
+          description: >-
+            The default orientation for rendering the page is "portrait" mode.
+            By sending "landscape" parameter, you can ask the output to be
+            landscape.
+        resultFilename:
+          type: string
+          example: output.pdf
+          description: >-
+            If provided, the API will return the resulting PDF file with the
+            given filename. Otherwise a random filename is used.
+      required:
+        - files
+    URLConvertRequestBody:
+      title: URL Conversion Request Body
+      type: object
+      properties:
+        remoteURL:
+          type: string
+          example: 'https://google.com'
+        marginTop:
+          type: number
+          example: 0
+          default: 1
+          description: Top margin for the page in inches.
+        marginBottom:
+          type: number
+          example: 0
+          default: 1
+          description: Bottom margin for the page in inches.
+        marginLeft:
+          type: number
+          example: 0
+          default: 1
+          description: Left margin for the page in inches.
+        marginRight:
+          type: number
+          example: 0
+          default: 1
+          description: Right margin for the page in inches.
+        paperWidth:
+          type: number
+          example: 8.27
+          description: >-
+            Paper width to be used while rendering the PDF. The default page
+            size is A4.
+        paperHeight:
+          type: number
+          example: 11.69
+          description: >-
+            Paper height to be used while rendering the PDF. The default page
+            size is A4.
+        landscape:
+          type: boolean
+          example: true
+          default: false
+          description: >-
+            The default orientation for rendering the page is "portrait" mode.
+            By sending "landscape" parameter, you can ask the output to be
+            landscape.
+        resultFilename:
+          type: string
+          example: output.pdf
+          description: >-
+            If provided, the API will return the resulting PDF file with the
+            given filename. Otherwise a random filename is used.
+      required:
+        - remoteURL
+    OfficeConvertRequestBody:
+      title: Office Conversion Request Body
+      type: object
+      properties:
+        files:
+          type: array
+          description: >-
+            List of HTML files to be converted to PDF. An `index.html` file is
+            required, and any other resources that are referenced through the
+            HTML file must be included as well. All the referenced files must be
+            on the same level as the `index.html` file.
+          items:
+            type: string
+            format: binary
+        pageRanges:
+          type: string
+          example: 1-3
+          description: >-
+            The page ranges to be converted to PDF for the incoming Office
+            documents. **If there are multiple files sent to the API, this page
+            range will apply to all of the documents**.
+        landscape:
+          type: boolean
+          example: true
+          default: false
+          description: >-
+            The default orientation for rendering the page is "portrait" mode.
+            By sending "landscape" parameter, you can ask the output to be
+            landscape.
+        resultFilename:
+          type: string
+          example: output.pdf
+          description: >-
+            If provided, the API will return the resulting PDF file with the
+            given filename. Otherwise a random filename is used.
+      required:
+        - files
+    MergeFilesRequestBody:
+      title: Merge Files Request Body
+      type: object
+      properties:
+        files:
+          type: array
+          description: >-
+            List of HTML files to be converted to PDF. An `index.html` file is
+            required, and any other resources that are referenced through the
+            HTML file must be included as well. All the referenced files must be
+            on the same level as the `index.html` file.
+          items:
+            type: string
+            format: binary
+        resultFilename:
+          type: string
+          example: output.pdf
+          description: >-
+            If provided, the API will return the resulting PDF file with the
+            given filename. Otherwise a random filename is used.
+      required:
+        - files
+  securitySchemes: {}
+  responses:
+    SuccessfulPDF:
+      description: Resulting PDF file from the conversion.
+      content:
+        application/pdf:
+          schema:
+            type: string
+            format: binary

docs/theme/gotenberg/views/index.html

@@ -34,7 +34,7 @@
       <div class="Container">
         <div class="Header">
           <div class="Title center">
-            <img src="https://user-images.githubusercontent.com/8983173/50009948-84b01e00-ffb8-11e8-850b-fc240382c626.png" alt="Gotenberg logo" width="250" height="250" />
+            <img src="https://user-images.githubusercontent.com/8983173/69229423-ac731300-0b85-11ea-8c2e-2cc00ecdb269.PNG" alt="Gotenberg logo" width="250" height="250" />
             <span class="text">{{.Title}}</span>
             <span class="subtext">{{.Subtitle}}</span>
           </div>
@@ -58,7 +58,8 @@
                 {{.Content}}
               </div>
             {{end}}
-            <div class="Footer"></div>
+            <div class="Footer">
+            </div>
             <script src="theme/gotenberg/js/index.js"></script>
           </div>
         </div>

go.mod

@@ -1,23 +1,26 @@
 module github.com/thecodingmachine/gotenberg
 
-go 1.12
+go 1.14
 
 require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/go-cmp v0.2.0 // indirect
-	github.com/gorilla/websocket v1.4.0 // indirect
-	github.com/labstack/echo/v4 v4.0.0
-	github.com/labstack/gommon v0.2.8
-	github.com/mafredri/cdp v0.22.0
-	github.com/mattn/go-colorable v0.1.1 // indirect
-	github.com/mattn/go-isatty v0.0.7 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.1
+	github.com/dustin/go-humanize v1.0.0
+	github.com/kr/text v0.2.0 // indirect
+	github.com/labstack/echo/v4 v4.1.16
+	github.com/labstack/gommon v0.3.0
+	github.com/mafredri/cdp v0.28.0
+	github.com/mattn/go-isatty v0.0.12
+	github.com/microcosm-cc/bluemonday v1.0.2
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2
 	github.com/russross/blackfriday/v2 v2.0.1
-	github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 // indirect
-	github.com/stretchr/testify v1.3.0
-	github.com/valyala/fasttemplate v1.0.1 // indirect
-	golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c // indirect
-	golang.org/x/net v0.0.0-20181201002055-351d144fa1fc // indirect
-	golang.org/x/sync v0.0.0-20181108010431-42b317875d0f
-	golang.org/x/sys v0.0.0-20190322080309-f49334f85ddc // indirect
+	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
+	github.com/sirupsen/logrus v1.6.0
+	github.com/stretchr/testify v1.6.1
+	golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9 // indirect
+	golang.org/x/net v0.0.0-20200602114024-627f9648deb9 // indirect
+	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
+	golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 // indirect
+	golang.org/x/text v0.3.2
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c // indirect
 )

go.sum

@@ -1,53 +1,102 @@
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 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/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
-github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/labstack/echo/v4 v4.0.0 h1:q1GH+caIXPP7H2StPIdzy/ez9CO0EepqYeUg6vi9SWM=
-github.com/labstack/echo/v4 v4.0.0/go.mod h1:tZv7nai5buKSg5h/8E6zz4LsD/Dqh9/91Mvs7Z5Zyno=
-github.com/labstack/gommon v0.2.8 h1:JvRqmeZcfrHC5u6uVleB4NxxNbzx6gpbJiQknDbKQu0=
-github.com/labstack/gommon v0.2.8/go.mod h1:/tj9csK2iPSBvn+3NLM9e52usepMtrd5ilFYA+wQNJ4=
-github.com/mafredri/cdp v0.22.0 h1:BV17j8hXLDWczo2SZIAFuOjMpQMIOq5DOcd9sgB2hv0=
-github.com/mafredri/cdp v0.22.0/go.mod h1:hgdiA0yp1uqhSaDOHJWPgXpMbh+LAfUdD9vbN2AM8gE=
-github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.1 h1:G1f5SKeVxmagw/IyvzvtZE4Gybcc4Tr1tf7I8z0XgOg=
-github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
-github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.7 h1:UvyT9uN+3r7yLEYSlJsbQGdsaB/a0DlgWP3pql6iwOc=
-github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/microcosm-cc/bluemonday v1.0.1 h1:SIYunPjnlXcW+gVfvm0IlSeR5U3WZUOLfVmqg85Go44=
-github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/labstack/echo/v4 v4.1.16 h1:8swiwjE5Jkai3RPfZoahp8kjVCRNq+y7Q0hPji2Kz0o=
+github.com/labstack/echo/v4 v4.1.16/go.mod h1:awO+5TzAjvL8XpibdsfXxPgHr+orhtXZJZIQCVjogKI=
+github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/mafredri/cdp v0.28.0 h1:v/LWC3GpactA1EaS737bl+eNUhvOaDh+FzvyoDxNM5o=
+github.com/mafredri/cdp v0.28.0/go.mod h1:11586MgpyJuQR4qiXQ/7HBame2FtGIBzymaUHZcQ0PY=
+github.com/mafredri/go-lint v0.0.0-20180911205320-920981dfc79e/go.mod h1:k/zdyxI3q6dup24o8xpYjJKTCf2F7rfxLp6w/efTiWs=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
+github.com/mattn/go-colorable v0.1.6/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 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/microcosm-cc/bluemonday v1.0.2 h1:5lPfLTTAvAbtS0VqT+94yOtFnGfUWYyx0+iToC3Os3s=
+github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2 h1:JhzVVoYvbOACxoUmOs6V/G4D5nPVUW73rKvXxP4XUJc=
+github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2/go.mod h1:iIss55rKnNBTvrwdmkUpLnDpZoAHvWaiq5+iMmen4AE=
 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.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 h1:/vdW8Cb7EXrkqWGufVMES1OH2sU9gKVb2n9/1y5NMBY=
-github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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 v0.0.0-20170224212429-dcecefd839c4 h1:gKMu1Bf6QINDnvyZuTaACm9ofY+PRh+5vFz4oxBZeF8=
-github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4/go.mod h1:50wTf68f99/Zt14pr046Tgt3Lp2vLyFZKzbFXTOabXw=
-github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
-golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c h1:Vj5n4GlwjmQteupaxJ9+0FNOmBrHfq7vN4btdGoDZgI=
-golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc h1:a3CU5tJYVj92DY2LaA1kUkrsqD5/3mLDhx2NcNqyW+0=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+github.com/valyala/fasttemplate v1.1.0 h1:RZqt0yGBsps8NGvLSGW804QQqCUYYLsaOjTVHy1Ocw4=
+github.com/valyala/fasttemplate v1.1.0/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+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-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9 h1:vEg9joUBmeBcK9iSJftGNf3coIG4HqZElCPehJsfAYM=
+golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+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-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9 h1:pNX+40auqi2JqRfOP1akLGtYcn15TUbkhwuCO3foqqM=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a h1:WXEvlFVvvGxCJLG6REjsT03iWnKLEWinaScsxF2Vm2o=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/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-20190322080309-f49334f85ddc h1:4gbWbmmPFp4ySWICouJl6emP0MyS31yy9SrTlAGFT+g=
-golang.org/x/sys v0.0.0-20190322080309-f49334f85ddc/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/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-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 h1:OjiUf46hAmXblsZdnoSXsEUSKU8r1UEzcL5RVZ4gO9Y=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200330183114-f8bfb4ee3038 h1:FUufmZ17Dp41BwLDPii6R8vp0QtIquTiDIxcbFlY1ek=
+golang.org/x/tools v0.0.0-20200330183114-f8bfb4ee3038/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+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-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/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-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c h1:grhR+C34yXImVGp7EzNk+DTIk+323eIUWOmEevy6bDo=
+gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/app/api/api.go

@@ -1,53 +0,0 @@
-package api
-
-import (
-	"github.com/labstack/echo/v4"
-)
-
-const pingEndpoint = "/ping"
-
-// Options allows to customize the behaviour
-// of the API.
-type Options struct {
-	DefaultWaitTimeout       float64
-	DefaultListenPort        string
-	EnableChromeEndpoints    bool
-	EnableUnoconvEndpoints   bool
-	EnableHealthcheckLogging bool
-}
-
-// DefaultOptions returns default options.
-func DefaultOptions() *Options {
-	return &Options{
-		DefaultWaitTimeout:       10,
-		DefaultListenPort:        "3000",
-		EnableChromeEndpoints:    true,
-		EnableUnoconvEndpoints:   true,
-		EnableHealthcheckLogging: true,
-	}
-}
-
-// New returns an API.
-func New(opts *Options) *echo.Echo {
-	api := echo.New()
-	api.HideBanner = true
-	api.HidePort = true
-	api.Use(handleLogging(opts.EnableHealthcheckLogging))
-	api.GET(pingEndpoint, func(c echo.Context) error { return nil })
-	g := api.Group("/convert")
-	g.Use(handleContext(opts))
-	g.Use(handleError())
-	g.POST("/merge", merge)
-	if !opts.EnableChromeEndpoints && !opts.EnableUnoconvEndpoints {
-		return api
-	}
-	if opts.EnableChromeEndpoints {
-		g.POST("/html", convertHTML)
-		g.POST("/url", convertURL)
-		g.POST("/markdown", convertMarkdown)
-	}
-	if opts.EnableUnoconvEndpoints {
-		g.POST("/office", convertOffice)
-	}
-	return api
-}

internal/app/api/api_test.go

@@ -1,128 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/labstack/echo/v4"
-	"github.com/thecodingmachine/gotenberg/test"
-)
-
-func TestDefaultWaitTimeout(t *testing.T) {
-	opts := DefaultOptions()
-	opts.DefaultWaitTimeout = 0
-	srv := New(opts)
-	// testing if timeout.
-	body, contentType := test.URLTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-	// testing if no timeout.
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{waitTimeout: "10"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-}
-
-func TestDisableChromeEndpoints(t *testing.T) {
-	opts := DefaultOptions()
-	opts.EnableChromeEndpoints = false
-	srv := New(opts)
-	// Ping.
-	req := httptest.NewRequest(http.MethodGet, "/ping", nil)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Merge.
-	body, contentType := test.PDFTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// HTML.
-	body, contentType = test.HTMLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// Markdown.
-	body, contentType = test.MarkdownTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// URL.
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// Office.
-	body, contentType = test.OfficeTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-}
-
-func TestDisableUnoconvEndpoints(t *testing.T) {
-	opts := DefaultOptions()
-	opts.EnableUnoconvEndpoints = false
-	srv := New(opts)
-	// Ping.
-	req := httptest.NewRequest(http.MethodGet, "/ping", nil)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Merge.
-	body, contentType := test.PDFTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// HTML.
-	body, contentType = test.HTMLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Markdown.
-	body, contentType = test.MarkdownTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// URL.
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Office.
-	body, contentType = test.OfficeTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-}
-func TestDisableChromeAndUnoconvEndpoints(t *testing.T) {
-	opts := DefaultOptions()
-	opts.EnableChromeEndpoints = false
-	opts.EnableUnoconvEndpoints = false
-	srv := New(opts)
-	// Ping.
-	req := httptest.NewRequest(http.MethodGet, "/ping", nil)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Merge.
-	body, contentType := test.PDFTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// HTML.
-	body, contentType = test.HTMLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// Markdown.
-	body, contentType = test.MarkdownTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// URL.
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-	// Office.
-	body, contentType = test.OfficeTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
-}

internal/app/api/doc.go

@@ -1,2 +0,0 @@
-// Package api helps managing the HTTP server behind Gotenberg.
-package api

internal/app/api/handler.go

@@ -1,157 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-
-	"github.com/labstack/echo/v4"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/rand"
-)
-
-type errBadRequest struct {
-	err error
-}
-
-func (e *errBadRequest) Error() string {
-	return e.err.Error()
-}
-
-func merge(c echo.Context) error {
-	ctx := c.(*resourceContext)
-	opts, err := ctx.resource.mergePrinterOptions()
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	fpaths, err := ctx.resource.fpaths(".pdf")
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	p := printer.NewMerge(fpaths, opts)
-	return convert(ctx, p)
-}
-
-func convertHTML(c echo.Context) error {
-	ctx := c.(*resourceContext)
-	opts, err := ctx.resource.chromePrinterOptions()
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	fpath, err := ctx.resource.fpath("index.html")
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	p := printer.NewHTML(fpath, opts)
-	return convert(ctx, p)
-}
-
-func convertMarkdown(c echo.Context) error {
-	ctx := c.(*resourceContext)
-	opts, err := ctx.resource.chromePrinterOptions()
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	fpath, err := ctx.resource.fpath("index.html")
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	p, err := printer.NewMarkdown(fpath, opts)
-	if err != nil {
-		return err
-	}
-	return convert(ctx, p)
-}
-
-func convertURL(c echo.Context) error {
-	ctx := c.(*resourceContext)
-	opts, err := ctx.resource.chromePrinterOptions()
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	remote, err := ctx.resource.get(remoteURL)
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	p := printer.NewURL(remote, opts)
-	return convert(ctx, p)
-}
-
-func convertOffice(c echo.Context) error {
-	ctx := c.(*resourceContext)
-	opts, err := ctx.resource.officePrinterOptions()
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	fpaths, err := ctx.resource.fpaths(
-		".txt",
-		".rtf",
-		".fodt",
-		".doc",
-		".docx",
-		".odt",
-		".xls",
-		".xlsx",
-		".ods",
-		".ppt",
-		".pptx",
-		".odp",
-	)
-	if err != nil {
-		return &errBadRequest{err}
-	}
-	p := printer.NewOffice(fpaths, opts)
-	return convert(ctx, p)
-}
-
-func convert(ctx *resourceContext, p printer.Printer) error {
-	baseFilename, err := rand.Get()
-	if err != nil {
-		return err
-	}
-	filename := fmt.Sprintf("%s.pdf", baseFilename)
-	fpath := fmt.Sprintf("%s/%s", ctx.resource.formFilesDirPath, filename)
-	// if no webhook URL given, run conversion
-	// and directly return the resulting PDF file
-	// or an error.
-	if !ctx.resource.has(webhookURL) {
-		if err := p.Print(fpath); err != nil {
-			return err
-		}
-		if ctx.resource.has(resultFilename) {
-			filename, err = ctx.resource.get(resultFilename)
-			if err != nil {
-				return &errBadRequest{err}
-			}
-		}
-		return ctx.Attachment(fpath, filename)
-	}
-	// as a webhook URL has been given, we
-	// run the following lines in a goroutine so that
-	// it doesn't block.
-	go func() {
-		defer ctx.resource.close() // nolint: errcheck
-		if err := p.Print(fpath); err != nil {
-			ctx.Logger().Error(err)
-			return
-		}
-		f, err := os.Open(fpath)
-		if err != nil {
-			ctx.Logger().Error(err)
-			return
-		}
-		defer f.Close() // nolint: errcheck
-		webhook, err := ctx.resource.get(webhookURL)
-		if err != nil {
-			ctx.Logger().Error(err)
-			return
-		}
-		resp, err := http.Post(webhook, "application/pdf", f) /* #nosec */
-		if err != nil {
-			ctx.Logger().Error(err)
-			return
-		}
-		defer resp.Body.Close() // nolint: errcheck
-	}()
-	return nil
-}

internal/app/api/handler_test.go

@@ -1,360 +0,0 @@
-package api
-
-import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/labstack/echo/v4"
-	"github.com/stretchr/testify/assert"
-	"github.com/thecodingmachine/gotenberg/test"
-)
-
-func TestMerge(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	// OK.
-	body, contentType := test.PDFTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Bad request.
-	body, contentType = test.PDFTestMultipartForm(t, map[string]string{waitTimeout: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	// Timeout.
-	body, contentType = test.PDFTestMultipartForm(t, map[string]string{waitTimeout: "0"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-}
-
-func TestHTML(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	// OK.
-	body, contentType := test.HTMLTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Bad request.
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{waitTimeout: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{waitDelay: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{paperWidth: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{paperHeight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{marginTop: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{marginBottom: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{marginLeft: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{marginRight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{landscape: "not a bool"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	// Timeout.
-	body, contentType = test.HTMLTestMultipartForm(t, map[string]string{waitTimeout: "0"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/html", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-}
-
-func TestMarkdown(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	// OK.
-	body, contentType := test.MarkdownTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Bad request.
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{waitTimeout: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{waitDelay: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{paperWidth: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{paperHeight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{marginTop: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{marginBottom: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{marginLeft: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{marginRight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{landscape: "not a bool"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	// Timeout.
-	body, contentType = test.MarkdownTestMultipartForm(t, map[string]string{waitTimeout: "0"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-}
-
-func TestURL(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	// OK.
-	body, contentType := test.URLTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Bad request.
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{waitTimeout: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{waitDelay: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{paperWidth: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{paperHeight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{marginTop: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{marginBottom: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{marginLeft: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{marginRight: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{landscape: "not a bool"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	// Timeout.
-	body, contentType = test.URLTestMultipartForm(t, map[string]string{waitTimeout: "0"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/url", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-}
-
-func TestOffice(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	// OK.
-	body, contentType := test.OfficeTestMultipartForm(t, nil)
-	req := httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	// Bad request.
-	body, contentType = test.OfficeTestMultipartForm(t, map[string]string{waitTimeout: "not a float"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.OfficeTestMultipartForm(t, map[string]string{landscape: "not a bool"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	body, contentType = test.URLTestMultipartForm(t, nil)
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
-	// Timeout.
-	body, contentType = test.OfficeTestMultipartForm(t, map[string]string{waitTimeout: "0"})
-	req = httptest.NewRequest(http.MethodPost, "/convert/office", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusRequestTimeout, srv, req)
-}
-
-func TestConcurrent(t *testing.T) {
-	opts := DefaultOptions()
-	opts.DefaultWaitTimeout = 30
-	srv := New(opts)
-	// Merge.
-	test.AssertConcurrent(
-		t,
-		func() error {
-			body, contentType := test.MarkdownTestMultipartForm(t, nil)
-			req := httptest.NewRequest(http.MethodPost, "/convert/html", body)
-			req.Header.Set(echo.HeaderContentType, contentType)
-			rec := httptest.NewRecorder()
-			srv.ServeHTTP(rec, req)
-			if rec.Code != http.StatusOK {
-				return fmt.Errorf("wrong status code: want %d got %d", http.StatusOK, rec.Code)
-			}
-			return nil
-		},
-		10,
-	)
-	// HTML.
-	test.AssertConcurrent(
-		t,
-		func() error {
-			body, contentType := test.HTMLTestMultipartForm(t, nil)
-			req := httptest.NewRequest(http.MethodPost, "/convert/html", body)
-			req.Header.Set(echo.HeaderContentType, contentType)
-			rec := httptest.NewRecorder()
-			srv.ServeHTTP(rec, req)
-			if rec.Code != http.StatusOK {
-				return fmt.Errorf("wrong status code: want %d got %d", http.StatusOK, rec.Code)
-			}
-			return nil
-		},
-		10,
-	)
-	// Markdown.
-	test.AssertConcurrent(
-		t,
-		func() error {
-			body, contentType := test.MarkdownTestMultipartForm(t, nil)
-			req := httptest.NewRequest(http.MethodPost, "/convert/markdown", body)
-			req.Header.Set(echo.HeaderContentType, contentType)
-			rec := httptest.NewRecorder()
-			srv.ServeHTTP(rec, req)
-			if rec.Code != http.StatusOK {
-				return fmt.Errorf("wrong status code: want %d got %d", http.StatusOK, rec.Code)
-			}
-			return nil
-		},
-		10,
-	)
-	// URL.
-	test.AssertConcurrent(
-		t,
-		func() error {
-			body, contentType := test.URLTestMultipartForm(t, nil)
-			req := httptest.NewRequest(http.MethodPost, "/convert/url", body)
-			req.Header.Set(echo.HeaderContentType, contentType)
-			rec := httptest.NewRecorder()
-			srv.ServeHTTP(rec, req)
-			if rec.Code != http.StatusOK {
-				return fmt.Errorf("wrong status code: want %d got %d", http.StatusOK, rec.Code)
-			}
-			return nil
-		},
-		10,
-	)
-	// Office.
-	test.AssertConcurrent(
-		t,
-		func() error {
-			body, contentType := test.OfficeTestMultipartForm(t, nil)
-			req := httptest.NewRequest(http.MethodPost, "/convert/office", body)
-			req.Header.Set(echo.HeaderContentType, contentType)
-			rec := httptest.NewRecorder()
-			srv.ServeHTTP(rec, req)
-			if rec.Code != http.StatusOK {
-				return fmt.Errorf("wrong status code: want %d got %d", http.StatusOK, rec.Code)
-			}
-			return nil
-		},
-		10,
-	)
-}
-
-func TestWebhook(t *testing.T) {
-	status := make(chan error, 2)
-	rcv := echo.New()
-	rcv.POST("/foo", func(c echo.Context) error {
-		if c.Request().Header.Get("Content-type") != "application/pdf" {
-			status <- fmt.Errorf("wrong Content-type: got %s want %s", c.Request().Header.Get("Content-type"), "application/pdf")
-			return nil
-		}
-		body, err := ioutil.ReadAll(c.Request().Body)
-		if err != nil {
-			status <- err
-			return nil
-		}
-		if body == nil || len(body) == 0 {
-			status <- errors.New("empty body")
-			return nil
-		}
-		status <- nil
-		return nil
-	})
-	go func() {
-		rcv.Start(":3001")
-	}()
-	opts := DefaultOptions()
-	srv := New(opts)
-	body, contentType := test.PDFTestMultipartForm(t, map[string]string{webhookURL: "http://localhost:3001/foo"})
-	req := httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	test.AssertStatusCode(t, http.StatusOK, srv, req)
-	err := <-status
-	assert.NoError(t, err)
-}
-
-func TestResultFilename(t *testing.T) {
-	opts := DefaultOptions()
-	srv := New(opts)
-	body, contentType := test.PDFTestMultipartForm(t, map[string]string{resultFilename: "foo.pdf"})
-	req := httptest.NewRequest(http.MethodPost, "/convert/merge", body)
-	req.Header.Set(echo.HeaderContentType, contentType)
-	rec := httptest.NewRecorder()
-	srv.ServeHTTP(rec, req)
-	assert.Equal(t, "attachment; filename=\"foo.pdf\"", rec.Header().Get("Content-Disposition"))
-}

internal/app/api/middleware.go

@@ -1,75 +0,0 @@
-package api
-
-import (
-	"context"
-	"net/http"
-	"strings"
-
-	"github.com/labstack/echo/v4"
-	"github.com/labstack/echo/v4/middleware"
-)
-
-func handleLogging(enableHealthcheckLogging bool) echo.MiddlewareFunc {
-	if enableHealthcheckLogging {
-		// default logging middleware.
-		return middleware.Logger()
-	}
-	// middleware for skipping logging when the ping endpoint is called.
-	return middleware.LoggerWithConfig(middleware.LoggerConfig{
-		Skipper: func(c echo.Context) bool {
-			return c.Request().URL.Path == pingEndpoint
-		},
-	})
-}
-
-func handleContext(opts *Options) echo.MiddlewareFunc {
-	// middleware for extending default context with our
-	// custom constext.
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(c echo.Context) error {
-			ctx := &resourceContext{c, opts, nil}
-			r, err := newResource(ctx)
-			if err != nil {
-				if resourceErr := r.close(); resourceErr != nil {
-					c.Logger().Error(resourceErr)
-				}
-				return err
-			}
-			ctx.resource = r
-			return next(ctx)
-		}
-	}
-}
-
-func handleError() echo.MiddlewareFunc {
-	// middleware for handling errors and removing resources
-	// once the request has been handled.
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(c echo.Context) error {
-			err := next(c)
-			ctx := c.(*resourceContext)
-			// if a webhookURL has been given,
-			// do not remove the resources here because
-			// we don't know if the result file has been
-			// generated or sent.
-			if !ctx.resource.has(webhookURL) {
-				if resourceErr := ctx.resource.close(); resourceErr != nil {
-					c.Logger().Error(resourceErr)
-				}
-			}
-			if err != nil {
-				if _, ok := err.(*echo.HTTPError); ok {
-					return err
-				}
-				if _, ok := err.(*errBadRequest); ok {
-					return echo.NewHTTPError(http.StatusBadRequest, err.Error())
-				}
-				if strings.Contains(err.Error(), context.DeadlineExceeded.Error()) {
-					return echo.NewHTTPError(http.StatusRequestTimeout)
-				}
-				return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
-			}
-			return nil
-		}
-	}
-}

internal/app/api/resource.go

@@ -1,310 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"github.com/labstack/echo/v4"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/rand"
-)
-
-const (
-	resultFilename string = "resultFilename"
-	waitTimeout    string = "waitTimeout"
-	webhookURL     string = "webhookURL"
-	remoteURL      string = "remoteURL"
-	waitDelay      string = "waitDelay"
-	paperWidth     string = "paperWidth"
-	paperHeight    string = "paperHeight"
-	marginTop      string = "marginTop"
-	marginBottom   string = "marginBottom"
-	marginLeft     string = "marginLeft"
-	marginRight    string = "marginRight"
-	landscape      string = "landscape"
-)
-
-type resource struct {
-	formValues       map[string]string
-	formFilesDirPath string
-	opts             *Options
-}
-
-type resourceContext struct {
-	echo.Context
-	opts     *Options
-	resource *resource
-}
-
-func newResource(ctx *resourceContext) (*resource, error) {
-	r := &resource{
-		formValues: formValues(ctx),
-		opts:       ctx.opts,
-	}
-	dirPath, err := rand.Get()
-	if err != nil {
-		return r, err
-	}
-	r.formFilesDirPath = dirPath
-	if err := os.MkdirAll(dirPath, 0755); err != nil {
-		return nil, fmt.Errorf("%s: making directory: %v", dirPath, err)
-	}
-	if err := formFiles(ctx, dirPath); err != nil {
-		return r, err
-	}
-	return r, nil
-}
-
-func formValues(ctx *resourceContext) map[string]string {
-	v := make(map[string]string)
-	v[resultFilename] = ctx.FormValue(resultFilename)
-	v[waitTimeout] = ctx.FormValue(waitTimeout)
-	v[webhookURL] = ctx.FormValue(webhookURL)
-	v[remoteURL] = ctx.FormValue(remoteURL)
-	v[waitDelay] = ctx.FormValue(waitDelay)
-	v[paperWidth] = ctx.FormValue(paperWidth)
-	v[paperHeight] = ctx.FormValue(paperHeight)
-	v[marginTop] = ctx.FormValue(marginTop)
-	v[marginBottom] = ctx.FormValue(marginBottom)
-	v[marginLeft] = ctx.FormValue(marginLeft)
-	v[marginRight] = ctx.FormValue(marginRight)
-	v[landscape] = ctx.FormValue(landscape)
-	return v
-}
-
-func formFiles(ctx *resourceContext, dirPath string) error {
-	form, err := ctx.MultipartForm()
-	if err != nil {
-		return fmt.Errorf("getting multipart form: %v", err)
-	}
-	for _, files := range form.File {
-		for _, fh := range files {
-			in, err := fh.Open()
-			if err != nil {
-				return fmt.Errorf("%s: opening file: %v", fh.Filename, err)
-			}
-			defer in.Close() // nolint: errcheck
-			fpath := fmt.Sprintf("%s/%s", dirPath, fh.Filename)
-			out, err := os.Create(fpath)
-			if err != nil {
-				return fmt.Errorf("%s: creating new file: %v", fpath, err)
-			}
-			defer out.Close() // nolint: errcheck
-			if err := out.Chmod(0644); err != nil {
-				return fmt.Errorf("%s: changing file mode: %v", fpath, err)
-			}
-			if _, err := io.Copy(out, in); err != nil {
-				return fmt.Errorf("%s: writing file: %v", fpath, err)
-			}
-			if _, err := out.Seek(0, 0); err != nil {
-				return fmt.Errorf("%s: resetting read pointer: %v", fpath, err)
-			}
-		}
-	}
-	return nil
-}
-
-func (r *resource) close() error {
-	if _, err := os.Stat(r.formFilesDirPath); os.IsNotExist(err) {
-		return nil
-	}
-	return os.RemoveAll(r.formFilesDirPath)
-}
-
-const defaultHeaderFooterHTML string = "<html><head></head><body></body></html>"
-
-func (r *resource) chromePrinterOptions() (*printer.ChromeOptions, error) {
-	timeout, err := r.float64(waitTimeout, r.opts.DefaultWaitTimeout)
-	if err != nil {
-		return nil, err
-	}
-	delay, err := r.float64(waitDelay, 0.0)
-	if err != nil {
-		return nil, err
-	}
-	header, err := r.content("header.html", defaultHeaderFooterHTML)
-	if err != nil {
-		return nil, err
-	}
-	footer, err := r.content("footer.html", defaultHeaderFooterHTML)
-	if err != nil {
-		return nil, err
-	}
-	width, err := r.float64(paperWidth, 8.27)
-	if err != nil {
-		return nil, err
-	}
-	height, err := r.float64(paperHeight, 11.7)
-	if err != nil {
-		return nil, err
-	}
-	top, err := r.float64(marginTop, 1)
-	if err != nil {
-		return nil, err
-	}
-	bottom, err := r.float64(marginBottom, 1)
-	if err != nil {
-		return nil, err
-	}
-	left, err := r.float64(marginLeft, 1)
-	if err != nil {
-		return nil, err
-	}
-	right, err := r.float64(marginRight, 1)
-	if err != nil {
-		return nil, err
-	}
-	landscape, err := r.bool(landscape, false)
-	if err != nil {
-		return nil, err
-	}
-	return &printer.ChromeOptions{
-		WaitTimeout:  timeout,
-		WaitDelay:    delay,
-		HeaderHTML:   header,
-		FooterHTML:   footer,
-		PaperWidth:   width,
-		PaperHeight:  height,
-		MarginTop:    top,
-		MarginBottom: bottom,
-		MarginLeft:   left,
-		MarginRight:  right,
-		Landscape:    landscape,
-	}, nil
-}
-
-func (r *resource) officePrinterOptions() (*printer.OfficeOptions, error) {
-	timeout, err := r.float64(waitTimeout, r.opts.DefaultWaitTimeout)
-	if err != nil {
-		return nil, err
-	}
-	landscape, err := r.bool(landscape, false)
-	if err != nil {
-		return nil, err
-	}
-	return &printer.OfficeOptions{
-		WaitTimeout: timeout,
-		Landscape:   landscape,
-	}, nil
-}
-
-func (r *resource) mergePrinterOptions() (*printer.MergeOptions, error) {
-	timeout, err := r.float64(waitTimeout, r.opts.DefaultWaitTimeout)
-	if err != nil {
-		return nil, err
-	}
-	return &printer.MergeOptions{
-		WaitTimeout: timeout,
-	}, nil
-}
-
-func (r *resource) has(key string) bool {
-	v, ok := r.formValues[key]
-	if ok {
-		ok = v != ""
-	}
-	return ok
-}
-
-func (r *resource) hasFile(filename string) bool {
-	fpath := fmt.Sprintf("%s/%s", r.formFilesDirPath, filename)
-	_, err := os.Stat(fpath)
-	return !os.IsNotExist(err)
-}
-
-func (r *resource) get(key string) (string, error) {
-	v, ok := r.formValues[key]
-	if !ok {
-		return "", fmt.Errorf("form value %s does not exist", key)
-	}
-	return v, nil
-}
-
-func (r *resource) float64(key string, defaultValue float64) (float64, error) {
-	if !r.has(key) {
-		return defaultValue, nil
-	}
-	v, err := r.get(key)
-	if err != nil {
-		return 0.0, err
-	}
-	f, err := strconv.ParseFloat(v, 64)
-	if err != nil {
-		return 0.0, fmt.Errorf("form value %s: %v", key, err)
-	}
-	return f, nil
-}
-
-func (r *resource) bool(key string, defaultValue bool) (bool, error) {
-	if !r.has(key) {
-		return defaultValue, nil
-	}
-	v, err := r.get(key)
-	if err != nil {
-		return false, err
-	}
-	b, err := strconv.ParseBool(v)
-	if err != nil {
-		return false, fmt.Errorf("form value %s: %v", key, err)
-	}
-	return b, nil
-}
-
-func (r *resource) fpath(filename string) (string, error) {
-	fpath := fmt.Sprintf("%s/%s", r.formFilesDirPath, filename)
-	_, err := os.Stat(fpath)
-	if os.IsNotExist(err) {
-		return "", fmt.Errorf("%s: form file does not exist", filename)
-	}
-	absPath, err := filepath.Abs(fpath)
-	if err != nil {
-		return "", fmt.Errorf("%s: getting absolute path: %v", fpath, err)
-	}
-	return absPath, nil
-}
-
-func (r *resource) content(filename string, defaultValue string) (string, error) {
-	if !r.hasFile(filename) {
-		return defaultValue, nil
-	}
-	fpath, err := r.fpath(filename)
-	if err != nil {
-		return "", err
-	}
-	b, err := ioutil.ReadFile(fpath)
-	if err != nil {
-		return "", fmt.Errorf("%s: reading form file: %v", fpath, err)
-	}
-	return string(b), nil
-}
-
-func (r *resource) fpaths(exts ...string) ([]string, error) {
-	var fpaths []string
-	err := filepath.Walk(r.formFilesDirPath, func(path string, info os.FileInfo, _ error) error {
-		if info.IsDir() {
-			return nil
-		}
-		fpath, err := r.fpath(info.Name())
-		if err != nil {
-			return err
-		}
-		for _, ext := range exts {
-			if filepath.Ext(fpath) == ext {
-				fpaths = append(fpaths, fpath)
-				return nil
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	if len(fpaths) == 0 {
-		return nil, fmt.Errorf("no form files found for extensions: %v", exts)
-	}
-	return fpaths, nil
-}

internal/app/xhttp/doc.go

@@ -0,0 +1,3 @@
+// Package xhttp defines our own implementation
+// of echo.Echo.
+package xhttp

internal/app/xhttp/handler.go

@@ -0,0 +1,383 @@
+package xhttp
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+
+	"github.com/labstack/echo/v4"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/context"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/resource"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/chrome"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xrand"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xtime"
+)
+
+func pingEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "ping")
+}
+
+func mergeEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "merge")
+}
+
+func htmlEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "convert/html")
+}
+
+func urlEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "convert/url")
+}
+
+func markdownEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "convert/markdown")
+}
+
+func officeEndpoint(config conf.Config) string {
+	return fmt.Sprintf("%s%s", config.RootPath(), "convert/office")
+}
+
+func isMultipartFormDataEndpoint(config conf.Config, path string) bool {
+	var multipartFormDataEndpoints []string
+	multipartFormDataEndpoints = append(multipartFormDataEndpoints, mergeEndpoint(config))
+	if !config.DisableGoogleChrome() {
+		multipartFormDataEndpoints = append(
+			multipartFormDataEndpoints,
+			htmlEndpoint(config),
+			urlEndpoint(config),
+			markdownEndpoint(config),
+		)
+	}
+	if !config.DisableUnoconv() {
+		multipartFormDataEndpoints = append(
+			multipartFormDataEndpoints,
+			officeEndpoint(config),
+		)
+	}
+	for _, endpoint := range multipartFormDataEndpoints {
+		if endpoint == path {
+			return true
+		}
+	}
+	return false
+}
+
+// pingHandler is the handler for healthcheck.
+func pingHandler(c echo.Context) error {
+	const op string = "xhttp.pingHandler"
+	ctx := context.MustCastFromEchoContext(c)
+	logger := ctx.XLogger()
+	config := ctx.Config()
+
+	logger.DebugOp(op, "handling ping request...")
+
+	if !config.DisableGoogleChrome() {
+		_, err := chrome.IsViable(logger)
+		if err != nil {
+			return xerror.New(op, err)
+		}
+	}
+
+	return nil
+}
+
+// mergeHandler is the handler for merging
+// PDF files.
+func mergeHandler(c echo.Context) error {
+	const op string = "xhttp.mergeHandler"
+	resolver := func() error {
+		ctx := context.MustCastFromEchoContext(c)
+		logger := ctx.XLogger()
+		logger.DebugOp(op, "handling merge request...")
+		r := ctx.MustResource()
+		opts, err := mergePrinterOptions(r, ctx.Config())
+		if err != nil {
+			return xerror.New(op, err)
+		}
+		fpaths, err := r.Fpaths(".pdf")
+		if err != nil {
+			return err
+		}
+		p := printer.NewMergePrinter(logger, fpaths, opts)
+		return convert(ctx, p)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// htmlHandler is the handler for converting
+// HTML to PDF.
+func htmlHandler(c echo.Context) error {
+	const op string = "xhttp.htmlHandler"
+	resolver := func() error {
+		ctx := context.MustCastFromEchoContext(c)
+		logger := ctx.XLogger()
+		logger.DebugOp(op, "handling HTML request...")
+		r := ctx.MustResource()
+		opts, err := chromePrinterOptions(r, ctx.Config())
+		if err != nil {
+			return err
+		}
+		fpath, err := r.Fpath("index.html")
+		if err != nil {
+			return err
+		}
+		p := printer.NewHTMLPrinter(logger, fpath, opts)
+		return convert(ctx, p)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// urlHandler is the handler for converting
+// a URL to PDF.
+func urlHandler(c echo.Context) error {
+	const op string = "xhttp.urlHandler"
+	resolver := func() error {
+		ctx := context.MustCastFromEchoContext(c)
+		logger := ctx.XLogger()
+		logger.DebugOp(op, "handling URL request...")
+		r := ctx.MustResource()
+		opts, err := chromePrinterOptions(r, ctx.Config())
+		if err != nil {
+			return err
+		}
+		opts.CustomHTTPHeaders = resource.RemoteURLCustomHTTPHeaders(r)
+		if !r.HasArg(resource.RemoteURLArgKey) {
+			return xerror.Invalid(
+				op,
+				fmt.Sprintf("'%s' not found or empty", resource.RemoteURLArgKey),
+				nil,
+			)
+		}
+		remoteURL, err := r.StringArg(resource.RemoteURLArgKey, "")
+		if err != nil {
+			return err
+		}
+		p := printer.NewURLPrinter(logger, remoteURL, opts)
+		return convert(ctx, p)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// markdownHandler is the handler for converting
+// Markdown to PDF.
+func markdownHandler(c echo.Context) error {
+	const op string = "xhttp.markdownHandler"
+	resolver := func() error {
+		ctx := context.MustCastFromEchoContext(c)
+		logger := ctx.XLogger()
+		logger.DebugOp(op, "handling Markdown request...")
+		r := ctx.MustResource()
+		opts, err := chromePrinterOptions(r, ctx.Config())
+		if err != nil {
+			return err
+		}
+		fpath, err := r.Fpath("index.html")
+		if err != nil {
+			return err
+		}
+		p, err := printer.NewMarkdownPrinter(logger, fpath, opts)
+		if err != nil {
+			return err
+		}
+		return convert(ctx, p)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// officeHandler is the handler for converting
+// Office documents to PDF.
+func officeHandler(c echo.Context) error {
+	const op string = "xhttp.officeHandler"
+	resolver := func() error {
+		ctx := context.MustCastFromEchoContext(c)
+		logger := ctx.XLogger()
+		logger.DebugOp(op, "handling Office request...")
+		r := ctx.MustResource()
+		opts, err := officePrinterOptions(r, ctx.Config())
+		if err != nil {
+			return err
+		}
+		fpaths, err := r.Fpaths(
+			".txt",
+			".rtf",
+			".fodt",
+			".doc",
+			".docx",
+			".odt",
+			".xls",
+			".xlsx",
+			".ods",
+			".ppt",
+			".pptx",
+			".odp",
+		)
+		if err != nil {
+			return err
+		}
+		p := printer.NewOfficePrinter(logger, fpaths, opts)
+		return convert(ctx, p)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func convert(ctx context.Context, p printer.Printer) error {
+	const op string = "xhttp.convert"
+	resolver := func() error {
+		logger := ctx.XLogger()
+		r := ctx.MustResource()
+		baseFilename := xrand.Get()
+		filename := fmt.Sprintf("%s.pdf", baseFilename)
+		fpath := fmt.Sprintf("%s/%s", r.DirPath(), filename)
+		// if no webhook URL given, run conversion
+		// and directly return the resulting PDF file
+		// or an error.
+		if !r.HasArg(resource.WebhookURLArgKey) {
+			logger.DebugOpf(op, "no '%s' found, converting synchronously", resource.WebhookURLArgKey)
+			return convertSync(ctx, p, filename, fpath)
+		}
+		// as a webhook URL has been given, we
+		// run the following lines in a goroutine so that
+		// it doesn't block.
+		logger.DebugOpf(op, "'%s' found, converting asynchronously", resource.WebhookURLArgKey)
+		return convertAsync(ctx, p, filename, fpath)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func convertSync(ctx context.Context, p printer.Printer, filename, fpath string) error {
+	const op = "xhttp.convertSync"
+	resolver := func() error {
+		logger := ctx.XLogger()
+		r := ctx.MustResource()
+
+		if err := p.Print(fpath); err != nil {
+			return err
+		}
+		if !r.HasArg(resource.ResultFilenameArgKey) {
+			logger.DebugOpf(
+				op,
+				"no '%s' found, using generated filename '%s'",
+				resource.RemoteURLArgKey,
+				filename,
+			)
+			if err := ctx.Attachment(fpath, filename); err != nil {
+				return err
+			}
+			return nil
+		}
+		logger.DebugOpf(
+			op,
+			"'%s' found, so not using generated filename",
+			resource.ResultFilenameArgKey,
+		)
+		filename, err := r.StringArg(resource.ResultFilenameArgKey, filename)
+		if err != nil {
+			return err
+		}
+		if err := ctx.Attachment(fpath, filename); err != nil {
+			return err
+		}
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func convertAsync(ctx context.Context, p printer.Printer, filename, fpath string) error {
+	const op = "xhttp.convertAsync"
+	logger := ctx.XLogger()
+	r := ctx.MustResource()
+	webhookURL, err := r.StringArg(resource.WebhookURLArgKey, "")
+	if err != nil {
+		return xerror.New(op, err)
+	}
+	webhookURLTimeout, err := resource.WebhookURLTimeoutArg(r, ctx.Config())
+	if err != nil {
+		return xerror.New(op, err)
+	}
+	go func() {
+		defer r.Close()
+		if err := p.Print(fpath); err != nil {
+			xerr := xerror.New(op, err)
+			logger.ErrorOp(xerror.Op(xerr), xerr)
+			return
+		}
+		f, err := os.Open(fpath)
+		if err != nil {
+			xerr := xerror.New(op, err)
+			logger.ErrorOp(xerror.Op(xerr), xerr)
+			return
+		}
+		defer f.Close()
+		logger.DebugOpf(
+			op,
+			"preparing to send result file '%s' to '%s'...",
+			filename,
+			webhookURL,
+		)
+		httpClient := &http.Client{
+			Timeout: xtime.Duration(webhookURLTimeout),
+		}
+		req, err := http.NewRequest(http.MethodPost, webhookURL, f)
+		if err != nil {
+			xerr := xerror.New(op, err)
+			logger.ErrorOp(xerror.Op(xerr), xerr)
+			return
+		}
+		req.Header.Set(echo.HeaderContentType, "application/pdf")
+		// set custom headers (if any).
+		customHTTPHeaders := resource.WebhookURLCustomHTTPHeaders(r)
+		if len(customHTTPHeaders) > 0 {
+			for key, value := range customHTTPHeaders {
+				req.Header.Set(key, value)
+				logger.DebugOpf(op, "set '%s' to custom HTTP header '%s'", value, key)
+			}
+		} else {
+			logger.DebugOp(op, "skipping custom HTTP headers as none have been provided...")
+		}
+		// send the result file.
+		logger.DebugOpf(
+			op,
+			"sending result file '%s' to '%s'...",
+			filename,
+			webhookURL,
+		)
+		resp, err := httpClient.Do(req) /* #nosec */
+		if err != nil {
+			xerr := xerror.New(op, err)
+			logger.ErrorOp(xerror.Op(xerr), xerr)
+			return
+		}
+		defer resp.Body.Close()
+		logger.DebugOpf(
+			op,
+			"result file '%s' sent to '%s'",
+			filename,
+			webhookURL,
+		)
+	}()
+	return nil
+}

internal/app/xhttp/handler_test.go

@@ -0,0 +1,635 @@
+package xhttp
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/resource"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestPingHandler(t *testing.T) {
+	// should return 200.
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := pingEndpoint(config)
+	req := httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodPost, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+}
+
+func TestMergeHandler(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := mergeEndpoint(config)
+	// should return 200.
+	body, contentType := test.MergeMultipartForm(t, nil)
+	req := httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+	// should return 415 as Content-Type is wrong.
+	body, _ = test.MergeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	test.AssertStatusCode(t, http.StatusUnsupportedMediaType, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is < 0.
+	body, contentType = test.MergeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is is > config.MaximumWaitTimeout().
+	body, contentType = test.MergeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is invalid.
+	body, contentType = test.MergeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 504.
+	body, contentType = test.MergeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "0"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusGatewayTimeout, srv, req)
+}
+
+func TestHTMLHandler(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := htmlEndpoint(config)
+	// should return 200.
+	body, contentType := test.HTMLMultipartForm(t, nil)
+	req := httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+	// should return 415 as Content-Type is wrong.
+	body, _ = test.HTMLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	test.AssertStatusCode(t, http.StatusUnsupportedMediaType, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is is > config.MaximumWaitTimeout().
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 504.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "0"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusGatewayTimeout, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is is > config.MaximumWaitDelay().
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "landscape" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.LandscapeArgKey): "not a boolean"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is < 0.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is is > config.MaximumGoogleChromeRpccBufferSize().
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "104857601"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is invalid.
+	body, contentType = test.HTMLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "not an int"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+}
+
+func TestURLHandler(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := urlEndpoint(config)
+	// should return 200.
+	body, contentType := test.URLMultipartForm(t, nil)
+	req := httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+	// should return 415 as Content-Type is wrong.
+	body, _ = test.URLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	test.AssertStatusCode(t, http.StatusUnsupportedMediaType, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is is > config.MaximumWaitTimeout().
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 504.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "0"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusGatewayTimeout, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is is > config.MaximumWaitDelay().
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "landscape" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.LandscapeArgKey): "not a boolean"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is < 0.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is is > config.MaximumGoogleChromeRpccBufferSize().
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "104857601"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is invalid.
+	body, contentType = test.URLMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "not an int"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+}
+
+func TestMarkdownHandler(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := markdownEndpoint(config)
+	// should return 200.
+	body, contentType := test.MarkdownMultipartForm(t, nil)
+	req := httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+	// should return 415 as Content-Type is wrong.
+	body, _ = test.MarkdownMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	test.AssertStatusCode(t, http.StatusUnsupportedMediaType, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is is > config.MaximumWaitTimeout().
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 504.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "0"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusGatewayTimeout, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is is > config.MaximumWaitDelay().
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitDelay" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.WaitDelayArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperWidth" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.PaperWidthArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "paperHeight" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.PaperHeightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginTop" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginTopArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginBottom" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginBottomArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginLeft" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginLeftArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "marginRight" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.MarginRightArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "landscape" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.LandscapeArgKey): "not a boolean"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is < 0.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is is > config.MaximumGoogleChromeRpccBufferSize().
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "104857601"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "googleChromeRpccBufferSize" form field
+	// value is invalid.
+	body, contentType = test.MarkdownMultipartForm(t, map[string]string{string(resource.GoogleChromeRpccBufferSizeArgKey): "not an int"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+}
+
+func TestOfficeHandler(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	endpoint := officeEndpoint(config)
+	// should return 200.
+	// note: increased the wait timeout as it happens to timeout from time to time.
+	body, contentType := test.OfficeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "30"})
+	req := httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// should return 405 as Method is wrong.
+	req = httptest.NewRequest(http.MethodGet, endpoint, nil)
+	test.AssertStatusCode(t, http.StatusMethodNotAllowed, srv, req)
+	// should return 415 as Content-Type is wrong.
+	body, _ = test.OfficeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	test.AssertStatusCode(t, http.StatusUnsupportedMediaType, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is < 0.
+	body, contentType = test.OfficeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "-1"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is is > config.MaximumWaitTimeout().
+	body, contentType = test.OfficeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "31"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 400 as "waitTimeout" form field
+	// value is invalid.
+	body, contentType = test.OfficeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "not a float"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+	// should return 504.
+	body, contentType = test.OfficeMultipartForm(t, map[string]string{string(resource.WaitTimeoutArgKey): "0"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusGatewayTimeout, srv, req)
+	// should return 400 as "landscape" form field
+	// value is invalid.
+	body, contentType = test.OfficeMultipartForm(t, map[string]string{string(resource.LandscapeArgKey): "not a boolean"})
+	req = httptest.NewRequest(http.MethodPost, endpoint, body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusBadRequest, srv, req)
+}
+
+func TestWebhook(t *testing.T) {
+	customHeaderRealKey := http.CanonicalHeaderKey("MyCustomHeader")
+	customHeaderKey := fmt.Sprintf("%s%s", resource.WebhookURLCustomHTTPHeaderCanonicalBaseKey, customHeaderRealKey)
+	customHeaderValue := "foo"
+	status := make(chan error, 2)
+	rcv := echo.New()
+	rcv.POST("/foo", func(c echo.Context) error {
+		if c.Request().Header.Get(echo.HeaderContentType) != "application/pdf" {
+			status <- fmt.Errorf("wrong Content-type: got '%s' want '%s'", c.Request().Header.Get(echo.HeaderContentType), "application/pdf")
+			return nil
+		}
+		if c.Request().Header.Get(customHeaderRealKey) != customHeaderValue {
+			status <- fmt.Errorf("wrong '%s': got '%s' want '%s'", customHeaderRealKey, c.Request().Header.Get(customHeaderRealKey), customHeaderValue)
+			return nil
+		}
+		body, err := ioutil.ReadAll(c.Request().Body)
+		if err != nil {
+			status <- err
+			return nil
+		}
+		if body == nil || len(body) == 0 {
+			status <- errors.New("empty body")
+			return nil
+		}
+		status <- nil
+		return nil
+	})
+	go func() {
+		rcv.Start(":3001")
+	}()
+	config := conf.DefaultConfig()
+	srv := New(config)
+	// our custom server should receive the PDF.
+	body, contentType := test.MergeMultipartForm(t, map[string]string{string(resource.WebhookURLArgKey): "http://localhost:3001/foo"})
+	req := httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	req.Header.Set(customHeaderKey, customHeaderValue)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	err := <-status
+	assert.NoError(t, err)
+}
+
+func TestResultFilename(t *testing.T) {
+	config := conf.DefaultConfig()
+	srv := New(config)
+	body, contentType := test.MergeMultipartForm(t, map[string]string{string(resource.ResultFilenameArgKey): "foo.pdf"})
+	req := httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	rec := httptest.NewRecorder()
+	srv.ServeHTTP(rec, req)
+	assert.Equal(t, "attachment; filename=\"foo.pdf\"", rec.Header().Get(echo.HeaderContentDisposition))
+}

internal/app/xhttp/middleware.go

@@ -0,0 +1,153 @@
+package xhttp
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/labstack/echo/v4"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/context"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/resource"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xrand"
+)
+
+// contextMiddleware extends the default echo.Context with
+// our custom context.Context.
+func contextMiddleware(config conf.Config) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			// generate a unique identifier for the request.
+			trace := xrand.Get()
+			// create the logger for this request using
+			// the previous identifier as trace.
+			logger := xlog.New(config.LogLevel(), trace)
+			// extend the current echo context with our custom
+			// context.
+			ctx := context.New(c, logger, config)
+			// if it's not a multipart/form-data request,
+			// there is no need to create a Resource.
+			if !isMultipartFormDataEndpoint(config, ctx.Path()) {
+				// validate method for healthcheck endpoint.
+				if ctx.Path() == pingEndpoint(config) && ctx.Request().Method != http.MethodGet {
+					err := doErr(ctx, echo.NewHTTPError(http.StatusMethodNotAllowed))
+					return ctx.LogRequestResult(err, false)
+				}
+				return next(ctx)
+			}
+			// validate method.
+			if ctx.Request().Method != http.MethodPost {
+				err := doErr(ctx, echo.NewHTTPError(http.StatusMethodNotAllowed))
+				return ctx.LogRequestResult(err, false)
+			}
+			// validate Content-Type.
+			contentType := ctx.Request().Header.Get("Content-Type")
+			if !strings.Contains(contentType, "multipart/form-data") {
+				err := doErr(ctx, echo.NewHTTPError(http.StatusUnsupportedMediaType))
+				return ctx.LogRequestResult(err, false)
+			}
+			// it's a multipart/form-data request, create a
+			// Resource.
+			if err := ctx.WithResource(trace); err != nil {
+				err = doCleanup(ctx, err)
+				err = doErr(ctx, err)
+				return ctx.LogRequestResult(err, false)
+			}
+			return next(ctx)
+		}
+	}
+}
+
+// loggerMiddleware logs the result of a request.
+func loggerMiddleware(config conf.Config) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			ctx := context.MustCastFromEchoContext(c)
+			err := next(ctx)
+			// we do not want to log healthcheck requests if
+			// log level is not set to DEBUG.
+			isDebug := ctx.Path() == pingEndpoint(config)
+			return ctx.LogRequestResult(err, isDebug)
+		}
+	}
+}
+
+// cleanupMiddleware removes a resource.Resource
+// at the end of a request.
+func cleanupMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			err := next(c)
+			ctx := context.MustCastFromEchoContext(c)
+			return doCleanup(ctx, err)
+		}
+	}
+}
+
+// errorMiddleware handles errors (if any).
+func errorMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			ctx := context.MustCastFromEchoContext(c)
+			err := next(ctx)
+			if err == nil {
+				// so far so good!
+				return nil
+			}
+			return doErr(ctx, err)
+		}
+	}
+}
+
+func doCleanup(ctx context.Context, err error) error {
+	const op string = "xhttp.cleanup"
+	if !ctx.HasResource() {
+		// nothing to remove.
+		return err
+	}
+	r := ctx.MustResource()
+	// if a webhook URL has been given,
+	// do not remove the resource.Resource here because
+	// we don't know if the result file has been
+	// generated or sent.
+	if r.HasArg(resource.WebhookURLArgKey) {
+		return err
+	}
+	// a resource.Resource is associated with our custom context.
+	if resourceErr := r.Close(); resourceErr != nil {
+		xerr := xerror.New(op, resourceErr)
+		ctx.XLogger().ErrorOp(xerror.Op(xerr), xerr)
+	}
+	return err
+}
+
+func doErr(ctx context.Context, err error) error {
+	// if it's an error from echo
+	// like 404 not found and so on.
+	if echoHTTPErr, ok := err.(*echo.HTTPError); ok {
+		// required to have a correct status code.
+		ctx.Error(echoHTTPErr)
+		return echoHTTPErr
+	}
+	// we log the initial error before returning
+	// the HTTP error.
+	errOp := xerror.Op(err)
+	logger := ctx.XLogger()
+	logger.ErrorOp(errOp, err)
+	// handle our custom HTTP error.
+	var httpErr error
+	errCode := xerror.Code(err)
+	errMessage := xerror.Message(err)
+	switch errCode {
+	case xerror.InvalidCode:
+		httpErr = echo.NewHTTPError(http.StatusBadRequest, errMessage)
+	case xerror.TimeoutCode:
+		httpErr = echo.NewHTTPError(http.StatusGatewayTimeout, errMessage)
+	default:
+		httpErr = echo.NewHTTPError(http.StatusInternalServerError, errMessage)
+	}
+	// required to have a correct status code.
+	ctx.Error(httpErr)
+	return httpErr
+}

internal/app/xhttp/option.go

@@ -0,0 +1,114 @@
+package xhttp
+
+import (
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/resource"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+)
+
+func mergePrinterOptions(r resource.Resource, config conf.Config) (printer.MergePrinterOptions, error) {
+	const op string = "xhttp.mergePrinterOptions"
+	waitTimeout, err := resource.WaitTimeoutArg(r, config)
+	if err != nil {
+		return printer.MergePrinterOptions{}, xerror.New(op, err)
+	}
+	return printer.MergePrinterOptions{
+		WaitTimeout: waitTimeout,
+	}, nil
+}
+
+func chromePrinterOptions(r resource.Resource, config conf.Config) (printer.ChromePrinterOptions, error) {
+	const op string = "xhttp.chromePrinterOptions"
+	resolver := func() (printer.ChromePrinterOptions, error) {
+		waitTimeout, err := resource.WaitTimeoutArg(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		waitDelay, err := resource.WaitDelayArg(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		headerHTML, footerHTML,
+			err := resource.HeaderFooterContents(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		paperWidth, paperHeight,
+			err := resource.PaperSizeArgs(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		marginTop, marginBottom, marginLeft, marginRight,
+			err := resource.MarginArgs(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		landscape, err := r.BoolArg(resource.LandscapeArgKey, false)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		pageRanges, err := r.StringArg(resource.PageRangesArgKey, "")
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		googleChromeRpccBufferSize, err := resource.GoogleChromeRpccBufferSizeArg(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		scale, err := resource.ScaleArg(r, config)
+		if err != nil {
+			return printer.ChromePrinterOptions{}, err
+		}
+		return printer.ChromePrinterOptions{
+			WaitTimeout:       waitTimeout,
+			WaitDelay:         waitDelay,
+			HeaderHTML:        headerHTML,
+			FooterHTML:        footerHTML,
+			PaperWidth:        paperWidth,
+			PaperHeight:       paperHeight,
+			MarginTop:         marginTop,
+			MarginBottom:      marginBottom,
+			MarginLeft:        marginLeft,
+			MarginRight:       marginRight,
+			Landscape:         landscape,
+			PageRanges:        pageRanges,
+			RpccBufferSize:    googleChromeRpccBufferSize,
+			CustomHTTPHeaders: make(map[string]string),
+			Scale:             scale,
+		}, nil
+	}
+	opts, err := resolver()
+	if err != nil {
+		return opts, xerror.New(op, err)
+	}
+	return opts, nil
+}
+
+func officePrinterOptions(r resource.Resource, config conf.Config) (printer.OfficePrinterOptions, error) {
+	const op string = "xhttp.officePrinterOptions"
+	resolver := func() (printer.OfficePrinterOptions, error) {
+		waitTimeout, err := resource.WaitTimeoutArg(r, config)
+		if err != nil {
+			return printer.OfficePrinterOptions{}, err
+		}
+		landscape, err := r.BoolArg(resource.LandscapeArgKey, false)
+		if err != nil {
+			return printer.OfficePrinterOptions{}, err
+		}
+		pageRanges, err := r.StringArg(resource.PageRangesArgKey, "")
+		if err != nil {
+			return printer.OfficePrinterOptions{}, err
+		}
+		return printer.OfficePrinterOptions{
+			WaitTimeout: waitTimeout,
+			Landscape:   landscape,
+			PageRanges:  pageRanges,
+		}, nil
+	}
+	opts, err := resolver()
+	if err != nil {
+		return opts, xerror.New(op, err)
+	}
+	return opts, nil
+}

internal/app/xhttp/pkg/context/context.go

@@ -0,0 +1,210 @@
+package context
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/thecodingmachine/gotenberg/internal/app/xhttp/pkg/resource"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
+// Context extends the default echo.Context.
+type Context struct {
+	echo.Context
+	logger    xlog.Logger
+	config    conf.Config
+	resource  resource.Resource
+	startTime time.Time
+}
+
+// New creates a new Context.
+func New(c echo.Context, logger xlog.Logger, config conf.Config) Context {
+	return Context{
+		c,
+		logger,
+		config,
+		resource.Resource{},
+		time.Now(),
+	}
+}
+
+/*
+MustCastFromEchoContext cast an echo.Context
+to our custom Context.
+
+It panics if casting goes wrong.
+*/
+func MustCastFromEchoContext(c echo.Context) Context {
+	const op string = "context.MustCastFromEchoContext"
+	ctx, ok := c.(Context)
+	if !ok {
+		panic(fmt.Sprintf("%s: unable to cast an echo.Context to our custom context.Context", op))
+	}
+	return ctx
+}
+
+/*
+XLogger returns the xlog.Logger associated
+with the Context.
+
+This method should be used instead of the
+default Logger() method coming from
+the echo.Context.
+*/
+func (ctx Context) XLogger() xlog.Logger {
+	return ctx.logger
+}
+
+// Config returns the conf.Config associated
+// with the Context.
+func (ctx Context) Config() conf.Config {
+	return ctx.config
+}
+
+// WithResource creates a resource.Resource and
+// adds it to the Context.
+func (ctx *Context) WithResource(directoryName string) error {
+	const op string = "context.Context.WithResource"
+	resolver := func() (resource.Resource, error) {
+		r, err := resource.New(ctx.logger, directoryName)
+		if err != nil {
+			return r, err
+		}
+		// retrieve custom headers from request.
+		for key, value := range ctx.Request().Header {
+			r.WithCustomHTTPHeader(key, value[0])
+		}
+		// retrieve form values from request.
+		for _, key := range resource.ArgKeys() {
+			r.WithArg(key, ctx.FormValue(string(key)))
+		}
+		// write form files from request.
+		form, err := ctx.MultipartForm()
+		if err != nil {
+			/*
+				(very) special case: one and
+				only one file has been sent
+				and it is empty.
+			*/
+			if strings.Contains(err.Error(), io.EOF.Error()) {
+				return r, xerror.Invalid(op, "one file has been sent but it is empty: does it exist?", err)
+			}
+			return r, err
+		}
+		for _, files := range form.File {
+			for _, fh := range files {
+				in, err := fh.Open()
+				if err != nil {
+					return r, err
+				}
+				defer in.Close()
+				// avoid directory traversal.
+				filename := filepath.Base(fh.Filename)
+				if err := r.WithFile(filename, in); err != nil {
+					return r, err
+				}
+			}
+		}
+		return r, nil
+	}
+	resource, err := resolver()
+	ctx.resource = resource
+	if err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// HasResource returns true if the Context
+// has a resource.Resource.
+func (ctx Context) HasResource() bool {
+	return !reflect.DeepEqual(ctx.resource, resource.Resource{})
+}
+
+/*
+MustResource returns the resource.Resource
+associated with the Context.
+
+It panics if no resource.Resource.
+*/
+func (ctx Context) MustResource() resource.Resource {
+	const op string = "context.Context.MustResource"
+	if !ctx.HasResource() {
+		panic(fmt.Sprintf("%s: unable to retrieve the resource.Resource from our custom context.Context", op))
+	}
+	return ctx.resource
+}
+
+/*
+LogRequestResult logs the result of a request.
+This method should only be used by a middleware!
+
+If an error is given, returns the exact same error.
+*/
+func (ctx Context) LogRequestResult(err error, isDebug bool) error {
+	const op string = "context.Context.LogRequestResult"
+	req := ctx.Request()
+	resp := ctx.Response()
+	stopTime := time.Now()
+	fields := map[string]interface{}{
+		"remote_ip":     ctx.RealIP(),
+		"host":          req.Host,
+		"uri":           req.RequestURI,
+		"method":        req.Method,
+		"path":          path(req),
+		"referer":       req.Referer(),
+		"user_agent":    req.UserAgent(),
+		"status":        resp.Status,
+		"latency":       lantency(ctx.startTime, stopTime),
+		"latency_human": latencyHuman(ctx.startTime, stopTime),
+		"bytes_in":      bytesIn(req),
+		"bytes_out":     bytesOut(resp),
+	}
+	if err != nil {
+		ctx.logger.WithFields(fields).ErrorOpf(op, "request failed")
+		return err
+	}
+	if isDebug {
+		ctx.logger.WithFields(fields).DebugOpf(op, "request handled")
+		return nil
+	}
+	ctx.logger.WithFields(fields).InfoOpf(op, "request handled")
+	return nil
+}
+
+func path(r *http.Request) string {
+	path := r.URL.Path
+	if path == "" {
+		path = "/"
+	}
+	return path
+}
+
+func lantency(startTime time.Time, stopTime time.Time) string {
+	return strconv.FormatInt(int64(stopTime.Sub(startTime)), 10)
+}
+
+func latencyHuman(startTime time.Time, stopTime time.Time) string {
+	return stopTime.Sub(startTime).String()
+}
+
+func bytesIn(r *http.Request) string {
+	bytesIn := r.Header.Get(echo.HeaderContentLength)
+	if bytesIn == "" {
+		bytesIn = "0"
+	}
+	return bytesIn
+}
+
+func bytesOut(r *echo.Response) string {
+	return strconv.FormatInt(r.Size, 10)
+}

internal/app/xhttp/pkg/context/context_test.go

@@ -0,0 +1,78 @@
+package context
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestMustCastFromEchoContext(t *testing.T) {
+	// should be OK.
+	ctx := New(
+		test.DummyEchoContext(),
+		test.DebugLogger(),
+		conf.DefaultConfig(),
+	)
+	assert.NotPanics(t, func() {
+		result := MustCastFromEchoContext(ctx)
+		assert.Equal(t, ctx, result)
+	})
+	// should not be OK.
+	assert.Panics(t, func() {
+		MustCastFromEchoContext(test.DummyEchoContext())
+	})
+}
+
+func TestLogRequestResult(t *testing.T) {
+	ctx := New(
+		test.DummyEchoContext(),
+		test.DebugLogger(),
+		conf.DefaultConfig(),
+	)
+	// Info log.
+	err := ctx.LogRequestResult(nil, false)
+	assert.Nil(t, err)
+	// Debug log.
+	err = ctx.LogRequestResult(nil, true)
+	assert.Nil(t, err)
+	// Error log.
+	err = ctx.LogRequestResult(errors.New("foo"), true)
+	assert.NotNil(t, err)
+}
+
+func TestGetters(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	ctx := New(
+		test.DummyEchoContext(),
+		logger,
+		config,
+	)
+	// Logger.
+	assert.Equal(t, logger, ctx.XLogger())
+	// Config.
+	assert.Equal(t, config, ctx.Config())
+	// Context should not have a resource.Resource.
+	assert.Equal(t, false, ctx.HasResource())
+	assert.Panics(t, func() {
+		ctx.MustResource()
+	})
+	// Context should have a resource.Resource.
+	ctx = New(
+		test.EchoContextMultipart(t),
+		logger,
+		config,
+	)
+	err := ctx.WithResource(resourceDirectoryName)
+	assert.Nil(t, err)
+	assert.Equal(t, true, ctx.HasResource())
+	assert.NotPanics(t, func() {
+		r := ctx.MustResource()
+		err = r.Close()
+		assert.Nil(t, err)
+	})
+}

internal/app/xhttp/pkg/context/doc.go

@@ -0,0 +1,7 @@
+/*
+Package context extends the default echo.Context.
+
+All functions return our standard xerror.Error
+in case of error.
+*/
+package context

internal/app/xhttp/pkg/resource/arg.go

@@ -0,0 +1,319 @@
+package resource
+
+import (
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xassert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+)
+
+// ArgKey is a type for
+// arguments' keys.
+type ArgKey string
+
+const (
+	// ResultFilenameArgKey is the key
+	// of the argument "resultFilename".
+	ResultFilenameArgKey ArgKey = "resultFilename"
+	// WaitTimeoutArgKey is the key
+	// of the argument "waitTimeout".
+	WaitTimeoutArgKey ArgKey = "waitTimeout"
+	// WebhookURLArgKey is the key
+	// of the argument "webhookURL".
+	WebhookURLArgKey ArgKey = "webhookURL"
+	// WebhookURLTimeoutArgKey is the key
+	// of the argument "webhookURLTimeout".
+	WebhookURLTimeoutArgKey ArgKey = "webhookURLTimeout"
+	// RemoteURLArgKey is the key
+	// of the argument "remoteURL".
+	RemoteURLArgKey ArgKey = "remoteURL"
+	// WaitDelayArgKey is the key
+	// of the argument "waitDelay".
+	WaitDelayArgKey ArgKey = "waitDelay"
+	// PaperWidthArgKey is the key
+	// of the argument "paperWidth".
+	PaperWidthArgKey ArgKey = "paperWidth"
+	// PaperHeightArgKey is the key
+	// of the argument "paperHeight".
+	PaperHeightArgKey ArgKey = "paperHeight"
+	// MarginTopArgKey is the key
+	// of the argument "marginTop".
+	MarginTopArgKey ArgKey = "marginTop"
+	// MarginBottomArgKey is the key
+	// of the argument "marginBottom".
+	MarginBottomArgKey ArgKey = "marginBottom"
+	// MarginLeftArgKey is the key
+	// of the argument "marginLeft".
+	MarginLeftArgKey ArgKey = "marginLeft"
+	// MarginRightArgKey is the key
+	// of the argument "marginRight".
+	MarginRightArgKey ArgKey = "marginRight"
+	// LandscapeArgKey is the key
+	// of the argument "landscape".
+	LandscapeArgKey ArgKey = "landscape"
+	// PageRangesArgKey is the key
+	// of the argument "pageRanges".
+	PageRangesArgKey ArgKey = "pageRanges"
+	// GoogleChromeRpccBufferSizeArgKey is the key
+	// of the argument "googleChromeRpccBufferSize".
+	GoogleChromeRpccBufferSizeArgKey ArgKey = "googleChromeRpccBufferSize"
+	// ScaleArgKey is the key
+	// of the argument "scale".
+	ScaleArgKey ArgKey = "scale"
+)
+
+/*
+ArgKeys returns a slice
+containing all available
+arguments' keys.
+*/
+func ArgKeys() []ArgKey {
+	return []ArgKey{
+		ResultFilenameArgKey,
+		WaitTimeoutArgKey,
+		WebhookURLArgKey,
+		WebhookURLTimeoutArgKey,
+		RemoteURLArgKey,
+		WaitDelayArgKey,
+		PaperWidthArgKey,
+		PaperHeightArgKey,
+		MarginTopArgKey,
+		MarginBottomArgKey,
+		MarginLeftArgKey,
+		MarginRightArgKey,
+		LandscapeArgKey,
+		PageRangesArgKey,
+		GoogleChromeRpccBufferSizeArgKey,
+		ScaleArgKey,
+	}
+}
+
+/*
+WaitTimeoutArg is a helper for retrieving
+the "waitTimeout" argument as float64.
+
+It also validates it against the application
+configuration.
+*/
+func WaitTimeoutArg(r Resource, config conf.Config) (float64, error) {
+	const op string = "resource.WaitTimeoutArg"
+	result, err := r.Float64Arg(
+		WaitTimeoutArgKey,
+		config.DefaultWaitTimeout(),
+		xassert.Float64NotInferiorTo(0),
+		xassert.Float64NotSuperiorTo(config.MaximumWaitTimeout()),
+	)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+WaitDelayArg is a helper for retrieving
+the "waitDelay" argument as float64.
+
+It also validates it against the application
+configuration.
+*/
+func WaitDelayArg(r Resource, config conf.Config) (float64, error) {
+	const (
+		op               string  = "resource.WaitDelayArg"
+		defaultWaitDelay float64 = 0.0
+	)
+	result, err := r.Float64Arg(
+		WaitDelayArgKey,
+		defaultWaitDelay,
+		xassert.Float64NotInferiorTo(0.0),
+		xassert.Float64NotSuperiorTo(config.MaximumWaitDelay()),
+	)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+WebhookURLTimeoutArg is a helper for retrieving
+the "webhookURLTimeout" argument as float64.
+
+It also validates it against the application
+configuration.
+*/
+func WebhookURLTimeoutArg(r Resource, config conf.Config) (float64, error) {
+	const op string = "resource.WebhookURLTimeoutArg"
+	result, err := r.Float64Arg(
+		WebhookURLTimeoutArgKey,
+		config.DefaultWebhookURLTimeout(),
+		xassert.Float64NotInferiorTo(0),
+		xassert.Float64NotSuperiorTo(config.MaximumWebhookURLTimeout()),
+	)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+PaperSizeArgs is a helper for retrieving
+the "paperWidth" and "paperHeight" arguments
+as float64.
+*/
+func PaperSizeArgs(r Resource, config conf.Config) (float64, float64, error) {
+	const op string = "resource.PaperSizeArgs"
+	opts := printer.DefaultChromePrinterOptions(config)
+	resolver := func() (float64, float64, error) {
+		paperWidth, err := r.Float64Arg(
+			PaperWidthArgKey,
+			opts.PaperWidth,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.PaperWidth,
+				opts.PaperHeight,
+				err
+		}
+		paperHeight, err := r.Float64Arg(
+			PaperHeightArgKey,
+			opts.PaperHeight,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.PaperWidth,
+				opts.PaperHeight,
+				err
+		}
+		return paperWidth,
+			paperHeight,
+			nil
+	}
+	paperWidth, paperHeight,
+		err := resolver()
+	if err != nil {
+		return paperWidth,
+			paperHeight,
+			xerror.New(op, err)
+	}
+	return paperWidth,
+		paperHeight,
+		nil
+}
+
+/*
+MarginArgs is a helper for retrieving
+the "marginTop", "marginBottom", "marginLeft"
+and "marginRight" arguments as float64.
+*/
+func MarginArgs(r Resource, config conf.Config) (float64, float64, float64, float64, error) {
+	const op string = "resource.MarginArgs"
+	opts := printer.DefaultChromePrinterOptions(config)
+	resolver := func() (float64, float64, float64, float64, error) {
+		marginTop, err := r.Float64Arg(
+			MarginTopArgKey,
+			opts.MarginTop,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.MarginTop,
+				opts.MarginBottom,
+				opts.MarginLeft,
+				opts.MarginRight,
+				err
+		}
+		marginBottom, err := r.Float64Arg(
+			MarginBottomArgKey,
+			opts.MarginBottom,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.MarginTop,
+				opts.MarginBottom,
+				opts.MarginLeft,
+				opts.MarginRight,
+				err
+		}
+		marginLeft, err := r.Float64Arg(
+			MarginLeftArgKey,
+			opts.MarginLeft,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.MarginTop,
+				opts.MarginBottom,
+				opts.MarginLeft,
+				opts.MarginRight,
+				err
+		}
+		marginRight, err := r.Float64Arg(
+			MarginRightArgKey,
+			opts.MarginRight,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		if err != nil {
+			return opts.MarginTop,
+				opts.MarginBottom,
+				opts.MarginLeft,
+				opts.MarginRight,
+				err
+		}
+		return marginTop,
+			marginBottom,
+			marginLeft,
+			marginRight,
+			nil
+	}
+	marginTop, marginBottom, marginLeft, marginRight,
+		err := resolver()
+	if err != nil {
+		return marginTop,
+			marginBottom,
+			marginLeft,
+			marginRight,
+			xerror.New(op, err)
+	}
+	return marginTop,
+		marginBottom,
+		marginLeft,
+		marginRight,
+		nil
+}
+
+/*
+GoogleChromeRpccBufferSizeArg is a helper for retrieving
+the "googleChromeRpccBufferSize" argument as int64.
+
+It also validates it against the application
+configuration.
+*/
+func GoogleChromeRpccBufferSizeArg(r Resource, config conf.Config) (int64, error) {
+	const op string = "resource.GoogleChromeRpccBufferSizeArg"
+	result, err := r.Int64Arg(
+		GoogleChromeRpccBufferSizeArgKey,
+		config.DefaultGoogleChromeRpccBufferSize(),
+		xassert.Int64NotInferiorTo(0.0),
+		xassert.Int64NotSuperiorTo(config.MaximumGoogleChromeRpccBufferSize()),
+	)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+ScaleArg is a helper for retrieving
+the "scale" argument as float64.
+*/
+func ScaleArg(r Resource, config conf.Config) (float64, error) {
+	const op string = "resource.ScaleArg"
+	opts := printer.DefaultChromePrinterOptions(config)
+	result, err := r.Float64Arg(
+		ScaleArgKey,
+		opts.Scale,
+		xassert.Float64NotInferiorTo(0.1),
+		xassert.Float64NotSuperiorTo(2.0),
+	)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}

internal/app/xhttp/pkg/resource/arg_test.go

@@ -0,0 +1,396 @@
+package resource
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestArgKeys(t *testing.T) {
+	expected := []ArgKey{
+		ResultFilenameArgKey,
+		WaitTimeoutArgKey,
+		WebhookURLArgKey,
+		WebhookURLTimeoutArgKey,
+		RemoteURLArgKey,
+		WaitDelayArgKey,
+		PaperWidthArgKey,
+		PaperHeightArgKey,
+		MarginTopArgKey,
+		MarginBottomArgKey,
+		MarginLeftArgKey,
+		MarginRightArgKey,
+		LandscapeArgKey,
+		PageRangesArgKey,
+		GoogleChromeRpccBufferSizeArgKey,
+		ScaleArgKey,
+	}
+	assert.Equal(t, expected, ArgKeys())
+}
+
+func TestWaitTimeoutArg(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// argument does not exist.
+	expected = config.DefaultWaitTimeout()
+	v, err := WaitTimeoutArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// argument exist.
+	expected = 5.0
+	r.WithArg(WaitTimeoutArgKey, "5.0")
+	v, err = WaitTimeoutArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is < 0.
+	expected = config.DefaultWaitTimeout()
+	r.WithArg(WaitTimeoutArgKey, "-1.0")
+	v, err = WaitTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is > config.MaximumWaitTimeout().
+	expected = config.DefaultWaitTimeout()
+	r.WithArg(WaitTimeoutArgKey, "31.0")
+	v, err = WaitTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as
+	// argument value is invalid.
+	expected = config.DefaultWaitTimeout()
+	r.WithArg(WaitTimeoutArgKey, "foo")
+	v, err = WaitTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestWaitDelayArg(t *testing.T) {
+	const (
+		resourceDirectoryName string  = "foo"
+		defaultValue          float64 = 0.0
+	)
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// argument does not exist.
+	expected = defaultValue
+	v, err := WaitDelayArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// argument exist.
+	expected = 5.0
+	r.WithArg(WaitDelayArgKey, "5.0")
+	v, err = WaitDelayArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is < 0.
+	expected = defaultValue
+	r.WithArg(WaitDelayArgKey, "-1.0")
+	v, err = WaitDelayArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is > config.MaximumWaitDelay().
+	expected = defaultValue
+	r.WithArg(WaitDelayArgKey, "31.0")
+	v, err = WaitDelayArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as
+	// argument value is invalid.
+	expected = defaultValue
+	r.WithArg(WaitDelayArgKey, "foo")
+	v, err = WaitDelayArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestWebhookURLTimeoutArg(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// argument does not exist.
+	expected = config.DefaultWebhookURLTimeout()
+	v, err := WebhookURLTimeoutArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// argument exist.
+	expected = 5.0
+	r.WithArg(WebhookURLTimeoutArgKey, "5.0")
+	v, err = WebhookURLTimeoutArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is < 0.
+	expected = config.DefaultWebhookURLTimeout()
+	r.WithArg(WebhookURLTimeoutArgKey, "-1.0")
+	v, err = WebhookURLTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is > config.MaximumWebhookURLTimeout().
+	expected = config.DefaultWebhookURLTimeout()
+	r.WithArg(WebhookURLTimeoutArgKey, "31.0")
+	v, err = WebhookURLTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as
+	// argument value is invalid.
+	expected = config.DefaultWebhookURLTimeout()
+	r.WithArg(WebhookURLTimeoutArgKey, "foo")
+	v, err = WebhookURLTimeoutArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestPaperSizeArgs(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	opts := printer.DefaultChromePrinterOptions(config)
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// arguments do not exist.
+	width, height, err := PaperSizeArgs(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, opts.PaperWidth, width)
+	assert.Equal(t, opts.PaperHeight, height)
+	// arguments exist.
+	expected = 5.0
+	r.WithArg(PaperWidthArgKey, "5.0")
+	r.WithArg(PaperHeightArgKey, "5.0")
+	width, height, err = PaperSizeArgs(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, width)
+	assert.Equal(t, expected, height)
+	// should not be OK as arguments
+	// value are < 0.
+	expected = opts.PaperWidth
+	r.WithArg(PaperWidthArgKey, "-1.0")
+	width, _, err = PaperSizeArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, width)
+	r.WithArg(PaperWidthArgKey, "5.0")
+	expected = opts.PaperHeight
+	r.WithArg(PaperHeightArgKey, "-1.0")
+	_, height, err = PaperSizeArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, height)
+	r.WithArg(PaperHeightArgKey, "5.0")
+	// should not be OK as
+	// arguments value are invalids.
+	expected = opts.PaperWidth
+	r.WithArg(PaperWidthArgKey, "foo")
+	width, _, err = PaperSizeArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, width)
+	r.WithArg(PaperWidthArgKey, "5.0")
+	expected = opts.PaperHeight
+	r.WithArg(PaperHeightArgKey, "foo")
+	_, height, err = PaperSizeArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, height)
+	r.WithArg(PaperHeightArgKey, "5.0")
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestMarginArgs(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	opts := printer.DefaultChromePrinterOptions(config)
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// arguments do not exist.
+	top, bottom, left, right, err := MarginArgs(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, opts.MarginTop, top)
+	assert.Equal(t, opts.MarginBottom, bottom)
+	assert.Equal(t, opts.MarginLeft, left)
+	assert.Equal(t, opts.MarginRight, right)
+	// arguments exist.
+	expected = 5.0
+	r.WithArg(MarginTopArgKey, "5.0")
+	r.WithArg(MarginBottomArgKey, "5.0")
+	r.WithArg(MarginLeftArgKey, "5.0")
+	r.WithArg(MarginRightArgKey, "5.0")
+	top, bottom, left, right, err = MarginArgs(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, top)
+	assert.Equal(t, expected, bottom)
+	assert.Equal(t, expected, left)
+	assert.Equal(t, expected, right)
+	// should not be OK as arguments
+	// value are < 0.
+	expected = opts.MarginTop
+	r.WithArg(MarginTopArgKey, "-1.0")
+	top, _, _, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, top)
+	r.WithArg(MarginTopArgKey, "5.0")
+	expected = opts.MarginBottom
+	r.WithArg(MarginBottomArgKey, "-1.0")
+	_, bottom, _, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, bottom)
+	r.WithArg(MarginBottomArgKey, "5.0")
+	expected = opts.MarginLeft
+	r.WithArg(MarginLeftArgKey, "-1.0")
+	_, _, left, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, left)
+	r.WithArg(MarginLeftArgKey, "5.0")
+	expected = opts.MarginRight
+	r.WithArg(MarginRightArgKey, "-1.0")
+	_, _, _, right, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, right)
+	r.WithArg(MarginRightArgKey, "5.0")
+	// should not be OK as
+	// arguments value are invalids.
+	expected = opts.MarginTop
+	r.WithArg(MarginTopArgKey, "foo")
+	top, _, _, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, top)
+	r.WithArg(MarginTopArgKey, "5.0")
+	expected = opts.MarginBottom
+	r.WithArg(MarginBottomArgKey, "foo")
+	_, bottom, _, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, bottom)
+	r.WithArg(MarginBottomArgKey, "5.0")
+	expected = opts.MarginLeft
+	r.WithArg(MarginLeftArgKey, "foo")
+	_, _, left, _, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, left)
+	r.WithArg(MarginLeftArgKey, "5.0")
+	expected = opts.MarginRight
+	r.WithArg(MarginRightArgKey, "foo")
+	_, _, _, right, err = MarginArgs(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, right)
+	r.WithArg(MarginRightArgKey, "5.0")
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestGoogleChromeRpccBufferSizeArg(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected int64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// argument does not exist.
+	expected = config.DefaultGoogleChromeRpccBufferSize()
+	v, err := GoogleChromeRpccBufferSizeArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// argument exist.
+	expected = 10
+	r.WithArg(GoogleChromeRpccBufferSizeArgKey, "10")
+	v, err = GoogleChromeRpccBufferSizeArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is < 0.
+	expected = config.DefaultGoogleChromeRpccBufferSize()
+	r.WithArg(GoogleChromeRpccBufferSizeArgKey, "-1")
+	v, err = GoogleChromeRpccBufferSizeArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is > config.MaximumGoogleChromeRpccBufferSize().
+	expected = config.DefaultGoogleChromeRpccBufferSize()
+	r.WithArg(GoogleChromeRpccBufferSizeArgKey, "104857601")
+	v, err = GoogleChromeRpccBufferSizeArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as
+	// argument value is invalid.
+	expected = config.DefaultGoogleChromeRpccBufferSize()
+	r.WithArg(GoogleChromeRpccBufferSizeArgKey, "foo")
+	v, err = GoogleChromeRpccBufferSizeArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestScaleArg(t *testing.T) {
+	const (
+		resourceDirectoryName string  = "foo"
+		defaultValue          float64 = 1.0
+	)
+	var expected float64
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// argument does not exist.
+	expected = defaultValue
+	v, err := ScaleArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// argument exist.
+	expected = 0.5
+	r.WithArg(ScaleArgKey, "0.5")
+	v, err = ScaleArg(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is < 0.1.
+	expected = defaultValue
+	r.WithArg(ScaleArgKey, "-1.0")
+	v, err = ScaleArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as argument
+	// value is > 2.0.
+	expected = defaultValue
+	r.WithArg(ScaleArgKey, "2.1")
+	v, err = ScaleArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as
+	// argument value is invalid.
+	expected = defaultValue
+	r.WithArg(ScaleArgKey, "foo")
+	v, err = ScaleArg(r, config)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}

internal/app/xhttp/pkg/resource/doc.go

@@ -0,0 +1,8 @@
+/*
+Package resource helps managing
+arguments and files for a conversion.
+
+All functions return our standard xerror.Error
+in case of error.
+*/
+package resource

internal/app/xhttp/pkg/resource/file.go

@@ -0,0 +1,91 @@
+package resource
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+)
+
+// file represents a file within the resource.
+type file struct {
+	fpath string
+}
+
+// write writes given content to the
+// resourceFile location.
+func (f file) write(in io.Reader) error {
+	const op string = "resource.file.write"
+	resolver := func() error {
+		out, err := os.Create(f.fpath)
+		if err != nil {
+			return err
+		}
+		defer out.Close()
+		if err := out.Chmod(0600); err != nil {
+			return err
+		}
+		if _, err := io.Copy(out, in); err != nil {
+			return err
+		}
+		if _, err := out.Seek(0, 0); err != nil {
+			return err
+		}
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// content returns the string content of
+// the file.
+func (f file) content() (string, error) {
+	const op string = "resource.file.content"
+	b, err := ioutil.ReadFile(f.fpath)
+	if err != nil {
+		return "", xerror.New(op, err)
+	}
+	return string(b), nil
+}
+
+/*
+HeaderFooterContents is a helper for retrieving
+the content of the files "header.html"
+and "footer.html".
+*/
+func HeaderFooterContents(r Resource, config conf.Config) (string, string, error) {
+	const op string = "resource.HeaderFooterContents"
+	opts := printer.DefaultChromePrinterOptions(config)
+	resolver := func() (string, string, error) {
+		headerHTML, err := r.Fcontent("header.html", opts.HeaderHTML)
+		if err != nil {
+			return opts.HeaderHTML,
+				opts.FooterHTML,
+				err
+		}
+		footerHTML, err := r.Fcontent("footer.html", opts.FooterHTML)
+		if err != nil {
+			return opts.HeaderHTML,
+				opts.FooterHTML,
+				err
+		}
+		return headerHTML,
+			footerHTML,
+			nil
+	}
+	headerHTML, footerHTML,
+		err := resolver()
+	if err != nil {
+		return headerHTML,
+			footerHTML,
+			xerror.New(op, err)
+	}
+	return headerHTML,
+		footerHTML,
+		nil
+}

internal/app/xhttp/pkg/resource/file_test.go

@@ -0,0 +1,46 @@
+package resource
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/printer"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestHeaderFooterContents(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	var expected string
+	logger := test.DebugLogger()
+	config := conf.DefaultConfig()
+	opts := printer.DefaultChromePrinterOptions(config)
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// arguments do not exist.
+	header, footer, err := HeaderFooterContents(r, config)
+	assert.Nil(t, err)
+	assert.Equal(t, opts.HeaderHTML, header)
+	assert.Equal(t, opts.FooterHTML, footer)
+	// arguments exist.
+	expected = "Gutenberg"
+	fpath := test.OfficeFpaths(t)[2]
+	f1, err := os.Open(fpath)
+	assert.Nil(t, err)
+	defer f1.Close() // nolint: errcheck
+	err = r.WithFile("header.html", f1)
+	assert.Nil(t, err)
+	f2, err := os.Open(fpath)
+	assert.Nil(t, err)
+	defer f2.Close() // nolint: errcheck
+	err = r.WithFile("footer.html", f2)
+	assert.Nil(t, err)
+	header, footer, err = HeaderFooterContents(r, config)
+	assert.Nil(t, err)
+	assert.Contains(t, header, expected)
+	assert.Contains(t, footer, expected)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}

internal/app/xhttp/pkg/resource/header.go

@@ -0,0 +1,37 @@
+package resource
+
+import (
+	"strings"
+)
+
+const (
+	// RemoteURLCustomHTTPHeaderCanonicalBaseKey is the base key
+	// of custom headers send to the remote URL.
+	RemoteURLCustomHTTPHeaderCanonicalBaseKey string = "Gotenberg-Remoteurl-"
+	// WebhookURLCustomHTTPHeaderCanonicalBaseKey is the base key
+	// of custom headers send to the webhook URL.
+	WebhookURLCustomHTTPHeaderCanonicalBaseKey string = "Gotenberg-Webhookurl-"
+)
+
+func fetchCustomHTTPHeaders(r Resource, baseKey string) map[string]string {
+	customHeaders := make(map[string]string)
+	for key, value := range r.customHeaders {
+		if strings.Contains(key, baseKey) {
+			realKey := strings.Replace(key, baseKey, "", 1)
+			customHeaders[realKey] = value
+		}
+	}
+	return customHeaders
+}
+
+// RemoteURLCustomHTTPHeaders is a helper for retrieving
+// the custom headers for the URL conversion.
+func RemoteURLCustomHTTPHeaders(r Resource) map[string]string {
+	return fetchCustomHTTPHeaders(r, RemoteURLCustomHTTPHeaderCanonicalBaseKey)
+}
+
+// WebhookURLCustomHTTPHeaders is a helper for retrieving
+// the custom headers for the webhook URL.
+func WebhookURLCustomHTTPHeaders(r Resource) map[string]string {
+	return fetchCustomHTTPHeaders(r, WebhookURLCustomHTTPHeaderCanonicalBaseKey)
+}

internal/app/xhttp/pkg/resource/header_test.go

@@ -0,0 +1,54 @@
+package resource
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestRemoteURLCustomHeaders(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// should find the custom header.
+	customHeaderValue := "bar"
+	customHeaderCanonicalRealKey := "Foo"
+	customHeaderCanonicalKey := http.CanonicalHeaderKey(fmt.Sprintf("%s%s", RemoteURLCustomHTTPHeaderCanonicalBaseKey, customHeaderCanonicalRealKey))
+	r.WithCustomHTTPHeader(customHeaderCanonicalKey, customHeaderValue)
+	r.WithCustomHTTPHeader("Bar", "Bar")
+	expected := map[string]string{
+		customHeaderCanonicalRealKey: customHeaderValue,
+	}
+	notExpected := map[string]string{
+		customHeaderCanonicalKey: customHeaderValue,
+	}
+	v := RemoteURLCustomHTTPHeaders(r)
+	assert.Equal(t, expected, v)
+	assert.NotEqual(t, notExpected, v)
+}
+
+func TestWebhookURLCustomHeaders(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// should find the custom header.
+	customHeaderValue := "bar"
+	customHeaderCanonicalRealKey := "Foo"
+	customHeaderCanonicalKey := http.CanonicalHeaderKey(fmt.Sprintf("%s%s", WebhookURLCustomHTTPHeaderCanonicalBaseKey, customHeaderCanonicalRealKey))
+	r.WithCustomHTTPHeader(customHeaderCanonicalKey, customHeaderValue)
+	r.WithCustomHTTPHeader("Bar", "Bar")
+	expected := map[string]string{
+		customHeaderCanonicalRealKey: customHeaderValue,
+	}
+	notExpected := map[string]string{
+		customHeaderCanonicalKey: customHeaderValue,
+	}
+	v := WebhookURLCustomHTTPHeaders(r)
+	assert.Equal(t, expected, v)
+	assert.NotEqual(t, notExpected, v)
+}

internal/app/xhttp/pkg/resource/resource.go

@@ -0,0 +1,258 @@
+package resource
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/normalize"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xassert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
+/*
+TemporaryDirectory is the directory
+where all the resources directory
+are located.
+*/
+const TemporaryDirectory string = "tmp"
+
+// Resource helps managing
+// arguments and files for a conversion.
+type Resource struct {
+	logger        xlog.Logger
+	dirPath       string
+	customHeaders map[string]string
+	args          map[ArgKey]string
+	files         map[string]file
+}
+
+// New creates a Resource where its files will
+// be located in the given directory name.
+func New(logger xlog.Logger, directoryName string) (Resource, error) {
+	const op string = "resource.New"
+	resolver := func() (string, error) {
+		dirPath := fmt.Sprintf("%s/%s", TemporaryDirectory, directoryName)
+		if err := os.MkdirAll(dirPath, 0755); err != nil {
+			return "", err
+		}
+		absDirPath, err := filepath.Abs(dirPath)
+		if err != nil {
+			return "", err
+		}
+		return absDirPath, nil
+	}
+	dirPath, err := resolver()
+	if err != nil {
+		return Resource{}, xerror.New(op, err)
+	}
+	logger.DebugOpf(op, "resource directory '%s' created", directoryName)
+	return Resource{
+		logger:        logger,
+		dirPath:       dirPath,
+		customHeaders: make(map[string]string),
+		args:          make(map[ArgKey]string),
+		files:         make(map[string]file),
+	}, nil
+}
+
+// Close removes the working directory of the
+// Resource if it exists.
+func (r Resource) Close() error {
+	const op string = "resource.Resource.Close"
+	if _, err := os.Stat(r.dirPath); os.IsNotExist(err) {
+		r.logger.DebugOpf(op, "resource directory '%s' does not exist, nothing to remove", r.dirPath)
+		return nil
+	}
+	if err := os.RemoveAll(r.dirPath); err != nil {
+		return xerror.New(op, err)
+	}
+	r.logger.DebugOpf(op, "resource directory '%s' removed", r.dirPath)
+	return nil
+}
+
+// WithCustomHTTPHeader add a new custom header to the Resource.
+// Given key should be in canonical format.
+func (r *Resource) WithCustomHTTPHeader(key string, value string) {
+	const op string = "resource.Resource.WithCustomHTTPHeader"
+	// should already be in canonical format.
+	canonicalKey := http.CanonicalHeaderKey(key)
+	if strings.Contains(canonicalKey, RemoteURLCustomHTTPHeaderCanonicalBaseKey) ||
+		strings.Contains(canonicalKey, WebhookURLCustomHTTPHeaderCanonicalBaseKey) {
+		r.customHeaders[canonicalKey] = value
+		r.logger.DebugOpf(op, "added '%s' with value '%s' to resource custom HTTP headers", canonicalKey, value)
+		return
+	}
+	r.logger.DebugOpf(op, "skipping '%s' as it is not a custom HTTP header...", canonicalKey)
+}
+
+// WithArg add a new argument to the Resource.
+func (r *Resource) WithArg(key ArgKey, value string) {
+	const op string = "resource.Resource.WithArg"
+	r.args[key] = value
+	r.logger.DebugOpf(op, "added '%s' with value '%s' to resource args", key, value)
+}
+
+// WithFile add a new file to the Resource.
+func (r *Resource) WithFile(filename string, in io.Reader) error {
+	const op string = "resource.Resource.WithFile"
+	resolver := func() error {
+		// see https://github.com/thecodingmachine/gotenberg/issues/104.
+		normalized, err := normalize.String(filename)
+		if err != nil {
+			return err
+		}
+		fpath := fmt.Sprintf("%s/%s", r.dirPath, normalized)
+		file := file{fpath: fpath}
+		if err := file.write(in); err != nil {
+			return err
+		}
+		r.files[filename] = file
+		r.logger.DebugOpf(op, "resource file '%s' created", filename)
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// DirPath returns the directory path
+// of the Resource.
+func (r Resource) DirPath() string {
+	return r.dirPath
+}
+
+// HasArg returns true if given key exists
+// among the Resource and its value is not empty.
+func (r Resource) HasArg(key ArgKey) bool {
+	if v, ok := r.args[key]; ok {
+		return v != ""
+	}
+	return false
+}
+
+/*
+StringArg returns the value of the
+argument identified by given key.
+
+It works in the same manner as xassert.String.
+*/
+func (r Resource) StringArg(key ArgKey, defaultValue string, rules ...xassert.RuleString) (string, error) {
+	const op string = "resource.Resource.StringArg"
+	result, err := xassert.String(string(key), r.args[key], defaultValue, rules...)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+Int64Arg returns the int64 representation of the
+argument identified by given key.
+
+It works in the same manner as xassert.Int64.
+*/
+func (r Resource) Int64Arg(key ArgKey, defaultValue int64, rules ...xassert.RuleInt64) (int64, error) {
+	const op string = "resource.Resource.Int64Arg"
+	result, err := xassert.Int64(string(key), r.args[key], defaultValue, rules...)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+Float64Arg returns the float64 representation of the
+argument identified by given key.
+
+It works in the same manner as xassert.Float64.
+*/
+func (r Resource) Float64Arg(key ArgKey, defaultValue float64, rules ...xassert.RuleFloat64) (float64, error) {
+	const op string = "resource.Resource.Float64Arg"
+	result, err := xassert.Float64(string(key), r.args[key], defaultValue, rules...)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+/*
+BoolArg returns the boolean representation of the
+argument identified by given key.
+
+It works in the same manner as xassert.Bool.
+*/
+func (r Resource) BoolArg(key ArgKey, defaultValue bool) (bool, error) {
+	const op string = "resource.Resource.BoolArg"
+	result, err := xassert.Bool(string(key), r.args[key], defaultValue)
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+// Fpath returns the path of the given filename.
+// This filename should exist whithin the Resource.
+func (r Resource) Fpath(filename string) (string, error) {
+	const op string = "resource.Resource.Fpath"
+	file, ok := r.files[filename]
+	if !ok {
+		return "", xerror.Invalid(
+			op,
+			fmt.Sprintf("resource file '%s' does not exist", filename),
+			nil,
+		)
+	}
+	return file.fpath, nil
+}
+
+/*
+Fpaths returns the paths of the files
+having one of the given file extensions.
+
+It should found at least one path.
+*/
+func (r Resource) Fpaths(exts ...string) ([]string, error) {
+	const op string = "resource.Resource.Fpaths"
+	var fpaths []string
+	for filename, file := range r.files {
+		for _, ext := range exts {
+			if filepath.Ext(filename) == ext {
+				fpaths = append(fpaths, file.fpath)
+			}
+		}
+	}
+	if len(fpaths) == 0 {
+		return nil, xerror.Invalid(
+			op,
+			fmt.Sprintf("no resource file found for extensions '%v'", exts),
+			nil,
+		)
+	}
+	return fpaths, nil
+}
+
+/*
+Fcontent returns the string content of the
+given filename.
+
+If filename does not exist within the Resource,
+returns the default value.
+*/
+func (r Resource) Fcontent(filename, defaultValue string) (string, error) {
+	const op string = "resource.Resource.Fcontent"
+	file, ok := r.files[filename]
+	if !ok {
+		return defaultValue, nil
+	}
+	content, err := file.content()
+	if err != nil {
+		return "", xerror.New(op, err)
+	}
+	return content, nil
+}

internal/app/xhttp/pkg/resource/resource_test.go

@@ -0,0 +1,287 @@
+package resource
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xassert"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestStringArg(t *testing.T) {
+	const (
+		resourceDirectoryName string = "foo"
+		defaultValue          string = "FOO"
+	)
+	var expected string
+	rule := xassert.StringOneOf([]string{"FOO", "BAR"})
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// empty value, result should be equal
+	// to the default value.
+	r.WithArg(ResultFilenameArgKey, "")
+	v, err := r.StringArg(ResultFilenameArgKey, defaultValue)
+	assert.Nil(t, err)
+	assert.Equal(t, defaultValue, v)
+	// result should be equal to given value
+	// as it is one of "FOO" and "BAR".
+	expected = "BAR"
+	r.WithArg(ResultFilenameArgKey, expected)
+	v, err = r.StringArg(ResultFilenameArgKey, defaultValue, rule)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as given value is not
+	// one of "FOO" and "BAR".
+	expected = defaultValue
+	r.WithArg(ResultFilenameArgKey, "BAZ")
+	v, err = r.StringArg(ResultFilenameArgKey, defaultValue, rule)
+	test.AssertError(t, err)
+	assert.Equal(t, expected, v)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestInt64Arg(t *testing.T) {
+	const (
+		resourceDirectoryName string = "foo"
+		defaultValue          int64  = 10
+	)
+	var expected int64
+	rule := xassert.Int64NotInferiorTo(6)
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// empty value, result should be equal
+	// to the default value.
+	r.WithArg(WaitTimeoutArgKey, "")
+	v, err := r.Int64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// result should be equal to given value
+	// but as integer.
+	r.WithArg(WaitTimeoutArgKey, "5")
+	v, err = r.Int64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = 5
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// should not be OK as given value is not
+	// a string representation of an integer.
+	r.WithArg(WaitTimeoutArgKey, "foo")
+	v, err = r.Int64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	test.AssertError(t, err)
+	// should not be OK as given value does not
+	// validate the rule x >= 6.
+	r.WithArg(WaitTimeoutArgKey, "5")
+	v, err = r.Int64Arg(WaitTimeoutArgKey, defaultValue, rule)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	test.AssertError(t, err)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestFloat64Arg(t *testing.T) {
+	const (
+		resourceDirectoryName string  = "foo"
+		defaultValue          float64 = 10.0
+	)
+	var expected float64
+	rule := xassert.Float64NotInferiorTo(6.0)
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// empty value, result should be equal
+	// to the default value.
+	r.WithArg(WaitTimeoutArgKey, "")
+	v, err := r.Float64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// result should be equal to given value
+	// but as float.
+	r.WithArg(WaitTimeoutArgKey, "5.5")
+	v, err = r.Float64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = 5.5
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// should not be OK as given value is not
+	// a string representation of a float.
+	r.WithArg(WaitTimeoutArgKey, "foo")
+	v, err = r.Float64Arg(WaitTimeoutArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	test.AssertError(t, err)
+	// should not be OK as given value does not
+	// validate the rule x >= 6.
+	r.WithArg(WaitTimeoutArgKey, "5.0")
+	v, err = r.Float64Arg(WaitTimeoutArgKey, defaultValue, rule)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	test.AssertError(t, err)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestBoolArg(t *testing.T) {
+	const (
+		resourceDirectoryName string = "foo"
+		defaultValue          bool   = true
+	)
+	var expected bool
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// empty value, result should be equal
+	// to the default value.
+	r.WithArg(LandscapeArgKey, "")
+	v, err := r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// result should be equal to given value
+	// but as boolean.
+	r.WithArg(LandscapeArgKey, "1")
+	v, err = r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = true
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	r.WithArg(LandscapeArgKey, "true")
+	v, err = r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = true
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	r.WithArg(LandscapeArgKey, "0")
+	v, err = r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = false
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	r.WithArg(LandscapeArgKey, "false")
+	v, err = r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = false
+	assert.Equal(t, expected, v)
+	assert.Nil(t, err)
+	// should not be OK as given value is not
+	// a string representation of a boolean.
+	r.WithArg(LandscapeArgKey, "foo")
+	v, err = r.BoolArg(LandscapeArgKey, defaultValue)
+	expected = defaultValue
+	assert.Equal(t, expected, v)
+	test.AssertError(t, err)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestFpath(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// file exists.
+	fpath := test.MergeFpaths(t)[0]
+	f, err := os.Open(fpath)
+	assert.Nil(t, err)
+	filename := "foo.pdf"
+	err = r.WithFile(filename, f)
+	assert.Nil(t, err)
+	absDirPath, err := filepath.Abs(fmt.Sprintf("%s/%s", TemporaryDirectory, resourceDirectoryName))
+	assert.Nil(t, err)
+	expected := fmt.Sprintf("%s/%s", absDirPath, filename)
+	v, err := r.Fpath(filename)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+	// should not be OK as file does
+	// not exist.
+	_, err = r.Fpath("bar.pdf")
+	test.AssertError(t, err)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestFpaths(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	fpath := test.MergeFpaths(t)[0]
+	f, err := os.Open(fpath)
+	assert.Nil(t, err)
+	defer f.Close() // nolint: errcheck
+	filename := "foo.pdf"
+	err = r.WithFile(filename, f)
+	assert.Nil(t, err)
+	// file extension exists.
+	absDirPath, err := filepath.Abs(fmt.Sprintf("%s/%s", TemporaryDirectory, resourceDirectoryName))
+	assert.Nil(t, err)
+	expected := []string{
+		fmt.Sprintf("%s/%s", absDirPath, filename),
+	}
+	fpaths, err := r.Fpaths(".pdf")
+	assert.Nil(t, err)
+	assert.Equal(t, expected, fpaths)
+	// should not be OK as file extension
+	// does not exist.
+	_, err = r.Fpaths(".html")
+	test.AssertError(t, err)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestFcontent(t *testing.T) {
+	const (
+		resourceDirectoryName string = "foo"
+		defaultValue          string = "Gutenberg"
+	)
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	filename := "foo.txt"
+	// file does not exist, expecting
+	// value.
+	v, err := r.Fcontent(filename, defaultValue)
+	assert.Nil(t, err)
+	assert.Equal(t, defaultValue, v)
+	// file exists.
+	fpath := test.OfficeFpaths(t)[2]
+	f, err := os.Open(fpath)
+	assert.Nil(t, err)
+	defer f.Close() // nolint: errcheck
+	err = r.WithFile(filename, f)
+	assert.Nil(t, err)
+	v, err = r.Fcontent(filename, defaultValue)
+	assert.Nil(t, err)
+	assert.Contains(t, v, defaultValue)
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}
+
+func TestGetters(t *testing.T) {
+	const resourceDirectoryName string = "foo"
+	logger := test.DebugLogger()
+	r, err := New(logger, resourceDirectoryName)
+	assert.Nil(t, err)
+	// has arg.
+	assert.Equal(t, false, r.HasArg(LandscapeArgKey))
+	r.WithArg(LandscapeArgKey, "foo")
+	assert.Equal(t, true, r.HasArg(LandscapeArgKey))
+	// directory path.
+	absDirPath, err := filepath.Abs(fmt.Sprintf("%s/%s", TemporaryDirectory, resourceDirectoryName))
+	assert.Nil(t, err)
+	assert.Equal(t, absDirPath, r.DirPath())
+	// finally...
+	err = r.Close()
+	assert.Nil(t, err)
+}

internal/app/xhttp/xhttp.go

@@ -0,0 +1,31 @@
+package xhttp
+
+import (
+	"github.com/labstack/echo/v4"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+)
+
+// New returns a custom echo.Echo.
+func New(config conf.Config) *echo.Echo {
+	srv := echo.New()
+	srv.HideBanner = true
+	srv.HidePort = true
+	srv.Use(contextMiddleware(config))
+	srv.Use(loggerMiddleware(config))
+	srv.Use(cleanupMiddleware())
+	srv.Use(errorMiddleware())
+	srv.GET(pingEndpoint(config), pingHandler)
+	srv.POST(mergeEndpoint(config), mergeHandler)
+	if config.DisableGoogleChrome() && config.DisableUnoconv() {
+		return srv
+	}
+	if !config.DisableGoogleChrome() {
+		srv.POST(htmlEndpoint(config), htmlHandler)
+		srv.POST(urlEndpoint(config), urlHandler)
+		srv.POST(markdownEndpoint(config), markdownHandler)
+	}
+	if !config.DisableUnoconv() {
+		srv.POST(officeEndpoint(config), officeHandler)
+	}
+	return srv
+}

internal/app/xhttp/xhttp_test.go

@@ -0,0 +1,171 @@
+package xhttp
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestNonExistingEndpoint(t *testing.T) {
+	config, err := conf.FromEnv()
+	assert.Nil(t, err)
+	srv := New(config)
+	// "/" endpoint should return 404.
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+}
+
+func TestDisableChromeEndpoints(t *testing.T) {
+	os.Setenv(conf.DisableGoogleChromeEnvVar, "1")
+	config, err := conf.FromEnv()
+	assert.Nil(t, err)
+	srv := New(config)
+	// Ping endpoint should return 200.
+	req := httptest.NewRequest(http.MethodGet, pingEndpoint(config), nil)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Merge endpoint should return 200.
+	body, contentType := test.MergeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// HTML endpoint should return 404.
+	body, contentType = test.HTMLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, htmlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// URL endpoint should return 404.
+	body, contentType = test.URLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, urlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// Markdown endpoint should return 404.
+	body, contentType = test.MarkdownMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, markdownEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// Office endpoint should return 200.
+	body, contentType = test.OfficeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, officeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// finally...
+	os.Setenv(conf.DisableGoogleChromeEnvVar, "0")
+}
+
+func TestDisableUnoconvEndpoints(t *testing.T) {
+	os.Setenv(conf.DisableUnoconvEnvVar, "1")
+	config, err := conf.FromEnv()
+	assert.Nil(t, err)
+	srv := New(config)
+	// Ping endpoint should return 200.
+	req := httptest.NewRequest(http.MethodGet, pingEndpoint(config), nil)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Merge endpoint should return 200.
+	body, contentType := test.MergeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// HTML endpoint should return 200.
+	body, contentType = test.HTMLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, htmlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// URL endpoint should return 200.
+	body, contentType = test.URLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, urlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Markdown endpoint should return 200.
+	body, contentType = test.MarkdownMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, markdownEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Office endpoint should return 404.
+	body, contentType = test.OfficeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, officeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// finally...
+	os.Setenv(conf.DisableUnoconvEnvVar, "0")
+}
+func TestDisableChromeAndUnoconvEndpoints(t *testing.T) {
+	os.Setenv(conf.DisableGoogleChromeEnvVar, "1")
+	os.Setenv(conf.DisableUnoconvEnvVar, "1")
+	config, err := conf.FromEnv()
+	assert.Nil(t, err)
+	srv := New(config)
+	// Ping endpoint should return 200.
+	req := httptest.NewRequest(http.MethodGet, pingEndpoint(config), nil)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Merge endpoint should return 200.
+	body, contentType := test.MergeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// HTML endpoint should return 404.
+	body, contentType = test.HTMLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, htmlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// URL endpoint should return 404.
+	body, contentType = test.URLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, urlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// Markdown endpoint should return 404.
+	body, contentType = test.MarkdownMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, markdownEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// Office endpoint should return 404.
+	body, contentType = test.OfficeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, officeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusNotFound, srv, req)
+	// finally...
+	os.Setenv(conf.DisableGoogleChromeEnvVar, "0")
+	os.Setenv(conf.DisableUnoconvEnvVar, "0")
+}
+
+func TestCustomRootPath(t *testing.T) {
+	os.Setenv(conf.RootPathEnvVar, "/foo/")
+	config, err := conf.FromEnv()
+	assert.Nil(t, err)
+	srv := New(config)
+	// Ping endpoint should return 200.
+	req := httptest.NewRequest(http.MethodGet, pingEndpoint(config), nil)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Merge endpoint should return 200.
+	body, contentType := test.MergeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, mergeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// HTML endpoint should return 200.
+	body, contentType = test.HTMLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, htmlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// URL endpoint should return 200.
+	body, contentType = test.URLMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, urlEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Markdown endpoint should return 200.
+	body, contentType = test.MarkdownMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, markdownEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// Office endpoint should return 200.
+	body, contentType = test.OfficeMultipartForm(t, nil)
+	req = httptest.NewRequest(http.MethodPost, officeEndpoint(config), body)
+	req.Header.Set(echo.HeaderContentType, contentType)
+	test.AssertStatusCode(t, http.StatusOK, srv, req)
+	// finally...
+	os.Setenv(conf.RootPathEnvVar, "/")
+}

internal/pkg/chrome/chrome.go

@@ -0,0 +1,186 @@
+package chrome
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/mafredri/cdp/devtool"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xexec"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xtime"
+)
+
+// Start starts Google Chrome headless in background.
+func Start(logger xlog.Logger, ignoreCertificateErrors bool) error {
+	const op string = "chrome.Start"
+	logger.DebugOp(op, "starting new Google Chrome headless process on port 9222...")
+	resolver := func() error {
+		cmd, err := cmd(logger, ignoreCertificateErrors)
+		if err != nil {
+			return err
+		}
+		// we try to start the process.
+		xexec.LogBeforeExecute(logger, cmd)
+		if err := cmd.Start(); err != nil {
+			return err
+		}
+		// if the process failed to start correctly,
+		// we have to restart it.
+		isViable, _ := IsViable(logger)
+		if !isViable {
+			return restart(logger, cmd.Process, ignoreCertificateErrors)
+		}
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func cmd(logger xlog.Logger, ignoreCertificateErrors bool) (*exec.Cmd, error) {
+	const op string = "chrome.cmd"
+	binary := "google-chrome-stable"
+	args := []string{
+		"--no-sandbox",
+		"--headless",
+		// see https://github.com/thecodingmachine/gotenberg/issues/157.
+		"--disable-dev-shm-usage",
+		// See https://github.com/puppeteer/puppeteer/issues/661
+		// and https://github.com/puppeteer/puppeteer/issues/2410.
+		"--font-render-hinting=none",
+		"--remote-debugging-port=9222",
+		"--disable-gpu",
+		"--disable-translate",
+		"--disable-extensions",
+		"--disable-background-networking",
+		"--safebrowsing-disable-auto-update",
+		"--disable-sync",
+		"--disable-default-apps",
+		"--hide-scrollbars",
+		"--metrics-recording-only",
+		"--mute-audio",
+		"--no-first-run",
+	}
+
+	if ignoreCertificateErrors {
+		args = append(args, "--ignore-certificate-errors")
+	}
+
+	cmd, err := xexec.Command(logger, binary, args...)
+	if err != nil {
+		return nil, xerror.New(op, err)
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	return cmd, nil
+}
+
+func kill(logger xlog.Logger, proc *os.Process) error {
+	const op string = "chrome.kill"
+	logger.DebugOp(op, "killing Google Chrome headless process using port 9222...")
+	resolver := func() error {
+		err := syscall.Kill(-proc.Pid, syscall.SIGKILL)
+		if err == nil {
+			return nil
+		}
+		if strings.Contains(err.Error(), "no such process") {
+			return nil
+		}
+		return err
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func restart(logger xlog.Logger, proc *os.Process, ignoreCertificateErrors bool) error {
+	const op string = "chrome.restart"
+	logger.DebugOp(op, "restarting Google Chrome headless process using port 9222...")
+	resolver := func() error {
+		// kill the existing process first.
+		if err := kill(logger, proc); err != nil {
+			return err
+		}
+		cmd, err := cmd(logger, ignoreCertificateErrors)
+		if err != nil {
+			return err
+		}
+		// we try to restart the process.
+		xexec.LogBeforeExecute(logger, cmd)
+		if err := cmd.Start(); err != nil {
+			return err
+		}
+		// if the process failed to restart correctly,
+		// we have to restart it again.
+		isViable, _ := IsViable(logger)
+		if !isViable {
+			return restart(logger, cmd.Process, ignoreCertificateErrors)
+		}
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+// IsViable checks if Google Chrome is healthy.
+func IsViable(logger xlog.Logger) (bool, error) {
+	const (
+		op                string = "chrome.IsViable"
+		maxViabilityTests int    = 20
+	)
+	viable := func() (bool, error) {
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		endpoint := "http://localhost:9222"
+		logger.DebugOpf(
+			op,
+			"checking Google Chrome headless process viability via endpoint '%s/json/version'",
+			endpoint,
+		)
+		v, err := devtool.New(endpoint).Version(ctx)
+		if err != nil {
+			logger.DebugOpf(
+				op,
+				"Google Chrome headless is not viable as endpoint returned '%v'",
+				err.Error(),
+			)
+			return false, err
+		}
+		logger.DebugOpf(
+			op,
+			"Google Chrome headless is viable as endpoint returned '%v'",
+			v,
+		)
+		return true, nil
+	}
+	result := false
+	var err error
+
+	for i := 0; i < maxViabilityTests && !result; i++ {
+		warmup(logger)
+		result, err = viable()
+	}
+	return result, err
+}
+
+func warmup(logger xlog.Logger) {
+	const (
+		op      string  = "chrome.warmup"
+		seconds float64 = 0.5
+	)
+	warmupTime := xtime.Duration(seconds)
+	logger.DebugOpf(
+		op,
+		"waiting '%v' for allowing Google Chrome to warmup",
+		warmupTime,
+	)
+	time.Sleep(warmupTime)
+}

internal/pkg/chrome/doc.go

@@ -0,0 +1,3 @@
+// Package chrome helps starting
+// Google Chrome headless in background.
+package chrome

internal/pkg/conf/conf.go

@@ -0,0 +1,293 @@
+package conf
+
+import (
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xassert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
+const (
+	// MaximumWaitTimeoutEnvVar contains the name
+	// of the environment variable "MAXIMUM_WAIT_TIMEOUT".
+	MaximumWaitTimeoutEnvVar string = "MAXIMUM_WAIT_TIMEOUT"
+	// MaximumWaitDelayEnvVar contains the name
+	// of the environment variable "MAXIMUM_WAIT_DELAY".
+	MaximumWaitDelayEnvVar string = "MAXIMUM_WAIT_DELAY"
+	// MaximumWebhookURLTimeoutEnvVar contains the name
+	// of the environment variable "MAXIMUM_WEBHOOK_URL_TIMEOUT".
+	MaximumWebhookURLTimeoutEnvVar string = "MAXIMUM_WEBHOOK_URL_TIMEOUT"
+	// DefaultWaitTimeoutEnvVar contains the name
+	// of the environment variable "DEFAULT_WAIT_TIMEOUT".
+	DefaultWaitTimeoutEnvVar string = "DEFAULT_WAIT_TIMEOUT"
+	// DefaultWebhookURLTimeoutEnvVar contains the name
+	// of the environment variable "DEFAULT_WEBHOOK_URL_TIMEOUT".
+	DefaultWebhookURLTimeoutEnvVar string = "DEFAULT_WEBHOOK_URL_TIMEOUT"
+	// DefaultListenPortEnvVar contains the name
+	// of the environment variable "DEFAULT_LISTEN_PORT".
+	DefaultListenPortEnvVar string = "DEFAULT_LISTEN_PORT"
+	// DisableGoogleChromeEnvVar contains the name
+	// of the environment variable "DISABLE_GOOGLE_CHROME".
+	DisableGoogleChromeEnvVar string = "DISABLE_GOOGLE_CHROME"
+	// DisableUnoconvEnvVar contains the name
+	// of the environment variable "DISABLE_UNOCONV".
+	DisableUnoconvEnvVar string = "DISABLE_UNOCONV"
+	// LogLevelEnvVar contains the name
+	// of the environment variable "LOG_LEVEL".
+	LogLevelEnvVar string = "LOG_LEVEL"
+	// RootPathEnvVar contains the name
+	// of the environment variable "ROOT_PATH".
+	RootPathEnvVar string = "ROOT_PATH"
+	// DefaultGoogleChromeRpccBufferSizeEnvVar contains the name
+	// of the environment variable "DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE".
+	DefaultGoogleChromeRpccBufferSizeEnvVar string = "DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE"
+	// GoogleChromeIgnoreCertificateErrorsEnvVar contains the name
+	// of the environment variable "GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS".
+	GoogleChromeIgnoreCertificateErrorsEnvVar string = "GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS"
+)
+
+// Config contains the application
+// configuration.
+type Config struct {
+	maximumWaitTimeout                  float64
+	maximumWaitDelay                    float64
+	maximumWebhookURLTimeout            float64
+	defaultWaitTimeout                  float64
+	defaultWebhookURLTimeout            float64
+	defaultListenPort                   int64
+	disableGoogleChrome                 bool
+	disableUnoconv                      bool
+	googleChromeIgnoreCertificateErrors bool
+	logLevel                            xlog.Level
+	rootPath                            string
+	maximumGoogleChromeRpccBufferSize   int64
+	defaultGoogleChromeRpccBufferSize   int64
+}
+
+// DefaultConfig returns the default
+// configuration.
+func DefaultConfig() Config {
+	return Config{
+		maximumWaitTimeout:                  30.0,
+		maximumWaitDelay:                    10.0,
+		maximumWebhookURLTimeout:            30.0,
+		defaultWaitTimeout:                  10.0,
+		defaultWebhookURLTimeout:            10.0,
+		defaultListenPort:                   3000,
+		disableGoogleChrome:                 false,
+		disableUnoconv:                      false,
+		logLevel:                            xlog.InfoLevel,
+		rootPath:                            "/",
+		maximumGoogleChromeRpccBufferSize:   104857600, // ~100 MB
+		defaultGoogleChromeRpccBufferSize:   1048576,   // 1 MB
+		googleChromeIgnoreCertificateErrors: false,
+	}
+}
+
+/*
+FromEnv returns a Conf according
+to environment variables.
+*/
+func FromEnv() (Config, error) {
+	const op string = "conf.FromEnv"
+	resolver := func() (Config, error) {
+		c := DefaultConfig()
+		maximumWaitTimeout, err := xassert.Float64FromEnv(
+			MaximumWaitTimeoutEnvVar,
+			c.maximumWaitTimeout,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		c.maximumWaitTimeout = maximumWaitTimeout
+		if err != nil {
+			return c, err
+		}
+		maximumWaitDelay, err := xassert.Float64FromEnv(
+			MaximumWaitDelayEnvVar,
+			c.maximumWaitDelay,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		c.maximumWaitDelay = maximumWaitDelay
+		if err != nil {
+			return c, err
+		}
+		maximumWebhookURLTimeout, err := xassert.Float64FromEnv(
+			MaximumWebhookURLTimeoutEnvVar,
+			c.maximumWebhookURLTimeout,
+			xassert.Float64NotInferiorTo(0.0),
+		)
+		c.maximumWebhookURLTimeout = maximumWebhookURLTimeout
+		if err != nil {
+			return c, err
+		}
+		defaultWaitTimeout, err := xassert.Float64FromEnv(
+			DefaultWaitTimeoutEnvVar,
+			c.defaultWaitTimeout,
+			xassert.Float64NotInferiorTo(0.0),
+			xassert.Float64NotSuperiorTo(c.maximumWaitTimeout),
+		)
+		c.defaultWaitTimeout = defaultWaitTimeout
+		if err != nil {
+			return c, err
+		}
+		defaultWebhookURLTimeout, err := xassert.Float64FromEnv(
+			DefaultWebhookURLTimeoutEnvVar,
+			c.defaultWebhookURLTimeout,
+			xassert.Float64NotInferiorTo(0.0),
+			xassert.Float64NotSuperiorTo(c.defaultWebhookURLTimeout),
+		)
+		c.defaultWebhookURLTimeout = defaultWebhookURLTimeout
+		if err != nil {
+			return c, err
+		}
+		defaultListenPort, err := xassert.Int64FromEnv(
+			DefaultListenPortEnvVar,
+			c.defaultListenPort,
+			xassert.Int64NotInferiorTo(0),
+			xassert.Int64NotSuperiorTo(65535),
+		)
+		c.defaultListenPort = defaultListenPort
+		if err != nil {
+			return c, err
+		}
+		disableGoogleChrome, err := xassert.BoolFromEnv(
+			DisableGoogleChromeEnvVar,
+			c.disableGoogleChrome,
+		)
+		c.disableGoogleChrome = disableGoogleChrome
+		if err != nil {
+			return c, err
+		}
+		disableUnoconv, err := xassert.BoolFromEnv(
+			DisableUnoconvEnvVar,
+			c.disableUnoconv,
+		)
+		c.disableUnoconv = disableUnoconv
+		if err != nil {
+			return c, err
+		}
+		logLevel, err := xassert.StringFromEnv(
+			LogLevelEnvVar,
+			string(c.logLevel),
+			xassert.StringOneOf(xlog.Levels()),
+		)
+		c.logLevel = xlog.MustParseLevel(logLevel)
+		if err != nil {
+			return c, err
+		}
+		rootPath, err := xassert.StringFromEnv(
+			RootPathEnvVar,
+			c.rootPath,
+			xassert.StringStartWith("/"),
+			xassert.StringEndWith("/"),
+		)
+		c.rootPath = rootPath
+		if err != nil {
+			return c, err
+		}
+		defaultGoogleChromeRpccBufferSize, err := xassert.Int64FromEnv(
+			DefaultGoogleChromeRpccBufferSizeEnvVar,
+			c.defaultGoogleChromeRpccBufferSize,
+			xassert.Int64NotInferiorTo(0),
+			xassert.Int64NotSuperiorTo(c.MaximumGoogleChromeRpccBufferSize()),
+		)
+		c.defaultGoogleChromeRpccBufferSize = defaultGoogleChromeRpccBufferSize
+		if err != nil {
+			return c, err
+		}
+		googleChromeIgnoreCertificateErrors, err := xassert.BoolFromEnv(
+			GoogleChromeIgnoreCertificateErrorsEnvVar,
+			c.googleChromeIgnoreCertificateErrors,
+		)
+		c.googleChromeIgnoreCertificateErrors = googleChromeIgnoreCertificateErrors
+		if err != nil {
+			return c, err
+		}
+		return c, nil
+	}
+	result, err := resolver()
+	if err != nil {
+		return result, xerror.New(op, err)
+	}
+	return result, nil
+}
+
+// MaximumWaitTimeout returns the maximum
+// wait timeout from the configuration.
+func (c Config) MaximumWaitTimeout() float64 {
+	return c.maximumWaitTimeout
+}
+
+// MaximumWaitDelay returns the maximum
+// wait timeout from the configuration.
+func (c Config) MaximumWaitDelay() float64 {
+	return c.maximumWaitDelay
+}
+
+// MaximumWebhookURLTimeout returns the maximum
+// webhook URL wait timeout from the configuration.
+func (c Config) MaximumWebhookURLTimeout() float64 {
+	return c.maximumWebhookURLTimeout
+}
+
+// DefaultWaitTimeout returns the default
+// wait timeout from the configuration.
+func (c Config) DefaultWaitTimeout() float64 {
+	return c.defaultWaitTimeout
+}
+
+// DefaultWebhookURLTimeout returns the default
+// webhook URL wait timeout from the configuration.
+func (c Config) DefaultWebhookURLTimeout() float64 {
+	return c.defaultWebhookURLTimeout
+}
+
+// DefaultListenPort returns the default
+// listen port from the configuration.
+func (c Config) DefaultListenPort() int64 {
+	return c.defaultListenPort
+}
+
+/*
+DisableGoogleChrome returns true if
+Google Chrome is disabled in the
+configuration.
+*/
+func (c Config) DisableGoogleChrome() bool {
+	return c.disableGoogleChrome
+}
+
+/*
+DisableUnoconv returns true if
+Unoconv is disabled in the
+configuration.
+*/
+func (c Config) DisableUnoconv() bool {
+	return c.disableUnoconv
+}
+
+// LogLevel returns the xlog.Level from
+// the configuration.
+func (c Config) LogLevel() xlog.Level {
+	return c.logLevel
+}
+
+// RootPath returns the rooth path from
+// the configuration.
+func (c Config) RootPath() string {
+	return c.rootPath
+}
+
+// MaximumGoogleChromeRpccBufferSize returns the maximum
+// Google Chrome rpcc buffer size from the configuration.
+func (c Config) MaximumGoogleChromeRpccBufferSize() int64 {
+	return c.maximumGoogleChromeRpccBufferSize
+}
+
+// DefaultGoogleChromeRpccBufferSize returns the default
+//  Google Chrome rpcc buffer size from the configuration.
+func (c Config) DefaultGoogleChromeRpccBufferSize() int64 {
+	return c.defaultGoogleChromeRpccBufferSize
+}
+
+func (c Config) GoogleChromeIgnoreCertificateErrors() bool {
+	return c.googleChromeIgnoreCertificateErrors
+}

internal/pkg/conf/conf_test.go

@@ -0,0 +1,435 @@
+package conf
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestEmptyFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// no environment variables set,
+	// values should be equal to default config.
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+}
+
+func TestMaximumWaitTimeoutFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// MAXIMUM_WAIT_TIMEOUT correctly set.
+	os.Setenv(MaximumWaitTimeoutEnvVar, "10.0")
+	expected = DefaultConfig()
+	expected.maximumWaitTimeout = 10.0
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitTimeoutEnvVar)
+	// MAXIMUM_WAIT_TIMEOUT wrongly set.
+	os.Setenv(MaximumWaitTimeoutEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitTimeoutEnvVar)
+	// MAXIMUM_WAIT_TIMEOUT < 0.
+	os.Setenv(MaximumWaitTimeoutEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitTimeoutEnvVar)
+}
+
+func TestMaximumWaitDelayFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// MAXIMUM_WAIT_DELAY correctly set.
+	os.Setenv(MaximumWaitDelayEnvVar, "10.0")
+	expected = DefaultConfig()
+	expected.maximumWaitDelay = 10.0
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitDelayEnvVar)
+	// MAXIMUM_WAIT_DELAY wrongly set.
+	os.Setenv(MaximumWaitDelayEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitDelayEnvVar)
+	// MAXIMUM_WAIT_DELAY < 0.
+	os.Setenv(MaximumWaitDelayEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWaitDelayEnvVar)
+}
+
+func TestMaximumWebhookURLTimeoutFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// MAXIMUM_WEBHOOK_URL_TIMEOUT correctly set.
+	os.Setenv(MaximumWebhookURLTimeoutEnvVar, "10.0")
+	expected = DefaultConfig()
+	expected.maximumWebhookURLTimeout = 10.0
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWebhookURLTimeoutEnvVar)
+	// MAXIMUM_WEBHOOK_URL_TIMEOUT wrongly set.
+	os.Setenv(MaximumWebhookURLTimeoutEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWebhookURLTimeoutEnvVar)
+	// MAXIMUM_WEBHOOK_URL_TIMEOUT < 0.
+	os.Setenv(MaximumWebhookURLTimeoutEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(MaximumWebhookURLTimeoutEnvVar)
+}
+
+func TestDefaultWaitTimeoutFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DEFAULT_WAIT_TIMEOUT correctly set.
+	os.Setenv(DefaultWaitTimeoutEnvVar, "10.0")
+	expected = DefaultConfig()
+	expected.defaultWaitTimeout = 10.0
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWaitTimeoutEnvVar)
+	// DEFAULT_WAIT_TIMEOUT wrongly set.
+	os.Setenv(DefaultWaitTimeoutEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWaitTimeoutEnvVar)
+	// DEFAULT_WAIT_TIMEOUT < 0.
+	os.Setenv(DefaultWaitTimeoutEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWaitTimeoutEnvVar)
+	// DEFAULT_WAIT_TIMEOUT > MAXIMUM_WAIT_TIMEOUT.
+	os.Setenv(DefaultWaitTimeoutEnvVar, "40.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWaitTimeoutEnvVar)
+}
+
+func TestDefaultWebhookURLTimeoutFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DEFAULT_WEBHOOK_URL_TIMEOUT correctly set.
+	os.Setenv(DefaultWebhookURLTimeoutEnvVar, "10.0")
+	expected = DefaultConfig()
+	expected.defaultWebhookURLTimeout = 10.0
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWebhookURLTimeoutEnvVar)
+	// DEFAULT_WEBHOOK_URL_TIMEOUT wrongly set.
+	os.Setenv(DefaultWebhookURLTimeoutEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWebhookURLTimeoutEnvVar)
+	// DEFAULT_WEBHOOK_URL_TIMEOUT < 0.
+	os.Setenv(DefaultWebhookURLTimeoutEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWebhookURLTimeoutEnvVar)
+	// DEFAULT_WEBHOOK_URL_TIMEOUT > MAXIMUM_WEBHOOK_URL_TIMEOUT.
+	os.Setenv(DefaultWebhookURLTimeoutEnvVar, "40.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultWebhookURLTimeoutEnvVar)
+}
+
+func TestDefaultListenPortFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DEFAULT_LISTEN_PORT correctly set.
+	os.Setenv(DefaultListenPortEnvVar, "80")
+	expected = DefaultConfig()
+	expected.defaultListenPort = 80
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultListenPortEnvVar)
+	// DEFAULT_LISTEN_PORT wrongly set.
+	os.Setenv(DefaultListenPortEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultListenPortEnvVar)
+	// DEFAULT_LISTEN_PORT < 0.
+	os.Setenv(DefaultListenPortEnvVar, "-1.0")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultListenPortEnvVar)
+	// DEFAULT_LISTEN_PORT > 65535.
+	os.Setenv(DefaultListenPortEnvVar, "65536")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultListenPortEnvVar)
+}
+
+func TestDisableGoogleChromeFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DISABLE_GOOGLE_CHROME correctly set.
+	os.Setenv(DisableGoogleChromeEnvVar, "1")
+	expected = DefaultConfig()
+	expected.disableGoogleChrome = true
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableGoogleChromeEnvVar)
+	os.Setenv(DisableGoogleChromeEnvVar, "0")
+	expected = DefaultConfig()
+	expected.disableGoogleChrome = false
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableGoogleChromeEnvVar)
+	// DISABLE_GOOGLE_CHROME wrongly set.
+	os.Setenv(DisableGoogleChromeEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableGoogleChromeEnvVar)
+}
+
+func TestDisableUnoconvFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DISABLE_UNOCONV correctly set.
+	os.Setenv(DisableUnoconvEnvVar, "1")
+	expected = DefaultConfig()
+	expected.disableUnoconv = true
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableUnoconvEnvVar)
+	os.Setenv(DisableUnoconvEnvVar, "0")
+	expected = DefaultConfig()
+	expected.disableUnoconv = false
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableUnoconvEnvVar)
+	// DISABLE_UNOCONV wrongly set.
+	os.Setenv(DisableUnoconvEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DisableUnoconvEnvVar)
+}
+
+func TestLogLevelFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// LOG_LEVEL correctly set.
+	os.Setenv(LogLevelEnvVar, "DEBUG")
+	expected = DefaultConfig()
+	expected.logLevel = xlog.DebugLevel
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(LogLevelEnvVar)
+	os.Setenv(LogLevelEnvVar, "INFO")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(LogLevelEnvVar)
+	os.Setenv(LogLevelEnvVar, "ERROR")
+	expected = DefaultConfig()
+	expected.logLevel = xlog.ErrorLevel
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(LogLevelEnvVar)
+	// LOG_LEVEL wrongly set.
+	os.Setenv(LogLevelEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(LogLevelEnvVar)
+}
+
+func TestRootPathFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// ROOT_PATH correctly set.
+	os.Setenv(RootPathEnvVar, "/foo/")
+	expected = DefaultConfig()
+	expected.rootPath = "/foo/"
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(RootPathEnvVar)
+	// ROOT_PATH wrongly set.
+	os.Setenv(RootPathEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(RootPathEnvVar)
+}
+
+func TestDefaultGoogleChromeRpccBufferSizeFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE correctly set.
+	os.Setenv(DefaultGoogleChromeRpccBufferSizeEnvVar, "100")
+	expected = DefaultConfig()
+	expected.defaultGoogleChromeRpccBufferSize = 100
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultGoogleChromeRpccBufferSizeEnvVar)
+	// DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE wrongly set.
+	os.Setenv(DefaultGoogleChromeRpccBufferSizeEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultGoogleChromeRpccBufferSizeEnvVar)
+	// DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE < 0.
+	os.Setenv(DefaultGoogleChromeRpccBufferSizeEnvVar, "-1")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultGoogleChromeRpccBufferSizeEnvVar)
+	// DEFAULT_GOOGLE_CHROME_RPCC_BUFFER_SIZE > 100 MB (maximumGoogleChromeRpccBufferSize).
+	os.Setenv(DefaultGoogleChromeRpccBufferSizeEnvVar, "104857601")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(DefaultGoogleChromeRpccBufferSizeEnvVar)
+}
+
+func TestGoogleChromeIgnoreCertificateErrorsFromEnv(t *testing.T) {
+	var (
+		expected Config
+		result   Config
+		err      error
+	)
+	// GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS correctly set to true.
+	os.Setenv(GoogleChromeIgnoreCertificateErrorsEnvVar, "1")
+	expected = DefaultConfig()
+	expected.googleChromeIgnoreCertificateErrors = true
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(GoogleChromeIgnoreCertificateErrorsEnvVar)
+	// GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS correctly set to false.
+	os.Setenv(GoogleChromeIgnoreCertificateErrorsEnvVar, "0")
+	expected = DefaultConfig()
+	expected.googleChromeIgnoreCertificateErrors = false
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(GoogleChromeIgnoreCertificateErrorsEnvVar)
+	// GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS wrongly set.
+	os.Setenv(GoogleChromeIgnoreCertificateErrorsEnvVar, "foo")
+	expected = DefaultConfig()
+	result, err = FromEnv()
+	test.AssertError(t, err)
+	assert.Equal(t, expected, result)
+	os.Unsetenv(GoogleChromeIgnoreCertificateErrorsEnvVar)
+	// GOOGLE_CHROME_IGNORE_CERTIFICATE_ERRORS not set at all.
+	expected = DefaultConfig()
+	expected.googleChromeIgnoreCertificateErrors = false
+	result, err = FromEnv()
+	assert.Nil(t, err)
+	assert.Equal(t, expected, result)
+}
+
+func TestGetters(t *testing.T) {
+	result := DefaultConfig()
+	assert.Equal(t, result.maximumWaitTimeout, result.MaximumWaitTimeout())
+	assert.Equal(t, result.maximumWaitDelay, result.MaximumWaitDelay())
+	assert.Equal(t, result.maximumWebhookURLTimeout, result.MaximumWebhookURLTimeout())
+	assert.Equal(t, result.defaultWaitTimeout, result.DefaultWaitTimeout())
+	assert.Equal(t, result.defaultWebhookURLTimeout, result.DefaultWebhookURLTimeout())
+	assert.Equal(t, result.defaultListenPort, result.DefaultListenPort())
+	assert.Equal(t, result.disableGoogleChrome, result.DisableGoogleChrome())
+	assert.Equal(t, result.disableUnoconv, result.DisableUnoconv())
+	assert.Equal(t, result.logLevel, result.LogLevel())
+	assert.Equal(t, result.rootPath, result.RootPath())
+	assert.Equal(t, result.maximumGoogleChromeRpccBufferSize, result.MaximumGoogleChromeRpccBufferSize())
+	assert.Equal(t, result.defaultGoogleChromeRpccBufferSize, result.DefaultGoogleChromeRpccBufferSize())
+	assert.Equal(t, result.googleChromeIgnoreCertificateErrors, result.GoogleChromeIgnoreCertificateErrors())
+}

internal/pkg/conf/doc.go

@@ -0,0 +1,3 @@
+// Package conf gathers all
+// configuration data.
+package conf

internal/pkg/normalize/doc.go

@@ -0,0 +1,9 @@
+/*
+Package normalize helps removing special
+characters from a string.
+
+Fixes: https://github.com/thecodingmachine/gotenberg/issues/104
+
+Credits: https://medium.com/@swdream/golang-remove-all-accents-in-string-319abf6a7f5b
+*/
+package normalize

internal/pkg/normalize/normalize.go

@@ -0,0 +1,21 @@
+package normalize
+
+import (
+	"unicode"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+// String normalizes given string.
+func String(str string) (string, error) {
+	const op string = "normalize.String"
+	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	result, _, err := transform.String(t, str)
+	if err != nil {
+		return "", xerror.New(op, err)
+	}
+	return result, nil
+}

internal/pkg/normalize/normalize_test.go

@@ -0,0 +1,17 @@
+package normalize
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestString(t *testing.T) {
+	const (
+		toNormalize string = "analise da aplicação"
+		expected    string = "analise da aplicacao"
+	)
+	v, err := String(toNormalize)
+	assert.Nil(t, err)
+	assert.Equal(t, expected, v)
+}

internal/pkg/notify/doc.go

@@ -1,5 +0,0 @@
-/*
-Package notify helps displaying nice outputs
-to the user.
-*/
-package notify

internal/pkg/notify/notify.go

@@ -1,35 +0,0 @@
-package notify
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/labstack/gommon/color"
-)
-
-// Print prints a message to stdout.
-func Print(message string) {
-	stdout := color.New()
-	stdout.SetOutput(os.Stdout)
-	stdout.Printf("⇨ %s\n", message)
-}
-
-// Printf prints a formatted message to stdout.
-func Printf(format string, a ...interface{}) {
-	message := fmt.Sprintf(format, a...)
-	Print(message)
-}
-
-// WarnPrint prints a warning to stderr.
-func WarnPrint(err error) {
-	stderr := color.New()
-	stderr.SetOutput(os.Stderr)
-	stderr.Printf("%s\n", color.Yellow(fmt.Sprintf("⇨ warn: %v", err)))
-}
-
-// ErrPrint prints an error to stderr.
-func ErrPrint(err error) {
-	stderr := color.New()
-	stderr.SetOutput(os.Stderr)
-	stderr.Printf("%s\n", color.Red(fmt.Sprintf("⇨ error: %v", err)))
-}

internal/pkg/pm2/chrome.go

@@ -1,72 +0,0 @@
-package pm2
-
-import (
-	"context"
-	"time"
-
-	"github.com/mafredri/cdp/devtool"
-)
-
-type chrome struct {
-	manager *processManager
-}
-
-// NewChrome retruns a Google Chrome
-// headless process.
-func NewChrome() Process {
-	return &chrome{
-		manager: &processManager{},
-	}
-}
-
-func (p *chrome) Fullname() string {
-	return "Google Chrome headless"
-}
-
-func (p *chrome) Start() error {
-	return p.manager.start(p)
-}
-
-func (p *chrome) Shutdown() error {
-	return p.manager.shutdown(p)
-}
-
-func (p *chrome) args() []string {
-	return []string{
-		"--no-sandbox",
-		"--headless",
-		"--remote-debugging-port=9222",
-		"--disable-gpu",
-		"--disable-translate",
-		"--disable-extensions",
-		"--disable-background-networking",
-		"--safebrowsing-disable-auto-update",
-		"--disable-sync",
-		"--disable-default-apps",
-		"--hide-scrollbars",
-		"--metrics-recording-only",
-		"--mute-audio",
-		"--no-first-run",
-	}
-}
-
-func (p *chrome) name() string {
-	return "google-chrome-stable"
-}
-
-func (p *chrome) viable() bool {
-	// check if Google Chrome is correctly running.
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	_, err := devtool.New("http://localhost:9222").Version(ctx)
-	return err == nil
-}
-
-func (p *chrome) warmup() {
-	time.Sleep(5 * time.Second)
-}
-
-// Compile-time checks to ensure type implements desired interfaces.
-var (
-	_ = Process(new(chrome))
-)

internal/pkg/pm2/chrome_test.go

@@ -1,19 +0,0 @@
-package pm2
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestChromeStart(t *testing.T) {
-	p := NewChrome()
-	err := p.Start()
-	require.Nil(t, err)
-}
-
-func TestChromeShutdown(t *testing.T) {
-	p := NewChrome()
-	err := p.Shutdown()
-	require.Nil(t, err)
-}

internal/pkg/pm2/doc.go

@@ -1,12 +0,0 @@
-/*
-Package pm2 facilitates starting external
-processes on which our API depends.
-
-For instance, it may start Google Chrome headless and
-unoconv listener with PM2.
-
-The PM2 process manager launch those processes and keep
-them running in the background. If for some reason they
-crash, it will also restart them.
-*/
-package pm2

internal/pkg/pm2/pm2.go

@@ -1,83 +0,0 @@
-package pm2
-
-import (
-	"fmt"
-	"os/exec"
-)
-
-const (
-	stoppedState = iota
-	runningState
-	errorState
-)
-
-// Process is a type that can start or
-// shutdown a process with PM2.
-type Process interface {
-	Fullname() string
-	Start() error
-	Shutdown() error
-	args() []string
-	name() string
-	viable() bool
-	warmup()
-}
-
-type processManager struct {
-	heuristicState int32
-}
-
-func (m *processManager) start(p Process) error {
-	if err := m.pm2(p, "start"); err != nil {
-		return err
-	}
-	p.warmup()
-	if !p.viable() {
-		attempts := 0
-		for attempts < 5 && !p.viable() {
-			if err := m.pm2(p, "restart"); err != nil {
-				m.heuristicState = errorState
-				return err
-			}
-			p.warmup()
-			attempts++
-		}
-		if !p.viable() {
-			m.heuristicState = errorState
-			return fmt.Errorf("failed to launch %s", p.Fullname())
-		}
-	}
-	m.heuristicState = runningState
-	return nil
-}
-
-func (m *processManager) shutdown(p Process) error {
-	if m.heuristicState != runningState {
-		return nil
-	}
-	if err := m.pm2(p, "stop"); err != nil {
-		m.heuristicState = errorState
-		return err
-	}
-	m.heuristicState = stoppedState
-	return nil
-}
-
-func (m *processManager) pm2(p Process, cmdName string) error {
-	cmdArgs := []string{
-		cmdName,
-		p.name(),
-	}
-	if cmdName == "start" {
-		cmdArgs = append(cmdArgs, "--interpreter=none", "--")
-		cmdArgs = append(cmdArgs, p.args()...)
-	}
-	cmd := exec.Command(
-		"pm2",
-		cmdArgs...,
-	)
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("%s %s with PM2: %v", cmdName, p.Fullname(), err)
-	}
-	return nil
-}

internal/pkg/pm2/unoconv.go

@@ -1,52 +0,0 @@
-package pm2
-
-type unoconv struct {
-	manager *processManager
-}
-
-// NewUnoconv retruns a unoconv listener
-// process.
-func NewUnoconv() Process {
-	return &unoconv{
-		manager: &processManager{},
-	}
-}
-
-func (p *unoconv) Fullname() string {
-	return "unoconv listener"
-}
-
-func (p *unoconv) Start() error {
-	return p.manager.start(p)
-}
-
-func (p *unoconv) Shutdown() error {
-	return p.manager.shutdown(p)
-}
-
-func (p *unoconv) args() []string {
-	return []string{
-		"--listener",
-		"--verbose",
-	}
-}
-
-func (p *unoconv) name() string {
-	return "unoconv"
-}
-
-func (p *unoconv) viable() bool {
-	// TODO find a way to check if
-	// the unoconv listener
-	// is correctly started?
-	return true
-}
-
-func (p *unoconv) warmup() {
-	// let's do nothing.
-}
-
-// Compile-time checks to ensure type implements desired interfaces.
-var (
-	_ = Process(new(unoconv))
-)

internal/pkg/pm2/unoconv_test.go

@@ -1,19 +0,0 @@
-package pm2
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestUnoconvStart(t *testing.T) {
-	p := NewUnoconv()
-	err := p.Start()
-	require.Nil(t, err)
-}
-
-func TestUnoconvShutdown(t *testing.T) {
-	p := NewUnoconv()
-	err := p.Shutdown()
-	require.Nil(t, err)
-}

internal/pkg/printer/chrome.go

@@ -2,8 +2,10 @@ package printer
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"strings"
 	"time"
 
 	"github.com/mafredri/cdp"
@@ -12,85 +14,161 @@ import (
 	"github.com/mafredri/cdp/protocol/page"
 	"github.com/mafredri/cdp/protocol/target"
 	"github.com/mafredri/cdp/rpcc"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xcontext"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xtime"
 	"golang.org/x/sync/errgroup"
 )
 
-type chrome struct {
-	url  string
-	opts *ChromeOptions
+type chromePrinter struct {
+	logger xlog.Logger
+	url    string
+	opts   ChromePrinterOptions
 }
 
-// ChromeOptions helps customizing the
-// Google Chrome printer behaviour.
-type ChromeOptions struct {
-	WaitTimeout  float64
-	WaitDelay    float64
-	HeaderHTML   string
-	FooterHTML   string
-	PaperWidth   float64
-	PaperHeight  float64
-	MarginTop    float64
-	MarginBottom float64
-	MarginLeft   float64
-	MarginRight  float64
-	Landscape    bool
+// ChromePrinterOptions helps customizing the
+// Google Chrome Printer behaviour.
+type ChromePrinterOptions struct {
+	WaitTimeout       float64
+	WaitDelay         float64
+	HeaderHTML        string
+	FooterHTML        string
+	PaperWidth        float64
+	PaperHeight       float64
+	MarginTop         float64
+	MarginBottom      float64
+	MarginLeft        float64
+	MarginRight       float64
+	Landscape         bool
+	PageRanges        string
+	RpccBufferSize    int64
+	CustomHTTPHeaders map[string]string
+	Scale             float64
 }
 
-func (p *chrome) Print(destination string) error {
-	duration := time.Duration(p.opts.WaitTimeout+p.opts.WaitDelay) * time.Second
-	ctx, cancel := context.WithTimeout(context.Background(), duration)
+// DefaultChromePrinterOptions returns the default
+// Google Chrome Printer options.
+func DefaultChromePrinterOptions(config conf.Config) ChromePrinterOptions {
+	const defaultHeaderFooterHTML string = "<html><head></head><body></body></html>"
+	return ChromePrinterOptions{
+		WaitTimeout:       config.DefaultWaitTimeout(),
+		WaitDelay:         0.0,
+		HeaderHTML:        defaultHeaderFooterHTML,
+		FooterHTML:        defaultHeaderFooterHTML,
+		PaperWidth:        8.27,
+		PaperHeight:       11.7,
+		MarginTop:         1.0,
+		MarginBottom:      1.0,
+		MarginLeft:        1.0,
+		MarginRight:       1.0,
+		Landscape:         false,
+		PageRanges:        "",
+		RpccBufferSize:    config.DefaultGoogleChromeRpccBufferSize(),
+		CustomHTTPHeaders: make(map[string]string),
+		Scale:             1.0,
+	}
+}
+
+// nolint: gochecknoglobals
+var lockChrome = make(chan struct{}, 1)
+
+const maxDevtConnections int = 5
+
+// nolint: gochecknoglobals
+var devtConnections int
+
+func (p chromePrinter) Print(destination string) error {
+	const op string = "printer.chromePrinter.Print"
+	logOptions(p.logger, p.opts)
+	ctx, cancel := xcontext.WithTimeout(p.logger, p.opts.WaitTimeout+p.opts.WaitDelay)
 	defer cancel()
-	devt, err := devtool.New("http://localhost:9222").Version(ctx)
-	if err != nil {
-		return err
-	}
-	// connect to WebSocket URL (page) that speaks the Chrome DevTools Protocol.
-	devtConn, err := rpcc.DialContext(ctx, devt.WebSocketDebuggerURL)
-	if err != nil {
-		return err
-	}
-	defer devtConn.Close() // nolint: errcheck
-	// create a new CDP Client that uses conn.
-	devtClient := cdp.NewClient(devtConn)
-	newContextTarget, err := devtClient.Target.CreateBrowserContext(ctx)
-	if err != nil {
-		return fmt.Errorf("creating new browser context: %v", err)
-	}
-	// create a new blank target with the new browser context.
-	createTargetArgs := target.
-		NewCreateTargetArgs("about:blank").
-		SetBrowserContextID(newContextTarget.BrowserContextID)
-	newTarget, err := devtClient.Target.CreateTarget(ctx, createTargetArgs)
-	if err != nil {
-		return fmt.Errorf("creating new blank target: %v", err)
-	}
-	// connect the client to the new target.
-	newTargetWsURL := fmt.Sprintf("ws://127.0.0.1:9222/devtools/page/%s", newTarget.TargetID)
-	newContextConn, err := rpcc.DialContext(ctx, newTargetWsURL)
-	if err != nil {
-		return fmt.Errorf("connecting client to blank target: %v", err)
-	}
-	defer newContextConn.Close() // nolint: errcheck
-	// create a new CDP Client that uses newContextConn.
-	targetClient := cdp.NewClient(newContextConn)
-	closeTargetArgs := target.NewCloseTargetArgs(newTarget.TargetID)
-	// close the target when done.
-	defer targetClient.Target.CloseTarget(ctx, closeTargetArgs) // nolint: errcheck
-	if err := runBatch(
-		// enable all the domain events that we're interested in.
-		func() error { return targetClient.DOM.Enable(ctx) },
-		func() error { return targetClient.Network.Enable(ctx, network.NewEnableArgs()) },
-		func() error { return targetClient.Page.Enable(ctx) },
-		func() error { return targetClient.Runtime.Enable(ctx) },
-	); err != nil {
-		return err
-	}
-	if err := p.navigate(ctx, targetClient); err != nil {
-		return err
-	}
-	print, err := targetClient.Page.PrintToPDF(
-		ctx,
-		page.NewPrintToPDFArgs().
+	resolver := func() error {
+		devt, err := devtool.New("http://localhost:9222").Version(ctx)
+		if err != nil {
+			return err
+		}
+		// connect to WebSocket URL (page) that speaks the Chrome DevTools Protocol.
+		devtConn, err := rpcc.DialContext(ctx, devt.WebSocketDebuggerURL)
+		if err != nil {
+			return err
+		}
+		defer devtConn.Close()
+		// create a new CDP Client that uses conn.
+		devtClient := cdp.NewClient(devtConn)
+		createBrowserContextArgs := target.NewCreateBrowserContextArgs()
+		newContextTarget, err := devtClient.Target.CreateBrowserContext(ctx, createBrowserContextArgs)
+		if err != nil {
+			return err
+		}
+		/*
+			close the browser context when done.
+			we're not using the "default" context
+			as it may timeout before actually closing
+			the browser context.
+			see: https://github.com/mafredri/cdp/issues/101#issuecomment-524533670
+		*/
+		disposeBrowserContextArgs := target.NewDisposeBrowserContextArgs(newContextTarget.BrowserContextID)
+		defer devtClient.Target.DisposeBrowserContext(context.Background(), disposeBrowserContextArgs) // nolint: errcheck
+		// create a new blank target with the new browser context.
+		createTargetArgs := target.
+			NewCreateTargetArgs("about:blank").
+			SetBrowserContextID(newContextTarget.BrowserContextID)
+		newTarget, err := devtClient.Target.CreateTarget(ctx, createTargetArgs)
+		if err != nil {
+			return err
+		}
+		// connect the client to the new target.
+		newTargetWsURL := fmt.Sprintf("ws://127.0.0.1:9222/devtools/page/%s", newTarget.TargetID)
+		newContextConn, err := rpcc.DialContext(
+			ctx,
+			newTargetWsURL,
+			/*
+				see:
+				https://github.com/thecodingmachine/gotenberg/issues/108
+				https://github.com/mafredri/cdp/issues/4
+				https://github.com/ChromeDevTools/devtools-protocol/issues/24
+			*/
+			rpcc.WithWriteBufferSize(int(p.opts.RpccBufferSize)),
+			rpcc.WithCompression(),
+		)
+		if err != nil {
+			return err
+		}
+		defer newContextConn.Close()
+		// create a new CDP Client that uses newContextConn.
+		targetClient := cdp.NewClient(newContextConn)
+		/*
+			close the target when done.
+			we're not using the "default" context
+			as it may timeout before actually closing
+			the target.
+			see: https://github.com/mafredri/cdp/issues/101#issuecomment-524533670
+		*/
+		closeTargetArgs := target.NewCloseTargetArgs(newTarget.TargetID)
+		defer targetClient.Target.CloseTarget(context.Background(), closeTargetArgs) // nolint: errcheck
+		// enable all events.
+		if err := p.enableEvents(ctx, targetClient); err != nil {
+			return err
+		}
+		// add custom headers (if any).
+		if err := p.setCustomHTTPHeaders(ctx, targetClient); err != nil {
+			return err
+		}
+		// listen for all events.
+		if err := p.listenEvents(ctx, targetClient); err != nil {
+			return err
+		}
+		// apply a wait delay (if any).
+		if p.opts.WaitDelay > 0.0 {
+			// wait for a given amount of time (useful for javascript delay).
+			p.logger.DebugOpf(op, "applying a wait delay of '%.2fs'...", p.opts.WaitDelay)
+			time.Sleep(xtime.Duration(p.opts.WaitDelay))
+		} else {
+			p.logger.DebugOp(op, "no wait delay to apply, moving on...")
+		}
+		printToPdfArgs := page.NewPrintToPDFArgs().
 			SetPaperWidth(p.opts.PaperWidth).
 			SetPaperHeight(p.opts.PaperHeight).
 			SetMarginTop(p.opts.MarginTop).
@@ -101,55 +179,205 @@ func (p *chrome) Print(destination string) error {
 			SetDisplayHeaderFooter(true).
 			SetHeaderTemplate(p.opts.HeaderHTML).
 			SetFooterTemplate(p.opts.FooterHTML).
-			SetPrintBackground(true),
-	)
-	if err != nil {
-		return fmt.Errorf("printing page to PDF: %v", err)
+			SetPrintBackground(true).
+			SetScale(p.opts.Scale)
+		if p.opts.PageRanges != "" {
+			printToPdfArgs.SetPageRanges(p.opts.PageRanges)
+		}
+		// printToPDF the page to PDF.
+		printToPDF, err := targetClient.Page.PrintToPDF(
+			ctx,
+			printToPdfArgs,
+		)
+		if err != nil {
+			// find a way to check it in the handlers?
+			if strings.Contains(err.Error(), "Page range syntax error") {
+				return xerror.Invalid(
+					op,
+					fmt.Sprintf("'%s' is not a valid Google Chrome page ranges", p.opts.PageRanges),
+					err,
+				)
+			}
+			if strings.Contains(err.Error(), "rpcc: message too large") {
+				return xerror.Invalid(
+					op,
+					fmt.Sprintf(
+						"'%d' bytes are not enough: increase the Google Chrome rpcc buffer size (up to 100 MB)",
+						p.opts.RpccBufferSize,
+					),
+					err,
+				)
+			}
+			return err
+		}
+		if err := ioutil.WriteFile(destination, printToPDF.Data, 0600); err != nil {
+			return err
+		}
+		return nil
 	}
-	if err := ioutil.WriteFile(destination, print.Data, 0644); err != nil {
-		return fmt.Errorf("%s: writing file: %v", destination, err)
+	if devtConnections < maxDevtConnections {
+		p.logger.DebugOp(op, "skipping lock acquisition...")
+		devtConnections++
+		err := resolver()
+		devtConnections--
+		if err != nil {
+			return xcontext.MustHandleError(
+				ctx,
+				xerror.New(op, err),
+			)
+		}
+		return nil
+	}
+	p.logger.DebugOp(op, "waiting lock to be acquired...")
+	select {
+	case lockChrome <- struct{}{}:
+		// lock acquired.
+		p.logger.DebugOp(op, "lock acquired")
+		devtConnections++
+		err := resolver()
+		devtConnections--
+		<-lockChrome // we release the lock.
+		if err != nil {
+			return xcontext.MustHandleError(
+				ctx,
+				xerror.New(op, err),
+			)
+		}
+		return nil
+	case <-ctx.Done():
+		// failed to acquire lock before
+		// deadline.
+		p.logger.DebugOp(op, "failed to acquire lock before context.Context deadline")
+		return xcontext.MustHandleError(
+			ctx,
+			ctx.Err(),
+		)
+	}
+}
+
+func (p chromePrinter) enableEvents(ctx context.Context, client *cdp.Client) error {
+	const op string = "printer.chromePrinter.enableEvents"
+	// enable all the domain events that we're interested in.
+	if err := runBatch(
+		func() error { return client.DOM.Enable(ctx) },
+		func() error { return client.Network.Enable(ctx, network.NewEnableArgs()) },
+		func() error { return client.Page.Enable(ctx) },
+		func() error {
+			return client.Page.SetLifecycleEventsEnabled(ctx, page.NewSetLifecycleEventsEnabledArgs(true))
+		},
+		func() error { return client.Runtime.Enable(ctx) },
+	); err != nil {
+		return xerror.New(op, err)
 	}
 	return nil
 }
 
-func (p *chrome) navigate(ctx context.Context, client *cdp.Client) error {
-	// make sure Page events are enabled.
-	if err := client.Page.Enable(ctx); err != nil {
-		return err
+func (p chromePrinter) setCustomHTTPHeaders(ctx context.Context, client *cdp.Client) error {
+	const op string = "printer.chromePrinter.setCustomHTTPHeaders"
+	resolver := func() error {
+		if len(p.opts.CustomHTTPHeaders) == 0 {
+			p.logger.DebugOp(op, "skipping custom HTTP headers as none have been provided...")
+			return nil
+		}
+		customHTTPHeaders := make(map[string]string)
+		// useless but for the logs.
+		for key, value := range p.opts.CustomHTTPHeaders {
+			customHTTPHeaders[key] = value
+			p.logger.DebugOpf(op, "set '%s' to custom HTTP header '%s'", value, key)
+		}
+		b, err := json.Marshal(customHTTPHeaders)
+		if err != nil {
+			return err
+		}
+		// should always be called after client.Network.Enable.
+		return client.Network.SetExtraHTTPHeaders(ctx, network.NewSetExtraHTTPHeadersArgs(b))
 	}
-	// make sure Network events are enabled.
-	if err := client.Network.Enable(ctx, nil); err != nil {
-		return err
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
 	}
-	// create all clients for events.
-	domContentEventFired, err := client.Page.DOMContentEventFired(ctx)
-	if err != nil {
-		return err
-	}
-	defer domContentEventFired.Close() // nolint: errcheck
-	loadEventFired, err := client.Page.LoadEventFired(ctx)
-	if err != nil {
-		return err
-	}
-	defer loadEventFired.Close() // nolint: errcheck
-	loadingFinished, err := client.Network.LoadingFinished(ctx)
-	if err != nil {
-		return err
-	}
-	defer loadingFinished.Close() // nolint: errcheck
-	if _, err := client.Page.Navigate(ctx, page.NewNavigateArgs(p.url)); err != nil {
-		return err
-	}
-	if err := runBatch(
+	return nil
+}
+
+func (p chromePrinter) listenEvents(ctx context.Context, client *cdp.Client) error {
+	const op string = "printer.chromePrinter.listenEvents"
+	resolver := func() error {
+		// make sure Page events are enabled.
+		if err := client.Page.Enable(ctx); err != nil {
+			return err
+		}
+		// make sure Network events are enabled.
+		if err := client.Network.Enable(ctx, nil); err != nil {
+			return err
+		}
+		// create all clients for events.
+		domContentEventFired, err := client.Page.DOMContentEventFired(ctx)
+		if err != nil {
+			return err
+		}
+		defer domContentEventFired.Close()
+		loadEventFired, err := client.Page.LoadEventFired(ctx)
+		if err != nil {
+			return err
+		}
+		defer loadEventFired.Close()
+		lifecycleEvent, err := client.Page.LifecycleEvent(ctx)
+		if err != nil {
+			return err
+		}
+		defer lifecycleEvent.Close()
+		loadingFinished, err := client.Network.LoadingFinished(ctx)
+		if err != nil {
+			return err
+		}
+		defer loadingFinished.Close()
+		if _, err := client.Page.Navigate(ctx, page.NewNavigateArgs(p.url)); err != nil {
+			return err
+		}
 		// wait for all events.
-		func() error { _, err := domContentEventFired.Recv(); return err },
-		func() error { _, err := loadEventFired.Recv(); return err },
-		func() error { _, err := loadingFinished.Recv(); return err },
-	); err != nil {
-		return err
+		return runBatch(
+			func() error {
+				_, err := domContentEventFired.Recv()
+				if err != nil {
+					return err
+				}
+				p.logger.DebugOp(op, "event 'domContentEventFired' received")
+				return nil
+			},
+			func() error {
+				_, err := loadEventFired.Recv()
+				if err != nil {
+					return err
+				}
+				p.logger.DebugOp(op, "event 'loadEventFired' received")
+				return nil
+			},
+			func() error {
+				const networkIdleEventName string = "networkIdle"
+				for {
+					ev, err := lifecycleEvent.Recv()
+					if err != nil {
+						return err
+					}
+					p.logger.DebugOpf(op, "event '%s' received", ev.Name)
+					if ev.Name == networkIdleEventName {
+						break
+					}
+				}
+				return nil
+			},
+			func() error {
+				_, err := loadingFinished.Recv()
+				if err != nil {
+					return err
+				}
+				p.logger.DebugOp(op, "event 'loadingFinished' received")
+				return nil
+			},
+		)
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
 	}
-	// wait for a given amount of time (useful for javascript delay).
-	time.Sleep(time.Duration(p.opts.WaitDelay) * time.Second)
 	return nil
 }
 
@@ -165,5 +393,5 @@ func runBatch(fn ...func() error) error {
 
 // Compile-time checks to ensure type implements desired interfaces.
 var (
-	_ = Printer(new(chrome))
+	_ = Printer(new(chromePrinter))
 )

internal/pkg/printer/doc.go

@@ -1,5 +1,3 @@
-/*
-Package printer contains structs which convert
-a specific file type to PDF.
-*/
+// Package printer helps converting
+// a specific file type to PDF.
 package printer

internal/pkg/printer/html.go

@@ -2,13 +2,17 @@ package printer
 
 import (
 	"fmt"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
 )
 
-// NewHTML returns an HTML printer.
-func NewHTML(fpath string, opts *ChromeOptions) Printer {
+// NewHTMLPrinter returns a Printer which
+// is able to convert an HTML file to PDF.
+func NewHTMLPrinter(logger xlog.Logger, fpath string, opts ChromePrinterOptions) Printer {
 	URL := fmt.Sprintf("file://%s", fpath)
-	return &chrome{
-		url:  URL,
-		opts: opts,
+	return chromePrinter{
+		logger: logger,
+		url:    URL,
+		opts:   opts,
 	}
 }

internal/pkg/printer/html_test.go

@@ -0,0 +1,72 @@
+package printer
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestHTMLPrinter(t *testing.T) {
+	var (
+		logger xlog.Logger = test.DebugLogger()
+		config conf.Config = conf.DefaultConfig()
+		fpath  string      = test.HTMLFpaths(t)[0]
+		opts   ChromePrinterOptions
+		dest   string
+		p      Printer
+		err    error
+	)
+	// default options.
+	opts = DefaultChromePrinterOptions(config)
+	p = NewHTMLPrinter(logger, fpath, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a wait delay.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitDelay = 0.5
+	p = NewHTMLPrinter(logger, fpath, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a page ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "1"
+	p = NewHTMLPrinter(logger, fpath, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as options have
+	// a wrong page ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "foo"
+	p = NewHTMLPrinter(logger, fpath, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.InvalidCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as context.Context
+	// should timeout.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitTimeout = 0.0
+	p = NewHTMLPrinter(logger, fpath, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.TimeoutCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+}

internal/pkg/printer/markdown.go

@@ -3,42 +3,51 @@ package printer
 import (
 	"bytes"
 	"fmt"
+	"github.com/microcosm-cc/bluemonday"
+	"github.com/russross/blackfriday/v2"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xrand"
 	"html/template"
 	"io/ioutil"
 	"path/filepath"
-
-	"github.com/microcosm-cc/bluemonday"
-	"github.com/russross/blackfriday/v2"
-	"github.com/thecodingmachine/gotenberg/internal/pkg/rand"
 )
 
-// NewMarkdown returns a Markdown printer.
-func NewMarkdown(fpath string, opts *ChromeOptions) (Printer, error) {
-	tmpl, err := template.
-		New(filepath.Base(fpath)).
-		Funcs(template.FuncMap{"toHTML": markdownToHTML}).
-		ParseFiles(fpath)
+// NewMarkdownPrinter returns a Printer which
+// is able to convert Markdown files to PDF.
+func NewMarkdownPrinter(logger xlog.Logger, fpath string, opts ChromePrinterOptions) (Printer, error) {
+	const op string = "printer.NewMarkdownPrinter"
+	resolver := func() (string, error) {
+		tmpl, err := template.
+			New(filepath.Base(fpath)).
+			Funcs(template.FuncMap{"toHTML": markdownToHTML}).
+			ParseFiles(fpath)
+		if err != nil {
+			return "", err
+		}
+		dirPath := filepath.Dir(fpath)
+		data := &templateData{DirPath: dirPath}
+		logger.DebugOp(op, "converting Markdown files to HTML...")
+		var buffer bytes.Buffer
+		if err := tmpl.Execute(&buffer, data); err != nil {
+			return "", err
+		}
+		baseFilename := xrand.Get()
+		dst := fmt.Sprintf("%s/%s.html", dirPath, baseFilename)
+		logger.DebugOp(op, "writing the HTML from previous conversion(s) into new file...")
+		if err := ioutil.WriteFile(dst, buffer.Bytes(), 0600); err != nil {
+			return "", err
+		}
+		return fmt.Sprintf("file://%s", dst), nil
+	}
+	URL, err := resolver()
 	if err != nil {
-		return nil, fmt.Errorf("%s: parsing template: %v", fpath, err)
+		return chromePrinter{}, xerror.New(op, err)
 	}
-	dirPath := filepath.Dir(fpath)
-	data := &templateData{DirPath: dirPath}
-	var buffer bytes.Buffer
-	if err := tmpl.Execute(&buffer, data); err != nil {
-		return nil, fmt.Errorf("%s: executing template: %v", fpath, err)
-	}
-	baseFilename, err := rand.Get()
-	if err != nil {
-		return nil, err
-	}
-	dst := fmt.Sprintf("%s/%s.html", dirPath, baseFilename)
-	if err := ioutil.WriteFile(dst, buffer.Bytes(), 0644); err != nil {
-		return nil, fmt.Errorf("%s: writing file: %v", dst, err)
-	}
-	URL := fmt.Sprintf("file://%s", dst)
-	return &chrome{
-		url:  URL,
-		opts: opts,
+	return chromePrinter{
+		logger: logger,
+		url:    URL,
+		opts:   opts,
 	}, nil
 }
 
@@ -47,10 +56,13 @@ type templateData struct {
 }
 
 func markdownToHTML(dirPath, filename string) (template.HTML, error) {
+	const op string = "printer.markdownToHTML"
+	// avoid directory traversal.
+	filename = filepath.Base(filename)
 	fpath := fmt.Sprintf("%s/%s", dirPath, filename)
 	b, err := ioutil.ReadFile(fpath)
 	if err != nil {
-		return "", fmt.Errorf("%s: reading file: %v", fpath, err)
+		return "", xerror.New(op, err)
 	}
 	unsafe := blackfriday.Run(b)
 	content := bluemonday.UGCPolicy().SanitizeBytes(unsafe)

internal/pkg/printer/markdown_test.go

@@ -0,0 +1,77 @@
+package printer
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestMarkdownPrinter(t *testing.T) {
+	var (
+		logger xlog.Logger = test.DebugLogger()
+		config conf.Config = conf.DefaultConfig()
+		fpath  string      = test.MarkdownFpaths(t)[0]
+		opts   ChromePrinterOptions
+		dest   string
+		p      Printer
+		err    error
+	)
+	// default options.
+	opts = DefaultChromePrinterOptions(config)
+	p, err = NewMarkdownPrinter(logger, fpath, opts)
+	assert.Nil(t, err)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a wait delay.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitDelay = 0.5
+	p, err = NewMarkdownPrinter(logger, fpath, opts)
+	assert.Nil(t, err)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a page ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "1"
+	p, err = NewMarkdownPrinter(logger, fpath, opts)
+	assert.Nil(t, err)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as options have
+	// a wrong page ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "foo"
+	p, err = NewMarkdownPrinter(logger, fpath, opts)
+	assert.Nil(t, err)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.InvalidCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as context.Context
+	// should timeout.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitTimeout = 0.0
+	p, err = NewMarkdownPrinter(logger, fpath, opts)
+	assert.Nil(t, err)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.TimeoutCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+}

internal/pkg/printer/merge.go

@@ -2,49 +2,78 @@ package printer
 
 import (
 	"context"
-	"fmt"
-	"os/exec"
-	"time"
+	"sort"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xcontext"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xexec"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
 )
 
-type merge struct {
+type mergePrinter struct {
 	ctx    context.Context
+	logger xlog.Logger
 	fpaths []string
-	opts   *MergeOptions
+	opts   MergePrinterOptions
 }
 
-// MergeOptions helps customizing the
-// merge printer behaviour.
-type MergeOptions struct {
+// MergePrinterOptions helps customizing the
+// merge Printer behaviour.
+type MergePrinterOptions struct {
 	WaitTimeout float64
 }
 
-// NewMerge returns a merge printer.
-func NewMerge(fpaths []string, opts *MergeOptions) Printer {
-	return &merge{
+// DefaultMergePrinterOptions returns the default
+// merge Printer options.
+func DefaultMergePrinterOptions(config conf.Config) MergePrinterOptions {
+	return MergePrinterOptions{
+		WaitTimeout: config.DefaultWaitTimeout(),
+	}
+}
+
+// NewMergePrinter returns a Printer which
+// is able to merge PDFs.
+func NewMergePrinter(logger xlog.Logger, fpaths []string, opts MergePrinterOptions) Printer {
+	return mergePrinter{
+		logger: logger,
 		fpaths: fpaths,
 		opts:   opts,
 	}
 }
 
-func (p *merge) Print(destination string) error {
+func (p mergePrinter) Print(destination string) error {
+	const op string = "printer.mergePrinter.Print"
+	/*
+		context.Context may be providen from
+		an officePrinter which needs to merge
+		its result files.
+	*/
 	if p.ctx == nil {
-		ctx, cancel := context.WithTimeout(context.Background(), time.Duration(p.opts.WaitTimeout)*time.Second)
+		logOptions(p.logger, p.opts)
+		ctx, cancel := xcontext.WithTimeout(p.logger, p.opts.WaitTimeout)
 		defer cancel()
 		p.ctx = ctx
 	}
-	var cmdArgs []string
-	cmdArgs = append(cmdArgs, p.fpaths...)
-	cmdArgs = append(cmdArgs, "cat", "output", destination)
-	cmd := exec.CommandContext(p.ctx, "pdftk", cmdArgs...)
-	_, err := cmd.Output()
-	if err != nil {
-		return fmt.Errorf("pdtk: %v", err)
+	// see https://github.com/thecodingmachine/gotenberg/issues/139.
+	sort.Strings(p.fpaths)
+	p.logger.DebugOpf(op, "merging '%v'...", p.fpaths)
+	resolver := func() error {
+		var args []string
+		args = append(args, p.fpaths...)
+		args = append(args, "cat", "output", destination)
+		return xexec.Run(p.ctx, p.logger, "pdftk", args...)
+	}
+	if err := resolver(); err != nil {
+		return xcontext.MustHandleError(
+			p.ctx,
+			xerror.New(op, err),
+		)
 	}
 	return nil
 }
 
 // Compile-time checks to ensure type implements desired interfaces.
 var (
-	_ = Printer(new(merge))
+	_ = Printer(new(mergePrinter))
 )

internal/pkg/printer/merge_test.go

@@ -0,0 +1,43 @@
+package printer
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestMergePrinter(t *testing.T) {
+	var (
+		logger xlog.Logger = test.DebugLogger()
+		config conf.Config = conf.DefaultConfig()
+		fpaths []string    = test.MergeFpaths(t)
+		opts   MergePrinterOptions
+		dest   string
+		p      Printer
+		err    error
+	)
+	// default options.
+	opts = DefaultMergePrinterOptions(config)
+	p = NewMergePrinter(logger, fpaths, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as context.Context
+	// should timeout.
+	opts = DefaultMergePrinterOptions(config)
+	opts.WaitTimeout = 0.0
+	p = NewMergePrinter(logger, fpaths, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.TimeoutCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+}

internal/pkg/printer/office.go

@@ -4,87 +4,149 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"sync"
-	"time"
+	"sort"
+	"strings"
 
-	"github.com/thecodingmachine/gotenberg/internal/pkg/rand"
+	"github.com/phayes/freeport"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xcontext"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xexec"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xrand"
 )
 
-type office struct {
+type officePrinter struct {
+	logger xlog.Logger
 	fpaths []string
-	opts   *OfficeOptions
+	opts   OfficePrinterOptions
 }
 
-// OfficeOptions helps customizing the
-// Office printer behaviour.
-type OfficeOptions struct {
+// OfficePrinterOptions helps customizing the
+// Office Printer behaviour.
+type OfficePrinterOptions struct {
 	WaitTimeout float64
 	Landscape   bool
+	PageRanges  string
 }
 
-// NewOffice returns an Office printer.
-func NewOffice(fpaths []string, opts *OfficeOptions) Printer {
-	return &office{
+// DefaultOfficePrinterOptions returns the default
+// Office Printer options.
+func DefaultOfficePrinterOptions(config conf.Config) OfficePrinterOptions {
+	return OfficePrinterOptions{
+		WaitTimeout: config.DefaultWaitTimeout(),
+		Landscape:   false,
+		PageRanges:  "",
+	}
+}
+
+// NewOfficePrinter returns a Printer which
+// is able to convert Office documents to PDF.
+func NewOfficePrinter(logger xlog.Logger, fpaths []string, opts OfficePrinterOptions) Printer {
+	return officePrinter{
+		logger: logger,
 		fpaths: fpaths,
 		opts:   opts,
 	}
 }
 
-func (p *office) Print(destination string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(p.opts.WaitTimeout)*time.Second)
+func (p officePrinter) Print(destination string) error {
+	const op string = "printer.officePrinter.Print"
+	logOptions(p.logger, p.opts)
+	ctx, cancel := xcontext.WithTimeout(p.logger, p.opts.WaitTimeout)
 	defer cancel()
-	fpaths := make([]string, len(p.fpaths))
-	dirPath := filepath.Dir(destination)
-	for i, fpath := range p.fpaths {
-		baseFilename, err := rand.Get()
-		if err != nil {
-			return err
+	resolver := func() error {
+		// see https://github.com/thecodingmachine/gotenberg/issues/139.
+		sort.Strings(p.fpaths)
+		fpaths := make([]string, len(p.fpaths))
+		dirPath := filepath.Dir(destination)
+		for i, fpath := range p.fpaths {
+			baseFilename := xrand.Get()
+			tmpDest := fmt.Sprintf("%s/%d%s.pdf", dirPath, i, baseFilename)
+			p.logger.DebugOpf(op, "converting '%s' to PDF...", fpath)
+			if err := p.unoconv(ctx, fpath, tmpDest); err != nil {
+				return err
+			}
+			p.logger.DebugOpf(op, "'%s.pdf' created", baseFilename)
+			fpaths[i] = tmpDest
 		}
-		tmpDest := fmt.Sprintf("%s/%d%s.pdf", dirPath, i, baseFilename)
-		if err := unoconv(ctx, fpath, tmpDest, p.opts); err != nil {
-			return err
+		if len(fpaths) == 1 {
+			p.logger.DebugOp(op, "only one PDF created, nothing to merge")
+			return os.Rename(fpaths[0], destination)
 		}
-		fpaths[i] = tmpDest
+		m := mergePrinter{
+			logger: p.logger,
+			ctx:    ctx,
+			fpaths: fpaths,
+		}
+		return m.Print(destination)
 	}
-	if len(fpaths) == 1 {
-		return os.Rename(fpaths[0], destination)
-	}
-	m := &merge{
-		ctx:    ctx,
-		fpaths: fpaths,
-	}
-	return m.Print(destination)
-}
-
-// nolint: gochecknoglobals
-var mu sync.Mutex
-
-func unoconv(ctx context.Context, fpath, destination string, opts *OfficeOptions) error {
-	mu.Lock()
-	defer mu.Unlock()
-	cmdArgs := []string{
-		"--format",
-		"pdf",
-	}
-	if opts.Landscape {
-		cmdArgs = append(cmdArgs, "--printer", "PaperOrientation=landscape")
-	}
-	cmdArgs = append(cmdArgs, "--output", destination, fpath)
-	cmd := exec.CommandContext(
-		ctx,
-		"unoconv",
-		cmdArgs...,
-	)
-	_, err := cmd.Output()
-	if err != nil {
-		return fmt.Errorf("unoconv: %v", err)
+	if err := resolver(); err != nil {
+		return xcontext.MustHandleError(
+			ctx,
+			xerror.New(op, err),
+		)
 	}
 	return nil
 }
 
+func (p officePrinter) unoconv(ctx context.Context, fpath, destination string) error {
+	const op string = "printer.unoconv"
+	resolver := func() error {
+		dirName := xrand.Get()
+		port, err := freeport.GetFreePort()
+		if err != nil {
+			return err
+		}
+		args := []string{
+			"--user-profile",
+			fmt.Sprintf("///tmp/%s", dirName),
+			"--port",
+			fmt.Sprintf("%d", port),
+			"--format",
+			"pdf",
+		}
+		if p.opts.Landscape {
+			args = append(args, "--printer", "PaperOrientation=landscape")
+		}
+		if p.opts.PageRanges != "" {
+			args = append(args, "--export", fmt.Sprintf("PageRange=%s", p.opts.PageRanges))
+		}
+		args = append(args, "--output", destination, fpath)
+		err = xexec.Run(ctx, p.logger, "unoconv", args...)
+		// always remove user profile folders created by LibreOffice.
+		// see https://github.com/thecodingmachine/gotenberg/issues/192.
+		go cleanupUserProfile(p.logger, dirName)
+		if err != nil {
+			// find a way to check it in the handlers?
+			if p.opts.PageRanges != "" && strings.Contains(err.Error(), "exit status 5") {
+				return xerror.Invalid(
+					op,
+					fmt.Sprintf("'%s' is not a valid LibreOffice page ranges", p.opts.PageRanges),
+					err,
+				)
+			}
+			return err
+		}
+		return nil
+	}
+	if err := resolver(); err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func cleanupUserProfile(logger xlog.Logger, dirName string) {
+	const op = "printer.cleanupUserProfile"
+	path := fmt.Sprintf("/tmp/%s", dirName)
+	if err := os.RemoveAll(path); err != nil {
+		// find a way to bubble up this error?
+		logger.ErrorOpf(op, "failed to remove user profile directory '%s': %s", path, err.Error())
+	}
+}
+
 // Compile-time checks to ensure type implements desired interfaces.
 var (
-	_ = Printer(new(office))
+	_ = Printer(new(officePrinter))
 )

internal/pkg/printer/office_test.go

@@ -0,0 +1,80 @@
+package printer
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestOfficePrinter(t *testing.T) {
+	var (
+		logger xlog.Logger = test.DebugLogger()
+		config conf.Config = conf.DefaultConfig()
+		fpaths []string    = test.OfficeFpaths(t)
+		opts   OfficePrinterOptions
+		dest   string
+		p      Printer
+		err    error
+	)
+	// default options.
+	opts = DefaultOfficePrinterOptions(config)
+	p = NewOfficePrinter(logger, fpaths, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// using one file.
+	opts = DefaultOfficePrinterOptions(config)
+	p = NewOfficePrinter(logger, []string{fpaths[0]}, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with landscape.
+	opts = DefaultOfficePrinterOptions(config)
+	opts.Landscape = true
+	p = NewOfficePrinter(logger, fpaths, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with page ranges.
+	opts = DefaultOfficePrinterOptions(config)
+	opts.PageRanges = "1-1"
+	p = NewOfficePrinter(logger, []string{fpaths[0]}, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as options have
+	// a wrong page ranges.
+	opts = DefaultOfficePrinterOptions(config)
+	opts.PageRanges = "foo"
+	p = NewOfficePrinter(logger, []string{fpaths[0]}, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.InvalidCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as context.Context
+	// should timeout.
+	opts = DefaultOfficePrinterOptions(config)
+	opts.WaitTimeout = 0.0
+	p = NewOfficePrinter(logger, fpaths, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.TimeoutCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+}

internal/pkg/printer/printer.go

@@ -1,7 +1,16 @@
 package printer
 
+import (
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
 // Printer is a type that can create a PDF file from a source.
 // The source is defined in the underlying implementation.
 type Printer interface {
 	Print(destination string) error
 }
+
+func logOptions(logger xlog.Logger, opts interface{}) {
+	const op string = "printer.logOptions"
+	logger.DebugOpf(op, "options: %+v", opts)
+}

internal/pkg/printer/url.go

@@ -1,9 +1,15 @@
 package printer
 
-// NewURL returns a URL printer.
-func NewURL(url string, opts *ChromeOptions) Printer {
-	return &chrome{
-		url:  url,
-		opts: opts,
+import (
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
+// NewURLPrinter returns a Printer which
+// is able to convert a URL to PDF.
+func NewURLPrinter(logger xlog.Logger, url string, opts ChromePrinterOptions) Printer {
+	return chromePrinter{
+		logger: logger,
+		url:    url,
+		opts:   opts,
 	}
 }

internal/pkg/printer/url_test.go

@@ -0,0 +1,72 @@
+package printer
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/conf"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+	"github.com/thecodingmachine/gotenberg/test"
+)
+
+func TestURLPrinter(t *testing.T) {
+	var (
+		logger xlog.Logger = test.DebugLogger()
+		config conf.Config = conf.DefaultConfig()
+		URL                = "https://google.com"
+		opts   ChromePrinterOptions
+		dest   string
+		p      Printer
+		err    error
+	)
+	// default options.
+	opts = DefaultChromePrinterOptions(config)
+	p = NewURLPrinter(logger, URL, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a wait delay.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitDelay = 0.5
+	p = NewURLPrinter(logger, URL, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// options with a pages ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "1"
+	p = NewURLPrinter(logger, URL, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	assert.Nil(t, err)
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as options have
+	// a wrong page ranges.
+	opts = DefaultChromePrinterOptions(config)
+	opts.PageRanges = "foo"
+	p = NewURLPrinter(logger, URL, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.InvalidCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+	// should not be OK as context.Context
+	// should timeout.
+	opts = DefaultChromePrinterOptions(config)
+	opts.WaitTimeout = 0.0
+	p = NewURLPrinter(logger, URL, opts)
+	dest = test.GenerateDestination()
+	err = p.Print(dest)
+	test.AssertError(t, err)
+	assert.Equal(t, xerror.TimeoutCode, xerror.Code(err))
+	err = os.RemoveAll(dest)
+	assert.Nil(t, err)
+}

internal/pkg/rand/doc.go

@@ -1,7 +0,0 @@
-/*
-Package rand helps generating a random string.
-
-It should be used for creating directory and
-file names in order to avoid collision.
-*/
-package rand

internal/pkg/rand/rand.go

@@ -1,17 +0,0 @@
-package rand
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-)
-
-// Get returns a random string.
-func Get() (string, error) {
-	randBytes := make([]byte, 16)
-	_, err := rand.Read(randBytes)
-	if err != nil {
-		return "", fmt.Errorf("creating random string: %v", err)
-	}
-	return hex.EncodeToString(randBytes), nil
-}

internal/pkg/rand/rand_test.go

@@ -1,16 +0,0 @@
-package rand
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGet(t *testing.T) {
-	rand1, err := Get()
-	require.Nil(t, err)
-	rand2, err := Get()
-	require.Nil(t, err)
-	assert.NotEqual(t, rand1, rand2)
-}

internal/pkg/xassert/doc.go

@@ -0,0 +1,8 @@
+/*
+Package xassert is a helper for converting
+and/or validating strings.
+
+All functions return our standard xerror.Error
+in case of error.
+*/
+package xassert