hotfix for the release error

build(deps): bump github.com/fasthttp/router from 1.4.22 to 1.5.0

.codecov.yml

@@ -0,0 +1,26 @@
+# Docs: <https://docs.codecov.io/docs/commit-status>
+
+coverage:
+  # coverage lower than 50 is red, higher than 90 green
+  range: 30..80
+
+  status:
+    project:
+      default:
+        # Choose a minimum coverage ratio that the commit must meet to be considered a success.
+        #
+        # `auto` will use the coverage from the base commit (pull request base or parent commit) coverage to compare
+        # against.
+        target: auto
+
+        # Allow the coverage to drop by X%, and posting a success status.
+        threshold: 5%
+
+        # Resulting status will pass no matter what the coverage is or what other settings are specified.
+        informational: true
+
+    patch:
+      default:
+        target: auto
+        threshold: 5%
+        informational: true

.dockerignore

@@ -1,3 +1,9 @@
-/out
-/node_modules
-*.log
+## Ignore everything
+*
+
+## Except the following files and directories
+!/cmd
+!/internal
+!/templates
+!/error-pages.yml
+!/go.*

.editorconfig

@@ -1,3 +1,5 @@
+# EditorConfig docs: <https://editorconfig.org/>
+
 root = true
 
 [*]
@@ -5,11 +7,8 @@ charset = utf-8
 end_of_line = lf
 insert_final_newline = true
 indent_style = space
-indent_size = 4
+indent_size = 2
 trim_trailing_whitespace = true
 
-[*.{yml, yaml, sh, conf}]
-indent_size = 2
-
-[Makefile]
+[{Makefile, go.mod, *.go}]
 indent_style = tab

.gitattributes

@@ -0,0 +1,9 @@
+# Text files have auto line endings
+* text=auto
+
+# Go source files always have LF line endings
+*.go text eol=lf
+
+# Disable next extensions in project "used languages" list
+*.lua linguist-detectable=false
+*.html linguist-detectable=false

.github/CODEOWNERS

@@ -0,0 +1,3 @@
+# @link <https://help.github.com/en/articles/about-code-owners>
+
+* @tarampampam

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,53 @@
+# Docs: <https://git.io/JR5E4>
+
+name: 🐞 Bug report
+description: File a bug/issue
+labels: ['type:bug']
+assignees: [tarampampam]
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an issue already exists for the bug you encountered
+      options:
+        - label: I have searched the existing issues
+          required: true
+        - label: And it has nothing to do with Traefik
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1. Start the container using command ...
+        2. Send an HTTP request using this curl command ...
+        3. See error
+
+  - type: textarea
+    id: configs
+    attributes:
+      label: Configuration files
+      description: Please copy and paste any relevant configuration files. This will be automatically formatted into code (yaml), so no need for backticks.
+      render: yaml
+      placeholder: Traefik, docker-compose, helm, etc.
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code (shell), so no need for backticks.
+      render: shell
+
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: Links? References? Anything that will give us more context about the issue you are encountering!
+      placeholder: You can attach images or log files by clicking this area to highlight it and then dragging files in

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,12 @@
+# Docs: <https://git.io/JP3tm>
+
+blank_issues_enabled: false
+
+contact_links:
+  - name: 🗣 Ask a Question, Discuss
+    url: https://github.com/tarampampam/error-pages/discussions
+    about: Feel free to ask anything
+
+  - name: 🌀 I have a question about Traefik..
+    url: https://community.traefik.io/
+    about: In this case - ask in the Traefik community

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,33 @@
+# Docs: <https://git.io/JR5E4>
+
+name: 💡 Feature request
+description: Suggest an idea for this project
+labels: ['type:feature_request']
+assignees: [tarampampam]
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an issue already exists for the bug you encountered
+      options:
+        - label: I have searched the existing issues
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Describe the problem to be solved
+      description: Please present a concise description of the problem to be addressed by this feature request
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Suggest a solution
+      description: A concise description of your preferred solution
+      placeholder: If there are multiple solutions, please present each one separately
+
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context about the feature request
+      placeholder: You can attach images or log files by clicking this area to highlight it and then dragging files in

.github/dependabot.yml

@@ -0,0 +1,19 @@
+# Docs: <https://docs.github.com/en/free-pro-team@latest/github/administering-a-repository/customizing-dependency-updates>
+
+version: 2
+
+updates:
+  - package-ecosystem: gomod
+    directory: /
+    schedule: {interval: monthly}
+    assignees: [tarampampam]
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule: {interval: monthly}
+    assignees: [tarampampam]
+
+  - package-ecosystem: docker
+    directory: /
+    schedule: {interval: monthly}
+    assignees: [tarampampam]

.github/renovate.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "github>tarampampam/.github//renovate/default",
+    ":rebaseStalePrs"
+  ]
+}

.github/workflows/dependabot.yml

@@ -0,0 +1,25 @@
+name: dependabot
+
+on:
+  pull_request: {}
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot: # https://tinyurl.com/e69djmen
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - uses: dependabot/fetch-metadata@v1
+        id: metadata
+        with: {github-token: "${{ secrets.GITHUB_TOKEN }}"}
+
+      - name: Enable auto-merge for Dependabot PRs
+        if: ${{ contains(fromJSON('["version-update:semver-minor", "version-update:semver-patch"]'), steps.metadata.outputs.update-type) }}
+        run: gh pr merge --auto --merge "$PR_URL"
+        continue-on-error: true
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/documentation.yml

@@ -0,0 +1,19 @@
+name: documentation
+
+on:
+  push:
+    branches: [master, main]
+    paths: ['README.md']
+
+jobs:
+  docker-hub-description:
+    name: Docker Hub Description
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: peter-evans/dockerhub-description@v4 # Action page: <https://github.com/peter-evans/dockerhub-description>
+        with:
+          username: ${{ secrets.DOCKER_LOGIN }}
+          password: ${{ secrets.DOCKER_USER_PASSWORD }}
+          repository: tarampampam/error-pages

.github/workflows/release.yml

@@ -5,80 +5,109 @@ on:
     types: [published]
 
 jobs:
-  demo:
-    name: Update demonstration, hosted on github pages
+  purge-cdn-cache:
+    name: Purge jsDelivr CDN cache
     runs-on: ubuntu-latest
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Setup NodeJS
-        uses: actions/setup-node@v1 # Action page: <https://github.com/actions/setup-node>
+      - uses: gacts/purge-jsdelivr-cache@v1 # Action page: <https://github.com/gacts/purge-jsdelivr-cache>
         with:
-          node-version: 12
+          url: |
+            https://cdn.jsdelivr.net/gh/tarampampam/error-pages@2/l10n/l10n.js
+            https://cdn.jsdelivr.net/gh/tarampampam/error-pages@2/l10n/l10n.min.js
+            https://cdn.jsdelivr.net/gh/tarampampam/error-pages@latest/l10n/l10n.js
+            https://cdn.jsdelivr.net/gh/tarampampam/error-pages@latest/l10n/l10n.min.js
 
-      - name: Generate version value
-        run: echo "::set-env name=PACKAGE_VERSION::${GITHUB_REF##*/v}"
+  build:
+    name: Build for ${{ matrix.os }} (${{ matrix.arch }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [linux, darwin] # linux, freebsd, darwin, windows
+        arch: [amd64]  # amd64, 386
+    steps:
+      - uses: actions/checkout@v4
 
-      - uses: actions/cache@v2
+      - uses: gacts/setup-go-with-cache@v1
+        with: {go-version-file: go.mod}
+
+      - {uses: gacts/github-slug@v1, id: slug}
+
+      - name: Generate builder values
+        id: values
+        run: echo "binary-name=error-pages-${{ matrix.os }}-${{ matrix.arch }}" >> $GITHUB_OUTPUT
+
+      - name: Build application
+        env:
+          GOOS: ${{ matrix.os }}
+          GOARCH: ${{ matrix.arch }}
+          CGO_ENABLED: 0
+          LDFLAGS: -s -w -X gh.tarampamp.am/error-pages/internal/version.version=${{ steps.slug.outputs.version }}
+        run: go build -trimpath -ldflags "$LDFLAGS" -o "./${{ steps.values.outputs.binary-name }}" ./cmd/error-pages/
+
+      - name: Upload binary file to release
+        uses: svenstaro/upload-release-action@v2
         with:
-          path: '**/node_modules'
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-
-      - name: Install dependencies
-        run: ./bin/generator.js -c ./configuration.json -o ./out
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: content
-          path: out/
-
-      - name: Switch to github pages branch
-        uses: actions/checkout@v2
-        with:
-          ref: gh-pages
-
-      - name: Download artifact
-        uses: actions/download-artifact@v2
-        with:
-          name: content
-
-      - name: Setup git
-        run: |
-          git config --global user.name "$GITHUB_ACTOR"
-          git config --global user.email 'actions@github.com'
-          git remote add github "https://$GITHUB_ACTOR:$GITHUB_TOKEN@github.com/$GITHUB_REPOSITORY.git"
-
-      - name: Stage changes
-        run: git add .
-
-      - name: Commit changes
-        run: git commit -m "Deploying ${GITHUB_SHA} to Github Pages"
-
-      - name: Push changes
-        run: git push github --force
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: ${{ steps.values.outputs.binary-name }}
+          asset_name: ${{ steps.values.outputs.binary-name }}
+          tag: ${{ github.ref }}
 
   docker-image:
     name: Build docker image
     runs-on: ubuntu-latest
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v4
+
+      - {uses: gacts/github-slug@v1, id: slug}
+
+      - uses: docker/setup-qemu-action@v3 # Action page: <https://github.com/docker/setup-qemu-action>
+
+      - uses: docker/setup-buildx-action@v3 # Action page: <https://github.com/docker/setup-buildx-action>
+
+      - uses: docker/login-action@v3 # Action page: <https://github.com/docker/login-action>
         with:
-          fetch-depth: 1
+          username: ${{ secrets.DOCKER_LOGIN }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
 
-      - name: Generate image tag value
-        run: echo "::set-env name=IMAGE_TAG::${GITHUB_REF##*/[vV]}" # `/refs/tags/v1.2.3` -> `1.2.3`
+      - uses: docker/login-action@v3 # Action page: <https://github.com/docker/login-action>
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Make docker login
-        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_LOGIN }}" --password-stdin &> /dev/null
+      - uses: docker/build-push-action@v5 # Action page: <https://github.com/docker/build-push-action>
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm64/v8
+          build-args: "APP_VERSION=${{ steps.slug.outputs.version }}"
+          tags: |
+            tarampampam/error-pages:${{ steps.slug.outputs.version }}
+            tarampampam/error-pages:${{ steps.slug.outputs.version-major }}.${{ steps.slug.outputs.version-minor }}
+            tarampampam/error-pages:${{ steps.slug.outputs.version-major }}
+            tarampampam/error-pages:latest
+            ghcr.io/${{ github.actor }}/${{ github.event.repository.name }}:${{ steps.slug.outputs.version }}
+            ghcr.io/${{ github.actor }}/${{ github.event.repository.name }}:${{ steps.slug.outputs.version-major }}.${{ steps.slug.outputs.version-minor }}
+            ghcr.io/${{ github.actor }}/${{ github.event.repository.name }}:${{ steps.slug.outputs.version-major }}
+            ghcr.io/${{ github.actor }}/${{ github.event.repository.name }}:latest
 
-      - name: Build image
-        run: docker build --tag "tarampampam/error-pages:${IMAGE_TAG}" --tag "tarampampam/error-pages:latest" -f ./Dockerfile .
+  demo:
+    name: Update the demonstration
+    runs-on: ubuntu-latest
+    needs: [docker-image]
+    steps:
+      - {uses: gacts/github-slug@v1, id: slug}
 
-      - name: Push version image
-        run: docker push "tarampampam/error-pages:${IMAGE_TAG}"
+      - name: Take rendered templates from the built docker image
+        run: |
+          docker create --name img ghcr.io/${{ github.actor }}/${{ github.event.repository.name }}:${{ steps.slug.outputs.version }}
+          docker cp img:/opt/html ./out
+          docker rm -f img
 
-      - name: Push latest image
-        run: docker push "tarampampam/error-pages:latest"
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./out

.github/workflows/tests.yml

@@ -2,51 +2,236 @@ name: tests
 
 on:
   push:
-    branches:
-      - master
-    tags-ignore:
-      - '**'
+    branches: [master, main]
+    tags-ignore: ['**']
+    paths-ignore: ['**.md']
   pull_request:
+    paths-ignore: ['**.md']
+
+concurrency:
+  group: ${{ github.ref }}
+  cancel-in-progress: true
 
 jobs: # Docs: <https://git.io/JvxXE>
-  generate:
-    name: Try to run generator
+  gitleaks:
+    name: Gitleaks
     runs-on: ubuntu-latest
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v4
+        with: {fetch-depth: 0}
 
-      - name: Setup NodeJS
-        uses: actions/setup-node@v1 # Action page: <https://github.com/actions/setup-node>
+      - name: Check for GitLeaks
+        uses: gacts/gitleaks@v1 # Action page: <https://github.com/gacts/gitleaks>
+
+  golangci-lint:
+    name: Golang-CI (lint)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: gacts/setup-go-with-cache@v1
+        with: {go-version-file: go.mod}
+
+      - uses: golangci/golangci-lint-action@v4
+        with: {skip-pkg-cache: true, skip-build-cache: true}
+
+  validate-config-file:
+    name: Validate config file
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: gacts/setup-node-with-cache@v1
+        with: {node-version: 16}
+
+      - name: Install linter
+        run: npm install -g ajv-cli # Package page: <https://www.npmjs.com/package/ajv-cli>
+
+      - name: Run linter
+        run: ajv validate --all-errors --verbose -s ./schemas/config/1.0.schema.json -d ./error-pages.y*ml
+
+  lint-l10n:
+    name: Lint l10n file(s)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: gacts/setup-node-with-cache@v1
+        with: {node-version: 16}
+
+      - name: Install eslint
+        run: npm install -g eslint@v8 # Package page: <https://www.npmjs.com/package/eslint>
+
+      - name: Run linter
+        working-directory: l10n
+        run: eslint ./*.js
+
+  go-test:
+    name: Unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: {fetch-depth: 2} # Fixes codecov error 'Issue detecting commit SHA'
+
+      - uses: gacts/setup-go-with-cache@v1
+        with: {go-version-file: go.mod}
+
+      - name: Run Unit tests
+        run: go test -race -covermode=atomic -coverprofile /tmp/coverage.txt ./...
+
+      - uses: codecov/codecov-action@v4 # https://github.com/codecov/codecov-action
+        continue-on-error: true
         with:
-          node-version: 12
+          file: /tmp/coverage.txt
+          token: ${{ secrets.CODECOV_TOKEN }}
 
-      - uses: actions/cache@v2
+  build:
+    name: Build for ${{ matrix.os }} (${{ matrix.arch }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [linux, darwin] # linux, freebsd, darwin, windows
+        arch: [amd64]  # amd64, 386
+    needs: [golangci-lint, go-test, validate-config-file]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: gacts/setup-go-with-cache@v1
+        with: {go-version-file: go.mod}
+
+      - {uses: gacts/github-slug@v1, id: slug}
+
+      - name: Build application
+        env:
+          GOOS: ${{ matrix.os }}
+          GOARCH: ${{ matrix.arch }}
+          CGO_ENABLED: 0
+          LDFLAGS: -s -w -X gh.tarampamp.am/error-pages/internal/version.version=${{ steps.slug.outputs.branch-name-slug }}@${{ steps.slug.outputs.commit-hash-short }}
+        run: go build -trimpath -ldflags "$LDFLAGS" -o ./error-pages ./cmd/error-pages/
+
+      - name: Try to execute
+        if: matrix.os == 'linux'
+        run: ./error-pages --version && ./error-pages -h
+
+      - uses: actions/upload-artifact@v4
         with:
-          path: '**/node_modules'
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          name: error-pages-${{ matrix.os }}-${{ matrix.arch }}
+          path: error-pages
+          if-no-files-found: error
+          retention-days: 1
 
-      - name: Install dependencies
-        run: yarn install
+  generate:
+    name: Run templates generator
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: error-pages-linux-amd64
+          path: .artifact
+
+      - name: Prepare binary file to run
+        working-directory: .artifact
+        run: mv ./error-pages ./../error-pages && chmod +x ./../error-pages
 
       - name: Run generator
-        run: ./bin/generator.js -c ./configuration.json -o ./out
+        run: ./error-pages --verbose build --index ./out
 
-      - name: Test file creation
-        run: test -f ./out/ghost/404.html
+      - name: Test files creation
+        run: |
+          test -f ./out/index.html
+          test -f ./out/ghost/404.html
+          test -f ./out/l7-dark/404.html
+          test -f ./out/l7-light/404.html
+          test -f ./out/shuffle/404.html
+          test -f ./out/noise/404.html
+          test -f ./out/hacker-terminal/404.html
+          test -f ./out/cats/404.html
+          test -f ./out/lost-in-space/404.html
+          test -f ./out/app-down/404.html
+          test -f ./out/connection/404.html
+          test -f ./out/matrix/404.html
+          test -f ./out/orient/404.html
 
-  docker-build:
+  docker-image:
     name: Build docker image
     runs-on: ubuntu-latest
+    needs: [golangci-lint, go-test, validate-config-file]
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-      - name: Build docker image
-        run: docker build -f ./Dockerfile --tag image:local .
+      - {uses: gacts/github-slug@v1, id: slug}
 
-      - name: Run docker image
-        run: docker run --rm -d -p "8080:8080" -e "TEMPLATE_NAME=ghost" image:local
+      - uses: docker/build-push-action@v5 # Action page: <https://github.com/docker/build-push-action>
+        with:
+          context: .
+          file: Dockerfile
+          push: false
+          build-args: "APP_VERSION=${{ steps.slug.outputs.branch-name-slug }}@${{ steps.slug.outputs.commit-hash-short }}"
+          tags: app:ci
 
-      - name: Send HTTP request
-        run: curl -sS --fail "http://127.0.0.1:8080/500.html"
+      - run: docker save app:ci > ./docker-image.tar
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: docker-image
+          path: ./docker-image.tar
+          retention-days: 1
+
+  scan-docker-image:
+    name: Scan the docker image
+    runs-on: ubuntu-latest
+    needs: [docker-image]
+    steps:
+      - uses: actions/checkout@v4 # is needed for `upload-sarif` action
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: docker-image
+          path: .artifact
+
+      - uses: aquasecurity/trivy-action@0.18.0 # action page: <https://github.com/aquasecurity/trivy-action>
+        with:
+          input: .artifact/docker-image.tar
+          format: sarif
+          severity: MEDIUM,HIGH,CRITICAL
+          exit-code: 1
+          output: trivy-results.sarif
+
+      - uses: github/codeql-action/upload-sarif@v3
+        if: always()
+        continue-on-error: true
+        with: {sarif_file: trivy-results.sarif}
+
+  poke-docker-image:
+    name: Run the docker image
+    runs-on: ubuntu-latest
+    needs: [docker-image]
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: docker-image
+          path: .artifact
+
+      - working-directory: .artifact
+        run: docker load < docker-image.tar
+
+      - uses: gacts/install-hurl@v1
+
+      - name: Run container with the app
+        run: docker run --rm -d -p "8080:8080/tcp" -e "SHOW_DETAILS=true" -e "PROXY_HTTP_HEADERS=X-Foo,Bar,Baz_blah" --name app app:ci
+
+      - name: Wait for container "healthy" state
+        run: until [[ "`docker inspect -f {{.State.Health.Status}} app`" == "healthy" ]]; do echo "wait 1 sec.."; sleep 1; done
+
+      - run: hurl --color --test --fail-at-end --variable host=127.0.0.1 --variable port=8080 ./test/hurl/*.hurl
+
+      - name: Stop the container
+        if: always()
+        run: docker kill app

.gitignore

@@ -1,18 +1,16 @@
 ## IDEs
-/.vscode
 /.idea
+/.vscode
 
-## Vendors
-/node_modules
-
-## Lock files (use yarn only)
-/package-lock.json
-
-## Dist
-/out
+## Binaries
+/error-pages
 
 ## Temp dirs & trash
-/npm-debug.log
-/yarn-error.log
+/temp
+/tmp
+*.env
 .DS_Store
-.env*
+*.cache
+*.out
+/out
+/cover*.*

.golangci.yml

@@ -0,0 +1,89 @@
+# Documentation: <https://github.com/golangci/golangci-lint#config-file>
+
+run:
+  timeout: 1m
+  skip-dirs:
+    - .github
+    - .git
+    - tmp
+    - temp
+  modules-download-mode: readonly
+  allow-parallel-runners: true
+
+output:
+  format: colored-line-number # colored-line-number|line-number|json|tab|checkstyle|code-climate
+
+linters-settings:
+  govet:
+    check-shadowing: true
+  gocyclo:
+    min-complexity: 15
+  godot:
+    scope: declarations
+    capital: true
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 2
+    min-occurrences: 3
+  misspell:
+    locale: US
+  lll:
+    line-length: 120
+  prealloc:
+    simple: true
+    range-loops: true
+    for-loops: true
+  nolintlint:
+    allow-leading-space: false
+    require-specific: true
+
+linters: # All available linters list: <https://golangci-lint.run/usage/linters/>
+  disable-all: true
+  enable:
+    - asciicheck # Simple linter to check that your code does not contain non-ASCII identifiers
+    - bidichk # Checks for dangerous unicode character sequences
+    - dogsled # Checks assignments with too many blank identifiers (e.g. x, _, _, _, := f())
+    - dupl # Tool for code clone detection
+    - errcheck # Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases
+    - errorlint # find code that will cause problems with the error wrapping scheme introduced in Go 1.13
+    - exhaustive # check exhaustiveness of enum switch statements
+    - exportloopref # checks for pointers to enclosing loop variables
+    - funlen # Tool for detection of long functions
+    - gochecknoglobals # Checks that no globals are present in Go code
+    - gochecknoinits # Checks that no init functions are present in Go code
+    - gocognit # Computes and checks the cognitive complexity of functions
+    - goconst # Finds repeated strings that could be replaced by a constant
+    - gocritic # The most opinionated Go source code linter
+    - gocyclo # Computes and checks the cyclomatic complexity of functions
+    - gofmt # Gofmt checks whether code was gofmt-ed. By default this tool runs with -s option to check for code simplification
+    - goimports # Goimports does everything that gofmt does. Additionally it checks unused imports
+    - gomnd # An analyzer to detect magic numbers
+    - goprintffuncname # Checks that printf-like functions are named with `f` at the end
+    - gosec # Inspects source code for security problems
+    - gosimple # Linter for Go source code that specializes in simplifying a code
+    - govet # Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
+    - ineffassign # Detects when assignments to existing variables are not used
+    - lll # Reports long lines
+    - misspell # Finds commonly misspelled English words in comments
+    - nakedret # Finds naked returns in functions greater than a specified function length
+    - nestif # Reports deeply nested if statements
+    - nlreturn # checks for a new line before return and branch statements to increase code clarity
+    - nolintlint # Reports ill-formed or insufficient nolint directives
+    - prealloc # Finds slice declarations that could potentially be preallocated
+    - staticcheck # Staticcheck is a go vet on steroids, applying a ton of static analysis checks
+    - stylecheck # Stylecheck is a replacement for golint
+    - typecheck # Like the front-end of a Go compiler, parses and type-checks Go code
+    - unconvert # Remove unnecessary type conversions
+    - unused # Checks Go code for unused constants, variables, functions and types
+    - whitespace # Tool for detection of leading and trailing whitespace
+    - wsl # Whitespace Linter - Forces you to use empty lines!
+
+issues:
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - dupl
+        - funlen
+        - scopelint
+        - gocognit

CHANGELOG.md

@@ -4,6 +4,452 @@ All notable changes to this package will be documented in this file.
 
 The format is based on [Keep a Changelog][keepachangelog] and this project adheres to [Semantic Versioning][semver].
 
+## v2.27.0
+
+### Changed
+
+- Go updated from `1.21` up to `1.22`
+- Go dependencies updated
+
+## v2.26.0
+
+### Added
+
+- Error pages now translated into 🇵🇱 [#226]
+- Possibility to set custom read buffer size (using `--read-buffer-size` flag or environment variable `READ_BUFFER_SIZE`) [#238], [#244]
+
+[#226]:https://github.com/tarampampam/error-pages/pull/226
+[#238]:https://github.com/tarampampam/error-pages/issues/238
+[#244]:https://github.com/tarampampam/error-pages/pull/244
+
+## v2.25.0
+
+### Added
+
+- Go updated from `1.20` up to `1.21`
+- Error pages now translated into 🇮🇩 [#218]
+- Possibility catch all paths with error page 404 (using `--catch-all` flag for the `serve` or environment variable `CATCH_ALL=true`) [#217]
+
+[#218]:https://github.com/tarampampam/error-pages/pull/218
+[#217]:https://github.com/tarampampam/error-pages/issues/217
+
+## v2.24.0
+
+### Added
+
+- Support for IPv6 addresses in the `--listen` flag [#191]
+
+[#191]:https://github.com/tarampampam/error-pages/issues/191
+
+## v2.23.0
+
+### Added
+
+- Template `orient` [#190]
+
+[#190]:https://github.com/tarampampam/error-pages/pull/190
+
+## v2.22.0
+
+### Changed
+
+- Non-existing pages now return styled `404` status page (with `404` status code) [#188]
+
+[#188]:https://github.com/tarampampam/error-pages/issues/188
+
+## v2.21.0
+
+### Changed
+
+- Go updated from `1.19` up to `1.20`
+- Go dependencies updated
+- Module name changed from `github.com/tarampampam/error-pages` to `gh.tarampamp.am/error-pages`
+
+## v2.20.0
+
+### Changed
+
+- `version` subcommand replaced by `--version` flag [#163]
+- `--config-file` flag is not global anymore (use `error-pages (serve|build) --config-file ...` instead of `error-pages --config-file ... (serve|build) ...`) [#163]
+- Flags `--verbose`, `--debug` and `--log-json` are deprecated, use `--log-level` and `--log-format` instead [#163]
+
+### Added
+
+- Possibility to use custom env variables in templates [#164], [#165]
+
+[#164]:https://github.com/tarampampam/error-pages/issues/164
+[#165]:https://github.com/tarampampam/error-pages/pull/165
+[#163]:https://github.com/tarampampam/error-pages/pull/163
+
+## v2.19.0
+
+### Changed
+
+- Go updated from `1.18` up to `1.19`
+
+### Added
+
+- Error pages now translated into Chinese 🇨🇳 [#147]
+
+[#147]:https://github.com/tarampampam/error-pages/pull/147
+
+## v2.18.0
+
+### Changed
+
+- Replaced `fonts.googleapis.com` by `fonts.bunny.net` regarding GDPR compliance [#131]
+
+[#131]:https://github.com/tarampampam/error-pages/pull/131
+
+## v2.17.0
+
+### Added
+
+- Error pages now translated into Spanish 🇪🇸 [#124]
+
+[#124]:https://github.com/tarampampam/error-pages/pull/124
+
+## v2.16.0
+
+### Added
+
+- Error pages are now translated into German 🇩🇪 [#115]
+
+[#115]:https://github.com/tarampampam/error-pages/pull/115
+
+## v2.15.0
+
+### Added
+
+- Error pages now translated into Dutch 🇳🇱 [#104]
+
+[#104]:https://github.com/tarampampam/error-pages/pull/104
+
+## v2.14.0
+
+### Added
+
+- Error pages now translated into Portuguese 🇵🇹 [#103]
+
+### Changed
+
+- Go updated from `1.18.0` up to `1.18.1`
+
+[#103]:https://github.com/tarampampam/error-pages/pull/103
+
+## v2.13.0
+
+### Added
+
+- Possibility to disable error pages auto-localization (using `--disable-l10n` flag for the `serve` & `build` commands or environment variable `DISABLE_L10N`) [#91]
+
+### Fixed
+
+- User UID/GID changed to the numeric values in the dockerfile [#92]
+
+[#92]:https://github.com/tarampampam/error-pages/issues/92
+[#91]:https://github.com/tarampampam/error-pages/issues/91
+
+## v2.12.1
+
+### Fixed
+
+- Fix translation 🇫🇷 [#86]
+
+[#85]:https://github.com/tarampampam/error-pages/pull/86
+
+## v2.12.0
+
+### Changed
+
+- Error pages now translated into 🇫🇷 [#82]
+
+[#82]:https://github.com/tarampampam/error-pages/pull/82
+
+## v2.11.0
+
+### Added
+
+- Template `matrix` [#81]
+
+### Fixed
+
+- Localization mistakes [#81]
+
+[#81]:https://github.com/tarampampam/error-pages/pull/81
+
+## v2.10.1
+
+### Fixed
+
+- Template `shuffle`
+- Localization mistakes
+
+## v2.10.0
+
+### Changed
+
+- Error pages now translated into 🇺🇦 and 🇷🇺 languages [#80]
+
+[#80]:https://github.com/tarampampam/error-pages/pull/80
+
+## v2.9.0
+
+### Added
+
+- Template `connection` [#79]
+
+[#79]:https://github.com/tarampampam/error-pages/pull/79
+
+## v2.8.1
+
+### Fixed
+
+- Dark mode for `app-down` template
+
+### Changed
+
+- The index page for built error pages now supports a dark theme
+
+## v2.8.0
+
+### Added
+
+- Template `app-down` [#74]
+
+### Changed
+
+- Go updated from `1.17.6` up to `1.18.0`
+
+[#74]:https://github.com/tarampampam/error-pages/pull/74
+
+## v2.7.0
+
+### Changed
+
+- Logs includes request/response headers now [#67]
+
+### Added
+
+- Possibility to proxy HTTP headers from the requests to the responses (can be enabled using `--proxy-headers` flag for the `serve` command or environment variable `PROXY_HTTP_HEADERS`, headers list should be comma-separated) [#67]
+- Template `lost-in-space` [#68]
+
+### Fixed
+
+- Template `l7-light` uses the dark colors in the browsers with the preferred dark theme
+
+[#67]:https://github.com/tarampampam/error-pages/pull/67
+[#68]:https://github.com/tarampampam/error-pages/pull/68
+
+## v2.6.0
+
+### Added
+
+- Possibility to change the template to the random once a day using "special" template name `random-daily` (or hourly, using `random-hourly`) [#48]
+
+[#48]:https://github.com/tarampampam/error-pages/issues/48
+
+## v2.5.0
+
+### Changed
+
+- Go updated from `1.17.5` up to `1.17.6`
+
+### Added
+
+- `Host` and `X-Forwarded-For` Header to error pages [#61]
+
+### Fixed
+
+- Performance issue, that affects template rendering. Now templates are cached in memory (for 2 seconds), and it has improved performance by more than 200% [#60]
+
+[#60]:https://github.com/tarampampam/error-pages/pull/60
+[#61]:https://github.com/tarampampam/error-pages/pull/61
+
+## v2.4.0
+
+### Changed
+
+- It is now possible to use [golang-tags of templates](https://pkg.go.dev/text/template) in error page templates and formatted (`json`, `xml`) responses [#49]
+- Health-check route become `/healthz` (instead `/health/live`, previous route marked as deprecated) [#49]
+
+### Added
+
+- The templates contain details block now (can be enabled using `--show-details` flag for the `serve` command or environment variable `SHOW_DETAILS=true`) [#49]
+- Formatted response templates (`json`, `xml`) - the server responds with a formatted response depending on the `Content-Type` (and `X-Format`) request header value [#49]
+- HTTP header `X-Robots-Tag: noindex` for the error pages [#49]
+- Possibility to pass the needed error page code using `X-Code` HTTP header [#49]
+- Possibility to integrate with [ingress-nginx](https://kubernetes.github.io/ingress-nginx/) [#49]
+- Metrics HTTP endpoint `/metrics` in prometheus format [#54]
+
+### Fixed
+
+- Potential race condition (in the `pick.StringsSlice` struct) [#49]
+
+[#54]:https://github.com/tarampampam/error-pages/pull/54
+[#49]:https://github.com/tarampampam/error-pages/pull/49
+
+## v2.3.0
+
+### Added
+
+- Flag `--default-http-code` for the `serve` subcommand (`404` is used by default instead of `200`, environment name `DEFAULT_HTTP_CODE`) [#41]
+
+### Changed
+
+- Go updated from `1.17.1` up to `1.17.5`
+
+[#41]:https://github.com/tarampampam/error-pages/issues/41
+
+## v2.2.0
+
+### Added
+
+- Template `cats` [#31]
+
+[#31]:https://github.com/tarampampam/error-pages/pull/31
+
+## v2.1.0
+
+### Added
+
+- `referer` field in access log records
+- Flag `--default-error-page` for the `serve` subcommand (`404` is used by default, environment name `DEFAULT_ERROR_PAGE`)
+
+### Changed
+
+- The source code has been refactored
+- The index page (`/`) now returns the error page with a code, declared using `--default-error-page` flag (HTTP code 200, when a page code exists)
+
+## v2.0.0
+
+### Changed
+
+- Application rewritten in Go
+
+## v1.8.0
+
+### Added
+
+- Nginx health-check endpoint (`/health/live`) and dockerfile `HEALTHCHECK` to utilise (thx [@modem7](https://github.com/modem7)) [#22], [#23]
+
+[#22]:https://github.com/tarampampam/error-pages/pull/22
+[#23]:https://github.com/tarampampam/error-pages/pull/23
+
+## v1.7.2
+
+### Changed
+
+- Nginx updated up to `1.21` (from `1.19`)
+
+## v1.7.1
+
+### Fixed
+
+- Random template selecting (thx [@xpliz](https://github.com/xpliz)) [#12]
+
+[#12]:https://github.com/tarampampam/error-pages/pull/12
+
+## v1.7.0
+
+### Added
+
+- Template `hacker-terminal` [#13]
+- HTML comments with error code and description into each template (header and footer, it seems more readable for curl usage)
+
+[#10]:https://github.com/tarampampam/error-pages/pull/13
+
+## v1.6.0
+
+### Added
+
+- Template `noise` [#10]
+
+### Fixed
+
+- File permissions in docker image
+
+[#10]:https://github.com/tarampampam/error-pages/issues/10
+
+## v1.5.0
+
+### Changed
+
+- Repository files structure
+- Nginx updated from `1.18` up to `1.19` in docker image
+- Docker image now uses default `nginx` entrypoint scripts and command
+
+### Added
+
+- Support for `linux/arm64/v8`, `linux/arm/v6` and `linux/arm/v7` platforms for docker image
+- Random template selecting (use `random` as a template name) for docker image
+
+## v1.4.0
+
+### Added
+
+- Template `shuffle` [#4]
+
+[#4]:https://github.com/tarampampam/error-pages/issues/4
+
+## v1.3.1
+
+### Fixed
+
+- `can't create directory '/opt/html/nginx-error-pages'` error [#3]
+
+[#3]:https://github.com/tarampampam/error-pages/issues/3
+
+## v1.3.0
+
+### Added
+
+- `418` status code error page
+- Set `server_tokens off;` in `nginx` server configuration
+
+## v1.2.0
+
+### Fixed
+
+- By default `nginx` in docker container returns 404 http code instead 200 when `/` requested
+
+### Changed
+
+- Default value for `TEMPLATE_NAME` is `ghost` now
+
+### Removed
+
+- Environment variable `DEFAULT_ERROR_CODE` support in docker image
+
+### Added
+
+- Templates `l7-light` and `l7-dark`
+
+## v1.1.0
+
+### Added
+
+- Environment variable `DEFAULT_ERROR_CODE` support in docker image
+
+## v1.0.1
+
+### Changed
+
+- Repository (not docker image) renamed from `error-pages-docker` to `error-pages`
+- `configuration.json` renamed to `config.json`
+- Makefile contains new targets (`install`, `gen`, `preview`)
+- Generator logging messages
+
+### Added
+
+- `docker-compose` for development
+
+### Fixed
+
+- Readme file content [#1]
+
+[#1]:https://github.com/tarampampam/error-pages/issues/1
+
 ## v1.0.0
 
 ### Changed

Dockerfile

@@ -1,22 +1,90 @@
-# Image page: <https://hub.docker.com/_/node>
-FROM node:12.16.2-alpine as builder
+# syntax=docker/dockerfile:1
+
+# this stage is used to build the application
+FROM docker.io/library/golang:1.22-bookworm AS builder
+
+COPY ./go.* /src/
+
+WORKDIR /src
+
+# burn the modules cache
+RUN go mod download
+
+# this stage is used to compile the application
+FROM builder AS compiler
+
+# can be passed with any prefix (like `v1.2.3@GITHASH`), e.g.: `docker build --build-arg "APP_VERSION=v1.2.3@GITHASH" .`
+ARG APP_VERSION="undefined@docker"
 
 WORKDIR /src
 
 COPY . .
 
+# arguments to pass on each go tool link invocation
+ENV LDFLAGS="-s -w -X gh.tarampamp.am/error-pages/internal/version.version=$APP_VERSION"
+
+# build the application
 RUN set -x \
-    && yarn install --frozen-lockfile \
-    && ./bin/generator.js -c ./configuration.json -o ./out
+    && CGO_ENABLED=0 go build -trimpath -ldflags "$LDFLAGS" -o ./error-pages ./cmd/error-pages/ \
+    && ./error-pages --version \
+    && ./error-pages -h
 
-# Image page: <https://hub.docker.com/_/nginx>
-FROM nginx:1.18-alpine
+WORKDIR /tmp/rootfs
 
-COPY --from=builder --chown=nginx /src/docker/docker-entrypoint.sh /docker-entrypoint.sh
-COPY --from=builder --chown=nginx /src/docker/nginx-server.conf /etc/nginx/conf.d/default.conf
-COPY --from=builder --chown=nginx /src/static /opt/html
-COPY --from=builder --chown=nginx /src/out /opt/html
+# prepare rootfs for runtime
+RUN set -x \
+    && mkdir -p \
+        ./etc \
+        ./bin \
+        ./opt/html \
+    && echo 'appuser:x:10001:10001::/nonexistent:/sbin/nologin' > ./etc/passwd \
+    && echo 'appuser:x:10001:' > ./etc/group \
+    && mv /src/error-pages ./bin/error-pages \
+    && mv /src/templates ./opt/templates \
+    && rm ./opt/templates/*.md \
+    && mv /src/error-pages.yml ./opt/error-pages.yml
 
-ENTRYPOINT ["/docker-entrypoint.sh"]
+WORKDIR /tmp/rootfs/opt
 
-CMD ["nginx", "-g", "daemon off;"]
+# generate static error pages (for usage inside another docker images, for example)
+RUN set -x \
+    && ./../bin/error-pages --verbose build --config-file ./error-pages.yml --index ./html \
+    && ls -l ./html
+
+# use empty filesystem
+FROM scratch AS runtime
+
+ARG APP_VERSION="undefined@docker"
+
+LABEL \
+    # Docs: <https://github.com/opencontainers/image-spec/blob/master/annotations.md>
+    org.opencontainers.image.title="error-pages" \
+    org.opencontainers.image.description="Static server error pages in the docker image" \
+    org.opencontainers.image.url="https://github.com/tarampampam/error-pages" \
+    org.opencontainers.image.source="https://github.com/tarampampam/error-pages" \
+    org.opencontainers.image.vendor="tarampampam" \
+    org.opencontainers.version="$APP_VERSION" \
+    org.opencontainers.image.licenses="MIT"
+
+# Import from builder
+COPY --from=compiler /tmp/rootfs /
+
+# Use an unprivileged user
+USER 10001:10001
+
+WORKDIR /opt
+
+ENV LISTEN_PORT="8080" \
+    TEMPLATE_NAME="ghost" \
+    DEFAULT_ERROR_PAGE="404" \
+    DEFAULT_HTTP_CODE="404" \
+    SHOW_DETAILS="false" \
+    DISABLE_L10N="false" \
+    READ_BUFFER_SIZE="2048"
+
+# Docs: <https://docs.docker.com/engine/reference/builder/#healthcheck>
+HEALTHCHECK --interval=7s --timeout=2s CMD ["/bin/error-pages", "--log-json", "healthcheck"]
+
+ENTRYPOINT ["/bin/error-pages"]
+
+CMD ["--log-json", "serve"]

Makefile

@@ -3,19 +3,62 @@
 # Makefile readme (en): <https://www.gnu.org/software/make/manual/html_node/index.html#SEC_Contents>
 
 SHELL = /bin/sh
+LDFLAGS = "-s -w -X gh.tarampamp.am/error-pages/internal/version.version=$(shell git rev-parse HEAD)"
 
-DOCKER_BIN = $(shell command -v docker 2> /dev/null)
+DC_RUN_ARGS = --rm --user "$(shell id -u):$(shell id -g)"
 APP_NAME = $(notdir $(CURDIR))
 
+.PHONY : help \
+         image dive build fmt lint gotest int-test test shell \
+         up down restart \
+         clean
 .DEFAULT_GOAL : help
+.SILENT : lint gotest
 
+# This will output the help for each task. thanks to https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
 help: ## Show this help
 	@printf "\033[33m%s:\033[0m\n" 'Available commands'
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  \033[32m%-15s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  \033[32m%-11s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
 
-image: ## Build docker image
-	$(DOCKER_BIN) build -f ./Dockerfile -t $(APP_NAME):local .
-	@printf "\n   \e[30;42m %s \033[0m\n\n" 'Now you can use image like `docker run --rm -p 8080:8080 $(APP_NAME):local ...`'
+image: ## Build docker image with app
+	docker build -f ./Dockerfile -t $(APP_NAME):local .
+	docker run --rm $(APP_NAME):local version
+	@printf "\n   \e[30;42m %s \033[0m\n\n" 'Now you can use image like `docker run --rm -p "8080:8080/tcp" $(APP_NAME):local ...`';
 
-shell: ## Start shell into container with node
-	$(DOCKER_BIN) run --rm -ti -v "$(shell pwd):/src:rw" -w "/src" --user "$(shell id -u):$(shell id -g)" node:12.16.2-alpine sh
+dive: image ## Explore the docker image
+	docker run --rm -it -v "/var/run/docker.sock:/var/run/docker.sock:ro" wagoodman/dive:latest $(APP_NAME):local
+
+build: ## Build app binary file
+	docker-compose run $(DC_RUN_ARGS) -e "CGO_ENABLED=0" --no-deps app go build -trimpath -ldflags $(LDFLAGS) -o ./error-pages ./cmd/error-pages/
+
+fmt: ## Run source code formatter tools
+	docker-compose run $(DC_RUN_ARGS) -e "GO111MODULE=off" --no-deps app sh -c 'go get golang.org/x/tools/cmd/goimports && $$GOPATH/bin/goimports -d -w .'
+	docker-compose run $(DC_RUN_ARGS) --no-deps app gofmt -s -w -d .
+	docker-compose run $(DC_RUN_ARGS) --no-deps app go mod tidy
+
+lint: ## Run app linters
+	docker-compose run --rm --no-deps golint golangci-lint run
+
+gotest: ## Run app tests
+	docker-compose run $(DC_RUN_ARGS) --no-deps app go test -v -race -timeout 10s ./...
+
+int-test: ## Run integration tests (docs: https://hurl.dev/docs/man-page.html#options)
+	docker-compose run --rm hurl --color --test --fail-at-end --variable host=web --variable port=8080 ./test/hurl/*.hurl
+
+test: lint gotest int-test ## Run app tests and linters
+
+shell: ## Start shell into container with golang
+	docker-compose run $(DC_RUN_ARGS) app bash
+
+up: ## Create and start containers
+	docker-compose up --detach web
+	@printf "\n   \e[30;42m %s \033[0m\n\n" 'Navigate your browser to ⇒ http://127.0.0.1:8080';
+
+down: ## Stop all services
+	docker-compose down -t 5
+
+restart: down up ## Restart all containers
+
+clean: ## Make clean
+	docker-compose down -v -t 1
+	-docker rmi $(APP_NAME):local -f

README.md

@@ -1,97 +1,205 @@
 <p align="center">
-  <img src="https://hsto.org/webt/rg/ys/c3/rgysc33oc7jiufdzmwrkohpmef8.png" width="94" alt="" />
+  <a href="https://github.com/tarampampam/error-pages#readme"><img src="https://socialify.git.ci/tarampampam/error-pages/image?description=1&font=Raleway&forks=1&issues=1&logo=https%3A%2F%2Fhsto.org%2Fwebt%2Frm%2F9y%2Fww%2Frm9ywwx3gjv9agwkcmllhsuyo7k.png&owner=1&pulls=1&pattern=Solid&stargazers=1&theme=Dark" alt="banner" width="100%" /></a>
 </p>
 
-# Static error pages in a Docker container
+<p align="center">
+  <a href="#"><img src="https://img.shields.io/github/go-mod/go-version/tarampampam/error-pages?longCache=true&label=&logo=go&logoColor=white&style=flat-square" alt="" /></a>
+  <a href="https://codecov.io/gh/tarampampam/error-pages"><img src="https://img.shields.io/codecov/c/github/tarampampam/error-pages/master.svg?maxAge=30&label=&logo=codecov&logoColor=white&style=flat-square" alt="" /></a>
+  <a href="https://github.com/tarampampam/error-pages/actions"><img src="https://img.shields.io/github/actions/workflow/status/tarampampam/error-pages/tests.yml?branch=master&maxAge=30&label=tests&logo=github&style=flat-square" alt="" /></a>
+  <a href="https://github.com/tarampampam/error-pages/actions"><img src="https://img.shields.io/github/actions/workflow/status/tarampampam/error-pages/release.yml?maxAge=30&label=release&logo=github&style=flat-square" alt="" /></a>
+  <a href="https://hub.docker.com/r/tarampampam/error-pages"><img src="https://img.shields.io/docker/pulls/tarampampam/error-pages.svg?maxAge=30&label=pulls&logo=docker&logoColor=white&style=flat-square" alt="" /></a>
+  <a href="https://hub.docker.com/r/tarampampam/error-pages"><img src="https://img.shields.io/docker/image-size/tarampampam/error-pages/latest?maxAge=30&label=size&logo=docker&logoColor=white&style=flat-square" alt="" /></a>
+  <a href="https://github.com/tarampampam/error-pages/blob/master/LICENSE"><img src="https://img.shields.io/github/license/tarampampam/error-pages.svg?maxAge=30&style=flat-square" alt="" /></a>
+</p>
 
-[![Build Status][badge_build_status]][link_build_status]
-[![License][badge_license]][link_license]
+<p align="center"><sup>
+  22 feb. 2022 - ⚡ Our Docker image was downloaded <strong>one MILLION times</strong> from the docker hub! ⚡<br/>
+  10 apr. 2023 - ⚡ <strong>Two million times</strong> from the docker hub and <strong>one million</strong> from the ghcr! ⚡
+</sup></p>
 
-This repository contains a very simple generator for server error pages _(like `404: Not found`)_ and ready docker image with web server for error pages serving.
+One day you may want to replace the standard error pages of your HTTP server with something more original and pretty. That's what this repository was created for :) It contains:
 
-Generator ([`bin/generator.js`](./bin/generator.js)) allows you:
+- Simple error pages generator, written in Go
+- Single-page error page templates with different designs (located in the [templates](https://github.com/tarampampam/error-pages/tree/master/templates) directory)
+- Fast and lightweight HTTP server
+- Already generated error pages (sources can be [found here][preview-sources], the **demonstration** is always accessible [here][preview-demo])
 
-- Use different templates (section `templates` in configuration file)
-- Generate pages with arbitrary content according to a specific template
+## 🔥 Features list
 
-Can be used for [Traefik error pages customization](https://docs.traefik.io/middlewares/errorpages/).
+- HTTP server written in Go, with the extremely fast [FastHTTP][fasthttp] under the hood
+  - Respects the `Content-Type` HTTP header (and `X-Format`) value and responds with the corresponding format (supported formats are `json` and `xml`)
+  - Writes logs in `json` format
+  - Contains healthcheck endpoint (`/healthz`)
+  - Contains metrics endpoint (`/metrics`) in Prometheus format
+- Lightweight docker image _(~4.6Mb compressed size)_, distroless and uses the unleveled user by default
+- [Go-template](https://pkg.go.dev/text/template) tags are allowed in the templates
+- Ready for integration with [Traefik][traefik] ([error pages customization](https://doc.traefik.io/traefik/middlewares/http/errorpages/)) and [Ingress-nginx][ingress-nginx]
+- Error pages can be [embedded into your own `nginx`][wiki-usage-with-nginx] docker image
+- Fully configurable (take a look at the [configuration file](https://github.com/tarampampam/error-pages/blob/master/error-pages.yml) and [project Wiki][wiki])
+- Distributed using docker image and compiled binary files
+- Localized (🇺🇸, 🇫🇷, 🇺🇦, 🇷🇺, 🇵🇹, 🇳🇱, 🇩🇪, 🇪🇸, 🇨🇳, 🇮🇩, 🇵🇱) HTML error pages (translation process [described here](https://github.com/tarampampam/error-pages/tree/master/l10n) - other translations are welcome!)
 
-### Usage
+## 🧩 Install
 
-Just execute (installed `nodejs` is required):
+Download the latest binary file for your os/arch from the [releases page][releases] or use our docker image:
 
-```bash
-$ bin/generator.js -c ./configuration.json -o ./out
+| Registry                          | Image                             |
+|-----------------------------------|-----------------------------------|
+| [Docker Hub][docker-hub]          | `tarampampam/error-pages`         |
+| [GitHub Container Registry][ghcr] | `ghcr.io/tarampampam/error-pages` |
+
+> Using the `latest` tag for the docker image is highly discouraged because of possible backward-incompatible changes during **major** upgrades. Please, use tags in `X.Y.Z` format
+
+💣 **Or** you can download **already rendered** error pages pack as a [zip][pages-pack-zip] or [tar.gz][pages-pack-tar-gz] archive.
+
+[pages-pack-zip]:https://github.com/tarampampam/error-pages/zipball/gh-pages/
+[pages-pack-tar-gz]:https://github.com/tarampampam/error-pages/tarball/gh-pages/
+
+## 🛠 Usage
+
+Please, take a look at [our Wiki][wiki] for the common usage stories:
+
+- [HTTP server][wiki-http-server] (routes, formats, flags and environment variables)
+- [Pages generator][wiki-generator] (build your own error page set)
+- [Static error pages][wiki-static-error-pages] (extract generated static error pages from the docker image)
+- [Usage with nginx][wiki-usage-with-nginx] (include our error pages into an image with nginx)
+- [Usage with Traefik and local Docker Compose][wiki-traefik-docker-compose] (it's a good starting point for the tests)
+- [Usage with Traefik and Docker Swarm][wiki-traefik-swarm]
+- [Kubernetes & ingress nginx][wiki-k8s-ingress-nginx]
+
+[wiki]:https://github.com/tarampampam/error-pages/wiki
+[wiki-http-server]:https://github.com/tarampampam/error-pages/wiki/HTTP-server
+[wiki-generator]:https://github.com/tarampampam/error-pages/wiki/Generator
+[wiki-static-error-pages]:https://github.com/tarampampam/error-pages/wiki/Static-error-pages
+[wiki-usage-with-nginx]:https://github.com/tarampampam/error-pages/wiki/Usage-with-nginx
+[wiki-traefik-swarm]:https://github.com/tarampampam/error-pages/wiki/Traefik-(docker-swarm)
+[wiki-traefik-docker-compose]:https://github.com/tarampampam/error-pages/wiki/Traefik-(docker-compose)
+[wiki-k8s-ingress-nginx]:https://github.com/tarampampam/error-pages/wiki/Kubernetes-&-ingress-nginx
+
+## 🦾 Performance
+
+Used hardware:
+
+- Intel® Core™ i7-10510U CPU @ 1.80GHz × 8
+- 16 GiB RAM
+
+```shell
+$ ulimit -aH | grep file
+-f: file size (blocks)              unlimited
+-c: core file size (blocks)         unlimited
+-n: file descriptors                1048576
+-x: file locks                      unlimited
+
+$ docker run --rm -p "8080:8080/tcp" -e "SHOW_DETAILS=true" error-pages:local # in separate terminal
+
+$ wrk --timeout 1s -t12 -c400 -d30s -s ./test/wrk/request.lua http://127.0.0.1:8080/
+Running 30s test @ http://127.0.0.1:8080/
+  12 threads and 400 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency    10.84ms    7.89ms 135.91ms   79.36%
+    Req/Sec     3.23k   785.11     6.30k    70.04%
+  1160567 requests in 30.10s, 4.12GB read
+Requests/sec:  38552.04
+Transfer/sec:    140.23MB
 ```
 
-And watch into `./out` directory:
+<details>
+  <summary>FS & memory usage stats during the test</summary>
 
-```text
-./out
-└── ghost
-    ├── 400.html
-    ├── 401.html
-    ├── 403.html
-    ├── 404.html
-    ├── ...
-    └── 505.html
-```
+  <p align="center">
+    <img src="https://hsto.org/webt/ts/w-/lz/tsw-lznvru0ngjneiimkwq7ysyc.png" alt="" />
+  </p>
+</details>
 
-Default configuration can be found in [`configuration.json`](./configuration.json) file.
+## 🪂 Templates
 
-### Docker
+|       Name        |                              Preview                               |
+|:-----------------:|:------------------------------------------------------------------:|
+|      `ghost`      |                [![ghost][ghost-screen]][ghost-link]                |
+|    `l7-light`     |           [![l7-light][l7-light-screen]][l7-light-link]            |
+|     `l7-dark`     |             [![l7-dark][l7-dark-screen]][l7-dark-link]             |
+|     `shuffle`     |             [![shuffle][shuffle-screen]][shuffle-link]             |
+|      `noise`      |                [![noise][noise-screen]][noise-link]                |
+| `hacker-terminal` | [![hacker-terminal][hacker-terminal-screen]][hacker-terminal-link] |
+|      `cats`       |                 [![cats][cats-screen]][cats-link]                  |
+|  `lost-in-space`  |    [![lost-in-space][lost-in-space-screen]][lost-in-space-link]    |
+|    `app-down`     |           [![app-down][app-down-screen]][app-down-link]            |
+|   `connection`    |        [![connection][connection-screen]][connection-link]         |
+|     `matrix`      |              [![matrix][matrix-screen]][matrix-link]               |
+|     `orient`      |              [![orient][orient-screen]][orient-link]               |
 
-[![Image size][badge_size_latest]][link_docker_build]
+> Note: `noise` template highly uses the CPU, be careful
 
-Start image (`nginx` inside):
+[ghost-screen]:https://hsto.org/webt/oj/cl/4k/ojcl4ko_cvusy5xuki6efffzsyo.gif
+[ghost-link]:https://tarampampam.github.io/error-pages/ghost/404.html
+[l7-light-screen]:https://hsto.org/webt/hx/ca/mm/hxcammfm7qjmogtvsjxcidgf7c8.png
+[l7-light-link]:https://tarampampam.github.io/error-pages/l7-light/404.html
+[l7-dark-screen]:https://hsto.org/webt/s1/ih/yr/s1ihyrqs_y-sgraoimfhk6ypney.png
+[l7-dark-link]:https://tarampampam.github.io/error-pages/l7-dark/404.html
+[shuffle-screen]:https://hsto.org/webt/7w/rk/3m/7wrk3mrzz3y8qfqwovmuvacu-bs.gif
+[shuffle-link]:https://tarampampam.github.io/error-pages/shuffle/404.html
+[noise-screen]:https://hsto.org/webt/42/oq/8y/42oq8yok_i-arrafjt6hds_7ahy.gif
+[noise-link]:https://tarampampam.github.io/error-pages/noise/404.html
+[hacker-terminal-screen]:https://hsto.org/webt/5s/l0/p1/5sl0p1_ud_nalzjzsj5slz6dfda.gif
+[hacker-terminal-link]:https://tarampampam.github.io/error-pages/hacker-terminal/404.html
+[cats-screen]:https://hsto.org/webt/_g/y-/ke/_gy-keqinz-3867jbw36v37-iwe.jpeg
+[cats-link]:https://tarampampam.github.io/error-pages/cats/404.html
+[lost-in-space-screen]:https://hsto.org/webt/lf/ln/x8/lflnx8fuy4rofxju34ttskijdsu.gif
+[lost-in-space-link]:https://tarampampam.github.io/error-pages/lost-in-space/404.html
+[app-down-screen]:https://habrastorage.org/webt/j2/la/fj/j2lafjvu_xjflzrvhiixobxy_ca.png
+[app-down-link]:https://tarampampam.github.io/error-pages/app-down/404.html
+[connection-screen]:https://hsto.org/webt/x4/ah/jb/x4ahjboo4-arm3bxpaash_sflmw.png
+[connection-link]:https://tarampampam.github.io/error-pages/connection/404.html
+[matrix-screen]:https://hsto.org/webt/ng/tf/oi/ngtfoiolvmq6hf15kimcxmhprhk.gif
+[matrix-link]:https://tarampampam.github.io/error-pages/matrix/404.html
+[orient-screen]:https://hsto.org/webt/pz/eu/v_/pzeuv_lyeqr0xpusa4zfrtgk7sa.png
+[orient-link]:https://tarampampam.github.io/error-pages/orient/404.html
 
-```bash
-$ docker run --rm -p "8080:8080" tarampampam/error-pages:1.0.0
-```
+## 🦾 Contributors
 
-And open in your browser `http://127.0.0.1:8080/ghost/400.html`. Additionally, you can set "default" pages theme by passing `TEMPLATE_NAME` environment variable (eg.: `-e "TEMPLATE_NAME=ghost"`) - in this case all error pages will be accessible in root directory (eg.: `http://127.0.0.1:8080/400.html`).
+I want to say a big thank you to everyone who contributed to this project:
 
-Also you can use generated error pages in your own docker images:
+[![contributors](https://contrib.rocks/image?repo=tarampampam/error-pages)][contributors]
 
-```dockerfile
-FROM nginx:1.18-alpine
+[contributors]:https://github.com/tarampampam/error-pages/graphs/contributors
 
-COPY --from=tarampampam/error-pages:1.0.0 /opt/html/ghost /usr/share/nginx/html/error-pages
-```
+## 📰 Changes log
 
-> [`error_page` for `nginx` configuration](http://nginx.org/en/docs/http/ngx_http_core_module.html#error_page)
+[![Release date][badge-release-date]][releases]
+[![Commits since latest release][badge-commits]][commits]
 
-## Changes log
+Changes log can be [found here][changelog].
 
-[![Release date][badge_release_date]][link_releases]
-[![Commits since latest release][badge_commits_since_release]][link_commits]
+## 👾 Support
 
-Changes log can be [found here][link_changes_log].
+[![Issues][badge-issues]][issues]
+[![Issues][badge-prs]][prs]
 
-## Support
+If you find any bugs in the project, please [create an issue][new-issue] in the current repository.
 
-[![Issues][badge_issues]][link_issues]
-[![Issues][badge_pulls]][link_pulls]
+## 📖 License
 
-If you will find any package errors, please, [make an issue][link_create_issue] in current repository.
+This is open-sourced software licensed under the [MIT License][license].
 
-## License
+[badge-release]:https://img.shields.io/github/release/tarampampam/error-pages.svg?maxAge=30
+[badge-release-date]:https://img.shields.io/github/release-date/tarampampam/error-pages.svg?maxAge=180
+[badge-commits]:https://img.shields.io/github/commits-since/tarampampam/error-pages/latest.svg?maxAge=45
+[badge-issues]:https://img.shields.io/github/issues/tarampampam/error-pages.svg?maxAge=45
+[badge-prs]:https://img.shields.io/github/issues-pr/tarampampam/error-pages.svg?maxAge=45
 
-This is open-sourced software licensed under the [MIT License][link_license].
+[docker-hub]:https://hub.docker.com/r/tarampampam/error-pages
+[docker-hub-tags]:https://hub.docker.com/r/tarampampam/error-pages/tags
+[license]:https://github.com/tarampampam/error-pages/blob/master/LICENSE
+[releases]:https://github.com/tarampampam/error-pages/releases
+[commits]:https://github.com/tarampampam/error-pages/commits
+[changelog]:https://github.com/tarampampam/error-pages/blob/master/CHANGELOG.md
+[issues]:https://github.com/tarampampam/error-pages/issues
+[new-issue]:https://github.com/tarampampam/error-pages/issues/new/choose
+[prs]:https://github.com/tarampampam/error-pages/pulls
+[ghcr]:https://github.com/users/tarampampam/packages/container/package/error-pages
 
-[badge_build_status]:https://img.shields.io/github/workflow/status/tarampampam/error-pages-docker/tests/master
-[badge_release_date]:https://img.shields.io/github/release-date/tarampampam/error-pages-docker.svg?style=flat-square&maxAge=180
-[badge_commits_since_release]:https://img.shields.io/github/commits-since/tarampampam/error-pages-docker/latest.svg?style=flat-square&maxAge=180
-[badge_issues]:https://img.shields.io/github/issues/tarampampam/error-pages-docker.svg?style=flat-square&maxAge=180
-[badge_pulls]:https://img.shields.io/github/issues-pr/tarampampam/error-pages-docker.svg?style=flat-square&maxAge=180
-[badge_license]:https://img.shields.io/github/license/tarampampam/error-pages-docker.svg?longCache=true
-[badge_size_latest]:https://img.shields.io/docker/image-size/tarampampam/error-pages/latest?maxAge=30
-[link_releases]:https://github.com/tarampampam/error-pages-docker/releases
-[link_commits]:https://github.com/tarampampam/error-pages-docker/commits
-[link_changes_log]:https://github.com/tarampampam/error-pages-docker/blob/master/CHANGELOG.md
-[link_issues]:https://github.com/tarampampam/error-pages-docker/issues
-[link_pulls]:https://github.com/tarampampam/error-pages-docker/pulls
-[link_build_status]:https://travis-ci.org/tarampampam/error-pages-docker
-[link_create_issue]:https://github.com/tarampampam/error-pages-docker/issues/new
-[link_license]:https://github.com/tarampampam/error-pages-docker/blob/master/LICENSE
-[link_docker_build]:https://hub.docker.com/r/tarampampam/error-pages/
+[fasthttp]:https://github.com/valyala/fasthttp
+[preview-sources]:https://github.com/tarampampam/error-pages/tree/gh-pages
+[preview-demo]:https://tarampampam.github.io/error-pages/
+[traefik]:https://github.com/traefik/traefik
+[ingress-nginx]:https://github.com/kubernetes/ingress-nginx/tree/main/charts/ingress-nginx

bin/generator.js

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const yargs = require('yargs');
-
-const options = yargs
-    .usage('Usage: -c <config.json> -d <output-directory>')
-    .option("c", {alias: "config", describe: "config file path", type: "string", demandOption: true})
-    .option("o", {alias: "out", describe: "output directory path", type: "string", demandOption: true})
-    .argv;
-
-const configFile = options.config;
-const outDir = options.out;
-
-try {
-    // Make sure that config file exists
-    if (! fs.existsSync(configFile)) {
-        throw new Error(`Config file "${configFile}" was not found`);
-    }
-
-    // Create output directory (if needed)
-    if (!fs.existsSync(outDir)){
-        fs.mkdirSync(outDir);
-    }
-
-    // Read JSON config file and parse into object
-    const configContent = JSON.parse(fs.readFileSync(configFile));
-
-    // Loop over all defined templates in configuration file
-    configContent.templates.forEach((templateConfig) => {
-        // Make sure that template layout file exists
-        if (! fs.existsSync(templateConfig.path)) {
-            throw new Error(`Template "${templateConfig.name}" was not found in "${templateConfig.path}"`);
-        }
-
-        // Read layout content into memory prepare output directory for template
-        const layoutContent = String(fs.readFileSync(templateConfig.path));
-        const templateOutDir = path.join(outDir, templateConfig.name);
-
-        if (!fs.existsSync(templateOutDir)){
-            fs.mkdirSync(templateOutDir);
-        }
-
-        console.info(`Use template "${templateConfig.name}" located in "${templateConfig.path}"`);
-
-        // Loop over all pages
-        configContent.pages.forEach((pageConfig) => {
-            console.info(`Page with code ${pageConfig.code} generation...`);
-
-            // Make replaces
-            let result = layoutContent
-                .replace(/{{\s?code\s?}}/g, pageConfig.code)
-                .replace(/{{\s?message\s?}}/g, pageConfig.message)
-                .replace(/{{\s?description\s?}}/g, pageConfig.description);
-
-            // And write into result file
-            fs.writeFileSync(path.join(templateOutDir, `${pageConfig.code}.${configContent.output.file_extension}`), result, {
-                encoding: "utf8",
-                flag: "w+",
-                mode: 0o644
-            })
-        });
-    })
-} catch (err) {
-    console.error(err);
-
-    process.exit(1);
-}

cmd/error-pages/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/fatih/color"
+	"go.uber.org/automaxprocs/maxprocs"
+
+	"gh.tarampamp.am/error-pages/internal/cli"
+)
+
+// set GOMAXPROCS to match Linux container CPU quota.
+var _, _ = maxprocs.Set(maxprocs.Min(1), maxprocs.Logger(func(_ string, _ ...any) {}))
+
+// exitFn is a function for application exiting.
+var exitFn = os.Exit //nolint:gochecknoglobals
+
+// main CLI application entrypoint.
+func main() { exitFn(run()) }
+
+// run this CLI application.
+// Exit codes documentation: <https://tldp.org/LDP/abs/html/exitcodes.html>
+func run() int {
+	if err := (cli.NewApp(filepath.Base(os.Args[0]))).Run(os.Args); err != nil {
+		_, _ = color.New(color.FgHiRed, color.Bold).Fprintln(os.Stderr, err.Error())
+
+		return 1
+	}
+
+	return 0
+}

cmd/error-pages/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_MainHelp(t *testing.T) {
+	os.Args = []string{"", "--help"}
+	exitFn = func(code int) { require.Equal(t, 0, code) }
+
+	output := capturer.CaptureStdout(main)
+
+	assert.Contains(t, output, "USAGE:")
+	assert.Contains(t, output, "COMMANDS:")
+	assert.Contains(t, output, "GLOBAL OPTIONS:")
+}

configuration.json

@@ -1,108 +0,0 @@
-{
-    "templates": [
-        {
-            "name": "ghost",
-            "path": "./templates/ghost.html"
-        }
-    ],
-    "output": {
-        "file_extension": "html"
-    },
-    "pages": [
-        {
-            "code": 400,
-            "message": "Bad Request",
-            "description": "The server did not understand the request"
-        },
-        {
-            "code": 401,
-            "message": "Unauthorized",
-            "description": "The requested page needs a username and a password"
-        },
-        {
-            "code": 403,
-            "message": "Forbidden",
-            "description": "Access is forbidden to the requested page"
-        },
-        {
-            "code": 404,
-            "message": "Not Found",
-            "description": "The server can not find the requested page"
-        },
-        {
-            "code": 405,
-            "message": "Method Not Allowed",
-            "description": "The method specified in the request is not allowed"
-        },
-        {
-            "code": 407,
-            "message": "Proxy Authentication Required",
-            "description": "You must authenticate with a proxy server before this request can be served"
-        },
-        {
-            "code": 408,
-            "message": "Request Timeout",
-            "description": "The request took longer than the server was prepared to wait"
-        },
-        {
-            "code": 409,
-            "message": "Conflict",
-            "description": "The request could not be completed because of a conflict"
-        },
-        {
-            "code": 410,
-            "message": "Gone",
-            "description": "The requested page is no longer available"
-        },
-        {
-            "code": 411,
-            "message": "Length Required",
-            "description": "The \"Content-Length\" is not defined. The server will not accept the request without it"
-        },
-        {
-            "code": 412,
-            "message": "Precondition Failed",
-            "description": "The pre condition given in the request evaluated to false by the server"
-        },
-        {
-            "code": 413,
-            "message": "Payload Too Large",
-            "description": "The server will not accept the request, because the request entity is too large"
-        },
-        {
-            "code": 416,
-            "message": "Requested Range Not Satisfiable",
-            "description": "The requested byte range is not available and is out of bounds"
-        },
-        {
-            "code": 429,
-            "message": "Too Many Requests",
-            "description": "Too many requests in a given amount of time"
-        },
-        {
-            "code": 500,
-            "message": "Internal Server Error",
-            "description": "The server met an unexpected condition"
-        },
-        {
-            "code": 502,
-            "message": "Bad Gateway",
-            "description": "The server received an invalid response from the upstream server"
-        },
-        {
-            "code": 503,
-            "message": "Service Unavailable",
-            "description": "The server is temporarily overloading or down"
-        },
-        {
-            "code": 504,
-            "message": "Gateway Timeout",
-            "description": "The gateway has timed out"
-        },
-        {
-            "code": 505,
-            "message": "HTTP Version Not Supported",
-            "description": "The server does not support the \"http protocol\" version"
-        }
-    ]
-}

docker-compose.yml

@@ -0,0 +1,52 @@
+# Docker-compose file is used only for local development. This is not production-ready example.
+
+version: '3.8'
+
+volumes:
+  tmp-data: {}
+  golint-go: {}
+  golint-cache: {}
+
+services:
+  app: &go
+    build: {target: builder}
+    environment:
+      HOME: /tmp
+      GOPATH: /tmp
+    volumes:
+      - /etc/passwd:/etc/passwd:ro
+      - /etc/group:/etc/group:ro
+      - .:/src:rw
+      - tmp-data:/tmp:rw
+    security_opt: [no-new-privileges:true]
+
+  web:
+    <<: *go
+    ports:
+      - "8080:8080/tcp" # Open <http://127.0.0.1:8080>
+    command: sh -c "go build -buildvcs=false -o /tmp/app ./cmd/error-pages && /tmp/app serve --show-details --proxy-headers=X-Foo,Bar,Baz_blah --catch-all"
+    healthcheck:
+      test: ['CMD', '/tmp/app', '--log-json', 'healthcheck']
+      interval: 4s
+      start_period: 5s
+      retries: 5
+
+  golint:
+    image: golangci/golangci-lint:v1.56-alpine # Image page: <https://hub.docker.com/r/golangci/golangci-lint>
+    environment:
+      GOLANGCI_LINT_CACHE: /tmp/golint # <https://github.com/golangci/golangci-lint/blob/v1.42.0/internal/cache/default.go#L68>
+    volumes:
+      - golint-go:/go:rw # go dependencies will be downloaded on each run without this
+      - golint-cache:/tmp/golint:rw
+      - .:/src:ro
+    working_dir: /src
+    security_opt: [no-new-privileges:true]
+
+  hurl:
+    image: ghcr.io/orange-opensource/hurl:4.2.0
+    volumes:
+      - .:/src:ro
+    working_dir: /src
+    depends_on:
+      web: {condition: service_healthy}
+    security_opt: [no-new-privileges:true]

docker/docker-entrypoint.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env sh
-set -e
-
-TEMPLATE_NAME=${TEMPLATE_NAME:-} # string|empty
-
-if [ -n "$TEMPLATE_NAME" ]; then
-  echo "$0: set pages for template '$TEMPLATE_NAME' as default (make accessible in root directory)";
-
-  if [ ! -d "/opt/html/$TEMPLATE_NAME" ]; then
-    (>&2 echo "$0: template '$TEMPLATE_NAME' was not found!"); exit 1;
-  fi;
-
-  ln -f -s "/opt/html/$TEMPLATE_NAME/"* /opt/html;
-fi;
-
-exec "$@"

docker/nginx-server.conf

@@ -1,9 +0,0 @@
-server {
-  listen      8080;
-  server_name _;
-
-  location / {
-    root  /opt/html;
-    index index.html index.htm;
-  }
-}

error-pages.yml

@@ -0,0 +1,140 @@
+templates:
+  # - name: {string} Template name (optional, if path is defined)
+  #   path: {string} Path to the template file
+  #   content: {string} Template content, if path is not defined
+  - path: ./templates/ghost.html
+    name: ghost # name is optional, if path is defined
+    content: ${GHOST_TEMPLATE_CONTENT}
+  - path: ./templates/l7-light.html
+  - path: ./templates/l7-dark.html
+  - path: ./templates/shuffle.html
+  - path: ./templates/noise.html
+  - path: ./templates/hacker-terminal.html
+  - path: ./templates/cats.html
+  - path: ./templates/lost-in-space.html
+  - path: ./templates/app-down.html
+  - path: ./templates/connection.html
+  - path: ./templates/matrix.html
+  - path: ./templates/orient.html
+
+formats:
+  json:
+    content: |
+      {
+        "error": true,
+        "code": {{ code | json }},
+        "message": {{ message | json }},
+        "description": {{ description | json }}{{ if show_details }},
+        "details": {
+          "host": {{ host | json }},
+          "original_uri": {{ original_uri | json }},
+          "forwarded_for": {{ forwarded_for | json }},
+          "namespace": {{ namespace | json }},
+          "ingress_name": {{ ingress_name | json }},
+          "service_name": {{ service_name | json }},
+          "service_port": {{ service_port | json }},
+          "request_id": {{ request_id | json }},
+          "timestamp": {{ now.Unix }}
+        }{{ end }}
+      }
+
+  xml:
+    content: |
+      <?xml version="1.0" encoding="utf-8"?>
+      <error>
+        <code>{{ code }}</code>
+        <message>{{ message }}</message>
+        <description>{{ description }}</description>{{ if show_details }}
+        <details>
+          <host>{{ host }}</host>
+          <originalURI>{{ original_uri }}</originalURI>
+          <forwardedFor>{{ forwarded_for }}</forwardedFor>
+          <namespace>{{ namespace }}</namespace>
+          <ingressName>{{ ingress_name }}</ingressName>
+          <serviceName>{{ service_name }}</serviceName>
+          <servicePort>{{ service_port }}</servicePort>
+          <requestID>{{ request_id }}</requestID>
+          <timestamp>{{ now.Unix }}</timestamp>
+        </details>{{ end }}
+      </error>
+
+pages:
+  400:
+    message: Bad Request
+    description: The server did not understand the request
+
+  401:
+    message: Unauthorized
+    description: The requested page needs a username and a password
+
+  403:
+    message: Forbidden
+    description: Access is forbidden to the requested page
+
+  404:
+    message: Not Found
+    description: The server can not find the requested page
+
+  405:
+    message: Method Not Allowed
+    description: The method specified in the request is not allowed
+
+  407:
+    message: Proxy Authentication Required
+    description: You must authenticate with a proxy server before this request can be served
+
+  408:
+    message: Request Timeout
+    description: The request took longer than the server was prepared to wait
+
+  409:
+    message: Conflict
+    description: The request could not be completed because of a conflict
+
+  410:
+    message: Gone
+    description: The requested page is no longer available
+
+  411:
+    message: Length Required
+    description: The "Content-Length" is not defined. The server will not accept the request without it
+
+  412:
+    message: Precondition Failed
+    description: The pre condition given in the request evaluated to false by the server
+
+  413:
+    message: Payload Too Large
+    description: The server will not accept the request, because the request entity is too large
+
+  416:
+    message: Requested Range Not Satisfiable
+    description: The requested byte range is not available and is out of bounds
+
+  418:
+    message: I'm a teapot
+    description: Attempt to brew coffee with a teapot is not supported
+
+  429:
+    message: Too Many Requests
+    description: Too many requests in a given amount of time
+
+  500:
+    message: Internal Server Error
+    description: The server met an unexpected condition
+
+  502:
+    message: Bad Gateway
+    description: The server received an invalid response from the upstream server
+
+  503:
+    message: Service Unavailable
+    description: The server is temporarily overloading or down
+
+  504:
+    message: Gateway Timeout
+    description: The gateway has timed out
+
+  505:
+    message: HTTP Version Not Supported
+    description: The server does not support the "http protocol" version

go.mod

@@ -0,0 +1,41 @@
+module gh.tarampamp.am/error-pages
+
+go 1.21
+
+require (
+	github.com/a8m/envsubst v1.4.2
+	github.com/fasthttp/router v1.5.0
+	github.com/fatih/color v1.16.0
+	github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d
+	github.com/pkg/errors v0.9.1
+	github.com/prometheus/client_golang v1.19.0
+	github.com/prometheus/client_model v0.6.0
+	github.com/stretchr/testify v1.9.0
+	github.com/urfave/cli/v2 v2.27.1
+	github.com/valyala/fasthttp v1.52.0
+	go.uber.org/automaxprocs v1.5.3
+	go.uber.org/goleak v1.3.0
+	go.uber.org/zap v1.27.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/klauspost/compress v1.17.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/common v0.50.0 // indirect
+	github.com/prometheus/procfs v0.13.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/savsgio/gotils v0.0.0-20240303185622-093b76447511 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/sys v0.18.0 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
+)

go.sum

@@ -0,0 +1,96 @@
+github.com/a8m/envsubst v1.4.2 h1:4yWIHXOLEJHQEFd4UjrWDrYeYlV7ncFWJOCBRLOZHQg=
+github.com/a8m/envsubst v1.4.2/go.mod h1:MVUTQNGQ3tsjOOtKCNd+fl8RzhsXcDvvAEzkhGtlsbY=
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+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/fasthttp/router v1.5.0 h1:3Qbbo27HAPzwbpRzgiV5V9+2faPkPt3eNuRaDV6LYDA=
+github.com/fasthttp/router v1.5.0/go.mod h1:FddcKNXFZg1imHcy+uKB0oo/o6yE9zD3wNguqlhWDak=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d h1:cVtBfNW5XTHiKQe7jDaDBSh/EVM4XLPutLAGboIXuM0=
+github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d/go.mod h1:P2viExyCEfeWGU259JnaQ34Inuec4R38JCyBx2edgD0=
+github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
+github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/klauspost/compress v1.17.7 h1:ehO88t2UGzQK66LMdE8tibEd1ErmzZjNEqWkjLAKQQg=
+github.com/klauspost/compress v1.17.7/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
+github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
+github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
+github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=
+github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8=
+github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
+github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
+github.com/prometheus/common v0.50.0 h1:YSZE6aa9+luNa2da6/Tik0q0A5AbR+U003TItK57CPQ=
+github.com/prometheus/common v0.50.0/go.mod h1:wHFBCEVWVmHMUpg7pYcOm2QUR/ocQdYSJVQJKnHc3xQ=
+github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
+github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/savsgio/gotils v0.0.0-20240303185622-093b76447511 h1:KanIMPX0QdEdB4R3CiimCAbxFrhB3j7h0/OvpYGVQa8=
+github.com/savsgio/gotils v0.0.0-20240303185622-093b76447511/go.mod h1:sM7Mt7uEoCeFSCBM+qBrqvEo+/9vdmj19wzp3yzUhmg=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
+github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
+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/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0=
+github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ=
+github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
+github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 h1:+qGGcbkzsfDQNPPe9UDgpxAWQrhbbBXOYJFQDq/dtJw=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913/go.mod h1:4aEEwZQutDLsQv2Deui4iYQ6DWTxR14g6m8Wv88+Xqk=
+go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
+go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/breaker/os_signal.go

@@ -0,0 +1,54 @@
+// Package breaker provides OSSignals struct for OS signals handling (with context).
+package breaker
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// OSSignals allows subscribing for system signals.
+type OSSignals struct {
+	ctx context.Context
+	ch  chan os.Signal
+}
+
+// NewOSSignals creates new subscriber for system signals.
+func NewOSSignals(ctx context.Context) OSSignals {
+	return OSSignals{
+		ctx: ctx,
+		ch:  make(chan os.Signal, 1),
+	}
+}
+
+// Subscribe for some system signals (call Stop for stopping).
+func (oss *OSSignals) Subscribe(onSignal func(os.Signal), signals ...os.Signal) {
+	if len(signals) == 0 {
+		signals = []os.Signal{os.Interrupt, syscall.SIGINT, syscall.SIGTERM} // default signals
+	}
+
+	signal.Notify(oss.ch, signals...)
+
+	go func(ch <-chan os.Signal) {
+		select {
+		case <-oss.ctx.Done():
+			break
+
+		case sig, opened := <-ch:
+			if oss.ctx.Err() != nil {
+				break
+			}
+
+			if opened && sig != nil {
+				onSignal(sig)
+			}
+		}
+	}(oss.ch)
+}
+
+// Stop system signals listening.
+func (oss *OSSignals) Stop() {
+	signal.Stop(oss.ch)
+	close(oss.ch)
+}

internal/breaker/os_signal_test.go

@@ -0,0 +1,57 @@
+package breaker_test
+
+import (
+	"context"
+	"os"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/breaker"
+)
+
+func TestNewOSSignals(t *testing.T) {
+	oss := breaker.NewOSSignals(context.Background())
+
+	gotSignal := make(chan os.Signal, 1)
+
+	oss.Subscribe(func(signal os.Signal) {
+		gotSignal <- signal
+	}, syscall.SIGUSR2)
+
+	defer oss.Stop()
+
+	proc, err := os.FindProcess(os.Getpid())
+	assert.NoError(t, err)
+
+	assert.NoError(t, proc.Signal(syscall.SIGUSR2)) // send the signal
+
+	time.Sleep(time.Millisecond * 5)
+
+	assert.Equal(t, syscall.SIGUSR2, <-gotSignal)
+}
+
+func TestNewOSSignalCtxCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	oss := breaker.NewOSSignals(ctx)
+
+	gotSignal := make(chan os.Signal, 1)
+
+	oss.Subscribe(func(signal os.Signal) {
+		gotSignal <- signal
+	}, syscall.SIGUSR2)
+
+	defer oss.Stop()
+
+	proc, err := os.FindProcess(os.Getpid())
+	assert.NoError(t, err)
+
+	cancel()
+
+	assert.NoError(t, proc.Signal(syscall.SIGUSR2)) // send the signal
+
+	assert.Empty(t, gotSignal)
+}

internal/checkers/health.go

@@ -0,0 +1,56 @@
+package checkers
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+type httpClient interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+// HealthChecker is a heals checker.
+type HealthChecker struct {
+	ctx        context.Context
+	httpClient httpClient
+}
+
+const defaultHTTPClientTimeout = time.Second * 3
+
+// NewHealthChecker creates heals checker.
+func NewHealthChecker(ctx context.Context, client ...httpClient) *HealthChecker {
+	var c httpClient
+
+	if len(client) == 1 {
+		c = client[0]
+	} else {
+		c = &http.Client{Timeout: defaultHTTPClientTimeout} // default
+	}
+
+	return &HealthChecker{ctx: ctx, httpClient: c}
+}
+
+// Check application using liveness probe.
+func (c *HealthChecker) Check(port uint16) error {
+	req, err := http.NewRequestWithContext(c.ctx, http.MethodGet, fmt.Sprintf("http://127.0.0.1:%d/healthz", port), nil) //nolint:lll
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("User-Agent", "HealthChecker/internal")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+
+	_ = resp.Body.Close()
+
+	if code := resp.StatusCode; code != http.StatusOK {
+		return fmt.Errorf("wrong status code [%d] from live endpoint", code)
+	}
+
+	return nil
+}

internal/checkers/health_test.go

@@ -0,0 +1,49 @@
+package checkers_test
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/checkers"
+)
+
+type httpClientFunc func(*http.Request) (*http.Response, error)
+
+func (f httpClientFunc) Do(req *http.Request) (*http.Response, error) { return f(req) }
+
+func TestHealthChecker_CheckSuccess(t *testing.T) {
+	var httpMock httpClientFunc = func(req *http.Request) (*http.Response, error) {
+		assert.Equal(t, http.MethodGet, req.Method)
+		assert.Equal(t, "http://127.0.0.1:123/healthz", req.URL.String())
+		assert.Equal(t, "HealthChecker/internal", req.Header.Get("User-Agent"))
+
+		return &http.Response{
+			Body:       io.NopCloser(bytes.NewReader([]byte{})),
+			StatusCode: http.StatusOK,
+		}, nil
+	}
+
+	checker := checkers.NewHealthChecker(context.Background(), httpMock)
+
+	assert.NoError(t, checker.Check(123))
+}
+
+func TestHealthChecker_CheckFail(t *testing.T) {
+	var httpMock httpClientFunc = func(req *http.Request) (*http.Response, error) {
+		return &http.Response{
+			Body:       io.NopCloser(bytes.NewReader([]byte{})),
+			StatusCode: http.StatusBadGateway,
+		}, nil
+	}
+
+	checker := checkers.NewHealthChecker(context.Background(), httpMock)
+
+	err := checker.Check(123)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "wrong status code")
+}

internal/checkers/live.go

@@ -0,0 +1,10 @@
+package checkers
+
+// LiveChecker is a liveness checker.
+type LiveChecker struct{}
+
+// NewLiveChecker creates liveness checker.
+func NewLiveChecker() *LiveChecker { return &LiveChecker{} }
+
+// Check application is alive?
+func (*LiveChecker) Check() error { return nil }

internal/checkers/live_test.go

@@ -0,0 +1,13 @@
+package checkers_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/checkers"
+)
+
+func TestLiveChecker_Check(t *testing.T) {
+	assert.NoError(t, checkers.NewLiveChecker().Check())
+}

internal/cli/app.go

@@ -0,0 +1,103 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"runtime"
+	"strings"
+
+	"github.com/urfave/cli/v2"
+
+	"gh.tarampamp.am/error-pages/internal/checkers"
+	"gh.tarampamp.am/error-pages/internal/cli/build"
+	"gh.tarampamp.am/error-pages/internal/cli/healthcheck"
+	"gh.tarampamp.am/error-pages/internal/cli/serve"
+	"gh.tarampamp.am/error-pages/internal/env"
+	"gh.tarampamp.am/error-pages/internal/logger"
+	"gh.tarampamp.am/error-pages/internal/version"
+)
+
+// NewApp creates new console application.
+func NewApp(appName string) *cli.App { //nolint:funlen
+	const (
+		logLevelFlagName  = "log-level"
+		logFormatFlagName = "log-format"
+		verboseFlagName   = "verbose"
+		debugFlagName     = "debug"
+		logJSONFlagName   = "log-json"
+
+		defaultLogLevel  = logger.InfoLevel
+		defaultLogFormat = logger.ConsoleFormat
+	)
+
+	// create "default" logger (will be overwritten later with customized)
+	var log, _ = logger.New(defaultLogLevel, defaultLogFormat) // error will never occurs
+
+	return &cli.App{
+		Usage: appName,
+		Before: func(c *cli.Context) (err error) {
+			_ = log.Sync() // sync previous logger instance
+
+			var logLevel, logFormat = defaultLogLevel, defaultLogFormat //nolint:ineffassign
+
+			if c.Bool(verboseFlagName) || c.Bool(debugFlagName) {
+				logLevel = logger.DebugLevel
+			} else {
+				// parse logging level
+				if logLevel, err = logger.ParseLevel(c.String(logLevelFlagName)); err != nil {
+					return err
+				}
+			}
+
+			if c.Bool(logJSONFlagName) {
+				logFormat = logger.JSONFormat
+			} else {
+				// parse logging format
+				if logFormat, err = logger.ParseFormat(c.String(logFormatFlagName)); err != nil {
+					return err
+				}
+			}
+
+			configured, err := logger.New(logLevel, logFormat) // create new logger instance
+			if err != nil {
+				return err
+			}
+
+			*log = *configured // replace "default" logger with customized
+
+			return nil
+		},
+		Commands: []*cli.Command{
+			healthcheck.NewCommand(checkers.NewHealthChecker(context.TODO())),
+			build.NewCommand(log),
+			serve.NewCommand(log),
+		},
+		Version: fmt.Sprintf("%s (%s)", version.Version(), runtime.Version()),
+		Flags: []cli.Flag{ // global flags
+			&cli.BoolFlag{ // kept for backward compatibility
+				Name:  verboseFlagName,
+				Usage: "verbose output (DEPRECATED FLAG)",
+			},
+			&cli.BoolFlag{ // kept for backward compatibility
+				Name:  debugFlagName,
+				Usage: "debug output (DEPRECATED FLAG)",
+			},
+			&cli.BoolFlag{ // kept for backward compatibility
+				Name:  logJSONFlagName,
+				Usage: "logs in JSON format (DEPRECATED FLAG)",
+			},
+			&cli.StringFlag{
+				Name:    logLevelFlagName,
+				Value:   defaultLogLevel.String(),
+				Usage:   "logging level (`" + strings.Join(logger.LevelStrings(), "/") + "`)",
+				EnvVars: []string{env.LogLevel.String()},
+			},
+			&cli.StringFlag{
+				Name:    logFormatFlagName,
+				Value:   defaultLogFormat.String(),
+				Usage:   "logging format (`" + strings.Join(logger.FormatStrings(), "/") + "`)",
+				EnvVars: []string{env.LogFormat.String()},
+			},
+		},
+	}
+}

internal/cli/app_test.go

@@ -0,0 +1,19 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/cli"
+)
+
+func TestNewCommand(t *testing.T) {
+	t.Parallel()
+
+	app := cli.NewApp("app")
+
+	assert.NotEmpty(t, app.Flags)
+
+	assert.NoError(t, app.Run([]string{"", "--log-level", "debug", "--log-format", "json"}))
+}

internal/cli/build/command.go

@@ -0,0 +1,155 @@
+package build
+
+import (
+	"os"
+	"path"
+
+	"github.com/pkg/errors"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+
+	"gh.tarampamp.am/error-pages/internal/cli/shared"
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+type command struct {
+	c *cli.Command
+}
+
+// NewCommand creates `build` command.
+func NewCommand(log *zap.Logger) *cli.Command {
+	var cmd = command{}
+
+	const (
+		generateIndexFlagName = "index"
+		disableL10nFlagName   = "disable-l10n"
+	)
+
+	cmd.c = &cli.Command{
+		Name:        "build",
+		Aliases:     []string{"b"},
+		Usage:       "build <output-directory>",
+		Description: "Build the error pages",
+		Action: func(c *cli.Context) error {
+			cfg, cfgErr := config.FromYamlFile(c.String(shared.ConfigFileFlag.Name))
+			if cfgErr != nil {
+				return cfgErr
+			}
+
+			if c.Args().Len() != 1 {
+				return errors.New("wrong arguments count")
+			}
+
+			return cmd.Run(log, cfg, c.Args().First(), c.Bool(generateIndexFlagName), c.Bool(disableL10nFlagName))
+		},
+		Flags: []cli.Flag{ // global flags
+			&cli.BoolFlag{
+				Name:    generateIndexFlagName,
+				Aliases: []string{"i"},
+				Usage:   "generate index page",
+			},
+			&cli.BoolFlag{
+				Name:  disableL10nFlagName,
+				Usage: "disable error pages localization",
+			},
+			shared.ConfigFileFlag,
+		},
+	}
+
+	return cmd.c
+}
+
+const (
+	outHTMLFileExt   = ".html"
+	outIndexFileName = "index"
+	outFilePerm      = os.FileMode(0664)
+	outDirPerm       = os.FileMode(0775)
+)
+
+func (cmd *command) Run(log *zap.Logger, cfg *config.Config, outDirectoryPath string, generateIndex, disableL10n bool) error { //nolint:funlen,lll
+	if len(cfg.Templates) == 0 {
+		return errors.New("no loaded templates")
+	}
+
+	log.Info("output directory preparing", zap.String("path", outDirectoryPath))
+
+	if err := cmd.createDirectory(outDirectoryPath, outDirPerm); err != nil {
+		return errors.Wrap(err, "cannot prepare output directory")
+	}
+
+	history, renderer := newBuildingHistory(), tpl.NewTemplateRenderer()
+	defer func() { _ = renderer.Close() }()
+
+	for _, template := range cfg.Templates {
+		log.Debug("template processing", zap.String("name", template.Name()))
+
+		for _, page := range cfg.Pages {
+			if err := cmd.createDirectory(path.Join(outDirectoryPath, template.Name()), outDirPerm); err != nil {
+				return err
+			}
+
+			var (
+				fileName = page.Code() + outHTMLFileExt
+				filePath = path.Join(outDirectoryPath, template.Name(), fileName)
+			)
+
+			content, renderingErr := renderer.Render(template.Content(), tpl.Properties{
+				Code:               page.Code(),
+				Message:            page.Message(),
+				Description:        page.Description(),
+				ShowRequestDetails: false,
+				L10nDisabled:       disableL10n,
+			})
+			if renderingErr != nil {
+				return renderingErr
+			}
+
+			if err := os.WriteFile(filePath, content, outFilePerm); err != nil {
+				return err
+			}
+
+			log.Debug("page rendered", zap.String("path", filePath))
+
+			if generateIndex {
+				history.Append(
+					template.Name(),
+					page.Code(),
+					page.Message(),
+					path.Join(template.Name(), fileName),
+				)
+			}
+		}
+	}
+
+	if generateIndex {
+		var filepath = path.Join(outDirectoryPath, outIndexFileName+outHTMLFileExt)
+
+		log.Info("index file generation", zap.String("path", filepath))
+
+		if err := history.WriteIndexFile(filepath, outFilePerm); err != nil {
+			return err
+		}
+	}
+
+	log.Info("job is done")
+
+	return nil
+}
+
+func (cmd *command) createDirectory(path string, perm os.FileMode) error {
+	stat, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return os.MkdirAll(path, perm)
+		}
+
+		return err
+	}
+
+	if !stat.IsDir() {
+		return errors.New("is not a directory")
+	}
+
+	return nil
+}

internal/cli/build/command_test.go

@@ -0,0 +1,26 @@
+package build_test
+
+import (
+	"flag"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/goleak"
+	"go.uber.org/zap"
+
+	"gh.tarampamp.am/error-pages/internal/cli/build"
+)
+
+func TestNewCommand(t *testing.T) {
+	defer goleak.VerifyNone(t)
+
+	cmd := build.NewCommand(zap.NewNop())
+
+	assert.NotEmpty(t, cmd.Flags)
+
+	assert.Error(t, cmd.Run(
+		cli.NewContext(cli.NewApp(), &flag.FlagSet{}, nil),
+		"",
+	), "should fail because of missing external services")
+}

internal/cli/build/history.go

@@ -0,0 +1,59 @@
+package build
+
+import (
+	"bytes"
+	_ "embed"
+	"os"
+	"sort"
+	"text/template"
+)
+
+type (
+	buildingHistory struct {
+		items map[string][]historyItem
+	}
+
+	historyItem struct {
+		Code, Message, Path string
+	}
+)
+
+func newBuildingHistory() buildingHistory {
+	return buildingHistory{items: make(map[string][]historyItem)}
+}
+
+func (bh *buildingHistory) Append(templateName, pageCode, message, path string) {
+	if _, ok := bh.items[templateName]; !ok {
+		bh.items[templateName] = make([]historyItem, 0)
+	}
+
+	bh.items[templateName] = append(bh.items[templateName], historyItem{
+		Code:    pageCode,
+		Message: message,
+		Path:    path,
+	})
+
+	sort.Slice(bh.items[templateName], func(i, j int) bool { // keep history items sorted
+		return bh.items[templateName][i].Code < bh.items[templateName][j].Code
+	})
+}
+
+//go:embed index.tpl.html
+var indexPageTemplate string
+
+func (bh *buildingHistory) WriteIndexFile(path string, perm os.FileMode) error {
+	t, err := template.New("index").Parse(indexPageTemplate)
+	if err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+
+	if err = t.Execute(&buf, bh.items); err != nil {
+		return err
+	}
+
+	defer buf.Reset() // optimization (is needed here?)
+
+	return os.WriteFile(path, buf.Bytes(), perm)
+}

internal/cli/build/index.tpl.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <title>Error pages list</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.1.3/css/bootstrap.min.css"
+          integrity="sha512-GQGU0fMMi238uA+a/bdWJfpUGKUkBdgfFdgBm72SUQ6BeyWjoY/ton0tEjH+OSH9iP4Dfh+7HM0I9f5eR0L/4w=="
+          crossorigin="anonymous" referrerpolicy="no-referrer" />
+    <style>
+        @media (prefers-color-scheme:dark){
+            :root {--bs-light:#212529;--bs-light-rgb:33,37,41;--bs-body-color:#eee}a{color:#91b4e8}a:hover{color:#a2bfec}
+        }
+    </style>
+</head>
+<body class="bg-light">
+<div class="container">
+    <main>
+        <div class="py-5 text-center">
+            <img class="d-block mx-auto mb-4" src="https://hsto.org/webt/rm/9y/ww/rm9ywwx3gjv9agwkcmllhsuyo7k.png"
+                 alt="" width="94">
+            <h2>Error pages index</h2>
+        </div>
+        {{- range $template, $item := . -}}
+        <h2 class="mb-3">Template name: <Code>{{ $template }}</Code></h2>
+        <ul class="mb-5">
+            {{ range $item -}}
+            <li><a href="{{ .Path }}"><strong>{{ .Code }}</strong>: {{ .Message }}</a></li>
+            {{ end -}}
+        </ul>
+        {{ end }}
+    </main>
+</div>
+<footer class="footer">
+    <div class="container text-center text-muted mt-3 mb-3">
+        For online documentation and support please refer to the
+        <a href="https://gh.tarampamp.am/error-pages">project repository</a>.
+    </div>
+</footer>
+</body>
+</html>

internal/cli/healthcheck/command.go

@@ -0,0 +1,36 @@
+// Package healthcheck contains CLI `healthcheck` command implementation.
+package healthcheck
+
+import (
+	"errors"
+	"math"
+
+	"github.com/urfave/cli/v2"
+
+	"gh.tarampamp.am/error-pages/internal/cli/shared"
+)
+
+type checker interface {
+	Check(port uint16) error
+}
+
+// NewCommand creates `healthcheck` command.
+func NewCommand(checker checker) *cli.Command {
+	return &cli.Command{
+		Name:    "healthcheck",
+		Aliases: []string{"chk", "health", "check"},
+		Usage:   "Health checker for the HTTP server. Use case - docker healthcheck",
+		Action: func(c *cli.Context) error {
+			var port = c.Uint(shared.ListenPortFlag.Name)
+
+			if port <= 0 || port > math.MaxUint16 {
+				return errors.New("port value out of range")
+			}
+
+			return checker.Check(uint16(port))
+		},
+		Flags: []cli.Flag{
+			shared.ListenPortFlag,
+		},
+	}
+}

internal/cli/healthcheck/command_test.go

@@ -0,0 +1,47 @@
+package healthcheck_test
+
+import (
+	"errors"
+	"flag"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli/v2"
+
+	"gh.tarampamp.am/error-pages/internal/cli/healthcheck"
+)
+
+type fakeChecker struct{ err error }
+
+func (c *fakeChecker) Check(port uint16) error { return c.err }
+
+func TestProperties(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+
+	assert.Equal(t, "healthcheck", cmd.Name)
+	assert.ElementsMatch(t, []string{"chk", "health", "check"}, cmd.Aliases)
+	assert.NotNil(t, cmd.Action)
+}
+
+func TestCommandRun(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+
+	assert.NoError(t, cmd.Run(cli.NewContext(cli.NewApp(), &flag.FlagSet{}, nil)))
+}
+
+func TestCommandRunFailed(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: errors.New("foo err")})
+
+	assert.ErrorContains(t, cmd.Run(cli.NewContext(cli.NewApp(), &flag.FlagSet{}, nil)), "foo err")
+}
+
+func TestPortFlagWrongArgument(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+
+	err := cmd.Run(
+		cli.NewContext(cli.NewApp(), &flag.FlagSet{}, nil),
+		"", "-p", "65536",
+	)
+
+	assert.ErrorContains(t, err, "port value out of range")
+}

internal/cli/serve/command.go

@@ -0,0 +1,297 @@
+package serve
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+
+	"gh.tarampamp.am/error-pages/internal/breaker"
+	"gh.tarampamp.am/error-pages/internal/cli/shared"
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/env"
+	appHttp "gh.tarampamp.am/error-pages/internal/http"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/pick"
+)
+
+type command struct {
+	c *cli.Command
+}
+
+const (
+	templateNameFlagName     = "template-name"
+	defaultErrorPageFlagName = "default-error-page"
+	defaultHTTPCodeFlagName  = "default-http-code"
+	showDetailsFlagName      = "show-details"
+	proxyHTTPHeadersFlagName = "proxy-headers"
+	disableL10nFlagName      = "disable-l10n"
+	catchAllFlagName         = "catch-all"
+	readBufferSizeFlagName   = "read-buffer-size"
+)
+
+const (
+	useRandomTemplate              = "random"
+	useRandomTemplateOnEachRequest = "i-said-random"
+	useRandomTemplateDaily         = "random-daily"
+	useRandomTemplateHourly        = "random-hourly"
+)
+
+// NewCommand creates `serve` command.
+func NewCommand(log *zap.Logger) *cli.Command { //nolint:funlen
+	var cmd = command{}
+
+	cmd.c = &cli.Command{
+		Name:    "serve",
+		Aliases: []string{"s", "server"},
+		Usage:   "Start HTTP server",
+		Action: func(c *cli.Context) error {
+			var cfg *config.Config
+
+			if configPath := c.String(shared.ConfigFileFlag.Name); configPath == "" { // load config from file
+				return errors.New("path to the config file is required for this command")
+			} else if loadedCfg, err := config.FromYamlFile(c.String(shared.ConfigFileFlag.Name)); err != nil {
+				return err
+			} else {
+				cfg = loadedCfg
+			}
+
+			var (
+				ip   = c.String(shared.ListenAddrFlag.Name)
+				port = uint16(c.Uint(shared.ListenPortFlag.Name))
+				o    options.ErrorPage
+			)
+
+			if net.ParseIP(ip) == nil {
+				return fmt.Errorf("wrong IP address [%s] for listening", ip)
+			}
+
+			{ // fill options
+				o.Template.Name = c.String(templateNameFlagName)
+				o.L10n.Disabled = c.Bool(disableL10nFlagName)
+				o.Default.PageCode = c.String(defaultErrorPageFlagName)
+				o.Default.HTTPCode = uint16(c.Uint(defaultHTTPCodeFlagName))
+				o.ShowDetails = c.Bool(showDetailsFlagName)
+				o.CatchAll = c.Bool(catchAllFlagName)
+
+				if headers := c.String(proxyHTTPHeadersFlagName); headers != "" { //nolint:nestif
+					var m = make(map[string]struct{})
+
+					// make unique and ignore empty strings
+					for _, header := range strings.Split(headers, ",") {
+						if h := strings.TrimSpace(header); h != "" {
+							if strings.ContainsRune(h, ' ') {
+								return fmt.Errorf("whitespaces in the HTTP headers for proxying [%s] are not allowed", header)
+							}
+
+							if _, ok := m[h]; !ok {
+								m[h] = struct{}{}
+							}
+						}
+					}
+
+					// convert map into slice
+					o.ProxyHTTPHeaders = make([]string, 0, len(m))
+					for h := range m {
+						o.ProxyHTTPHeaders = append(o.ProxyHTTPHeaders, h)
+					}
+				}
+			}
+
+			if o.Default.HTTPCode > 599 { //nolint:gomnd
+				return fmt.Errorf("wrong default HTTP response code [%d]", o.Default.HTTPCode)
+			}
+
+			return cmd.Run(c.Context, log, cfg, ip, port, c.Uint(readBufferSizeFlagName), o)
+		},
+		Flags: []cli.Flag{
+			shared.ConfigFileFlag,
+			shared.ListenPortFlag,
+			shared.ListenAddrFlag,
+			&cli.StringFlag{
+				Name:    templateNameFlagName,
+				Aliases: []string{"t"},
+				Usage: fmt.Sprintf(
+					"template name (set \"%s\" to use a randomized or \"%s\" to use a randomized template on "+
+						"each request or \"%s/%s\" daily/hourly randomized)",
+					useRandomTemplate,
+					useRandomTemplateOnEachRequest,
+					useRandomTemplateDaily,
+					useRandomTemplateHourly,
+				),
+				EnvVars: []string{env.TemplateName.String()},
+			},
+			&cli.StringFlag{
+				Name:    defaultErrorPageFlagName,
+				Value:   "404",
+				Usage:   "default error page",
+				EnvVars: []string{env.DefaultErrorPage.String()},
+			},
+			&cli.UintFlag{
+				Name:    defaultHTTPCodeFlagName,
+				Value:   404, //nolint:gomnd
+				Usage:   "default HTTP response code",
+				EnvVars: []string{env.DefaultHTTPCode.String()},
+			},
+			&cli.BoolFlag{
+				Name:    showDetailsFlagName,
+				Usage:   "show request details in response",
+				EnvVars: []string{env.ShowDetails.String()},
+			},
+			&cli.StringFlag{
+				Name:    proxyHTTPHeadersFlagName,
+				Usage:   "proxy HTTP request headers list (comma-separated)",
+				EnvVars: []string{env.ProxyHTTPHeaders.String()},
+			},
+			&cli.BoolFlag{
+				Name:    disableL10nFlagName,
+				Usage:   "disable error pages localization",
+				EnvVars: []string{env.DisableL10n.String()},
+			},
+			&cli.BoolFlag{
+				Name:    catchAllFlagName,
+				Usage:   "catch all pages",
+				EnvVars: []string{env.CatchAll.String()},
+			},
+			&cli.UintFlag{
+				Name:    readBufferSizeFlagName,
+				Usage:   "read buffer size (0 = use default value)",
+				EnvVars: []string{env.ReadBufferSize.String()},
+			},
+		},
+	}
+
+	return cmd.c
+}
+
+// Run current command.
+func (cmd *command) Run( //nolint:funlen
+	parentCtx context.Context,
+	log *zap.Logger,
+	cfg *config.Config,
+	ip string,
+	port uint16,
+	readBufferSize uint,
+	opt options.ErrorPage,
+) error {
+	var (
+		ctx, cancel = context.WithCancel(parentCtx) // serve context creation
+		oss         = breaker.NewOSSignals(ctx)     // OS signals listener
+	)
+
+	// subscribe for system signals
+	oss.Subscribe(func(sig os.Signal) {
+		log.Warn("Stopping by OS signal..", zap.String("signal", sig.String()))
+
+		cancel()
+	})
+
+	defer func() {
+		cancel()   // call the cancellation function after all
+		oss.Stop() // stop system signals listening
+	}()
+
+	var (
+		templateNames = cfg.TemplateNames()
+		picker        interface{ Pick() string }
+	)
+
+	switch opt.Template.Name {
+	case useRandomTemplate:
+		log.Info("A random template will be used")
+
+		picker = pick.NewStringsSlice(templateNames, pick.RandomOnce)
+
+	case useRandomTemplateOnEachRequest:
+		log.Info("A random template on EACH request will be used")
+
+		picker = pick.NewStringsSlice(templateNames, pick.RandomEveryTime)
+
+	case useRandomTemplateDaily:
+		log.Info("A random template will be used and changed once a day")
+
+		picker = pick.NewStringsSliceWithInterval(templateNames, pick.RandomEveryTime, time.Hour*24) //nolint:gomnd
+
+	case useRandomTemplateHourly:
+		log.Info("A random template will be used and changed hourly")
+
+		picker = pick.NewStringsSliceWithInterval(templateNames, pick.RandomEveryTime, time.Hour)
+
+	case "":
+		log.Info("The first template (ordered by name) will be used")
+
+		picker = pick.NewStringsSlice(templateNames, pick.First)
+
+	default:
+		if t, found := cfg.Template(opt.Template.Name); found {
+			log.Info("We will use the requested template", zap.String("name", t.Name()))
+			picker = pick.NewStringsSlice([]string{t.Name()}, pick.First)
+		} else {
+			return errors.New("requested nonexistent template: " + opt.Template.Name)
+		}
+	}
+
+	// create HTTP server
+	server := appHttp.NewServer(log, readBufferSize)
+
+	// register server routes, middlewares, etc.
+	if err := server.Register(cfg, picker, opt); err != nil {
+		return err
+	}
+
+	startedAt, startingErrCh := time.Now(), make(chan error, 1) // channel for server starting error
+
+	// start HTTP server in separate goroutine
+	go func(errCh chan<- error) {
+		defer close(errCh)
+
+		var fields = []zap.Field{
+			zap.String("addr", ip),
+			zap.Uint16("port", port),
+			zap.String("default error page", opt.Default.PageCode),
+			zap.Uint16("default HTTP response code", opt.Default.HTTPCode),
+			zap.Strings("proxy headers", opt.ProxyHTTPHeaders),
+			zap.Bool("show request details", opt.ShowDetails),
+			zap.Bool("localization disabled", opt.L10n.Disabled),
+			zap.Bool("catch all enabled", opt.CatchAll),
+		}
+
+		if readBufferSize > 0 {
+			fields = append(fields, zap.Uint("read buffer size", readBufferSize))
+		}
+
+		log.Info("Server starting", fields...)
+
+		if err := server.Start(ip, port); err != nil {
+			errCh <- err
+		}
+	}(startingErrCh)
+
+	// and wait for...
+	select {
+	case err := <-startingErrCh: // ..server starting error
+		return err
+
+	case <-ctx.Done(): // ..or context cancellation
+		log.Info("Gracefully server stopping", zap.Duration("uptime", time.Since(startedAt)))
+
+		if p, ok := picker.(interface{ Close() error }); ok {
+			if err := p.Close(); err != nil {
+				return err
+			}
+		}
+
+		// stop the server using created context above
+		if err := server.Stop(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/cli/serve/command_test.go

@@ -0,0 +1,7 @@
+package serve_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/cli/shared/flags.go

@@ -0,0 +1,31 @@
+package shared
+
+import (
+	"github.com/urfave/cli/v2"
+
+	"gh.tarampamp.am/error-pages/internal/env"
+)
+
+var ConfigFileFlag = &cli.StringFlag{ //nolint:gochecknoglobals
+	Name:    "config-file",
+	Aliases: []string{"c"},
+	Usage:   "path to the config file (yaml)",
+	Value:   "./error-pages.yml",
+	EnvVars: []string{env.ConfigFilePath.String()},
+}
+
+var ListenAddrFlag = &cli.StringFlag{ //nolint:gochecknoglobals
+	Name:    "listen",
+	Aliases: []string{"l"},
+	Usage:   "IP (v4 or v6) address to Listen on",
+	Value:   "0.0.0.0",
+	EnvVars: []string{env.ListenAddr.String()},
+}
+
+var ListenPortFlag = &cli.UintFlag{ //nolint:gochecknoglobals
+	Name:    "port",
+	Aliases: []string{"p"},
+	Usage:   "TCP port number",
+	Value:   8080, //nolint:gomnd
+	EnvVars: []string{env.ListenPort.String()},
+}

internal/config/config.go

@@ -0,0 +1,255 @@
+package config
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/a8m/envsubst"
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+// Config is a main (exportable) config struct.
+type Config struct {
+	Templates []Template
+	Pages     map[string]Page   // map key is a page code
+	Formats   map[string]Format // map key is a format name
+}
+
+// Template returns a Template with the passes name.
+func (c *Config) Template(name string) (*Template, bool) {
+	for i := 0; i < len(c.Templates); i++ {
+		if c.Templates[i].name == name {
+			return &c.Templates[i], true
+		}
+	}
+
+	return &Template{}, false
+}
+
+func (c *Config) JSONFormat() (*Format, bool) { return c.format("json") }
+func (c *Config) XMLFormat() (*Format, bool)  { return c.format("xml") }
+
+func (c *Config) format(name string) (*Format, bool) {
+	if f, ok := c.Formats[name]; ok {
+		if len(f.content) > 0 {
+			return &f, true
+		}
+	}
+
+	return &Format{}, false
+}
+
+// TemplateNames returns all template names.
+func (c *Config) TemplateNames() []string {
+	n := make([]string, len(c.Templates))
+
+	for i, t := range c.Templates {
+		n[i] = t.name
+	}
+
+	return n
+}
+
+// Template describes HTTP error page template.
+type Template struct {
+	name    string
+	content []byte
+}
+
+// Name returns the name of the template.
+func (t Template) Name() string { return t.name }
+
+// Content returns the template content.
+func (t Template) Content() []byte { return t.content }
+
+func (t *Template) loadContentFromFile(filePath string) (err error) {
+	if t.content, err = os.ReadFile(filePath); err != nil {
+		return errors.Wrap(err, "cannot load content for the template "+t.Name()+" from file "+filePath)
+	}
+
+	return
+}
+
+// Page describes error page.
+type Page struct {
+	code        string
+	message     string
+	description string
+}
+
+// Code returns the code of the Page.
+func (p Page) Code() string { return p.code }
+
+// Message returns the message of the Page.
+func (p Page) Message() string { return p.message }
+
+// Description returns the description of the Page.
+func (p Page) Description() string { return p.description }
+
+// Format describes different response formats.
+type Format struct {
+	name    string
+	content []byte
+}
+
+// Name returns the name of the format.
+func (f Format) Name() string { return f.name }
+
+// Content returns the format content.
+func (f Format) Content() []byte { return f.content }
+
+// config is internal struct for marshaling/unmarshaling configuration file content.
+type config struct {
+	Templates []struct {
+		Path    string `yaml:"path"`
+		Name    string `yaml:"name"`
+		Content string `yaml:"content"`
+	} `yaml:"templates"`
+
+	Formats map[string]struct {
+		Content string `yaml:"content"`
+	} `yaml:"formats"`
+
+	Pages map[string]struct {
+		Message     string `yaml:"message"`
+		Description string `yaml:"description"`
+	} `yaml:"pages"`
+}
+
+// Validate the config struct and return an error if something is wrong.
+func (c config) Validate() error {
+	if len(c.Templates) == 0 {
+		return errors.New("empty templates list")
+	} else {
+		for i := 0; i < len(c.Templates); i++ {
+			if c.Templates[i].Name == "" && c.Templates[i].Path == "" {
+				return errors.New("empty path and name with index " + strconv.Itoa(i))
+			}
+
+			if c.Templates[i].Path == "" && c.Templates[i].Content == "" {
+				return errors.New("empty path and template content with index " + strconv.Itoa(i))
+			}
+		}
+	}
+
+	if len(c.Pages) == 0 {
+		return errors.New("empty pages list")
+	} else {
+		for code := range c.Pages {
+			if code == "" {
+				return errors.New("empty page code")
+			}
+
+			if strings.ContainsRune(code, ' ') {
+				return errors.New("code should not contain whitespaces")
+			}
+		}
+	}
+
+	if len(c.Formats) > 0 {
+		for name := range c.Formats {
+			if name == "" {
+				return errors.New("empty format name")
+			}
+
+			if strings.ContainsRune(name, ' ') {
+				return errors.New("format should not contain whitespaces")
+			}
+		}
+	}
+
+	return nil
+}
+
+// Export the config struct into Config.
+func (c *config) Export() (*Config, error) {
+	cfg := &Config{}
+
+	cfg.Templates = make([]Template, 0, len(c.Templates))
+
+	for i := 0; i < len(c.Templates); i++ {
+		tpl := Template{name: c.Templates[i].Name}
+
+		if c.Templates[i].Content == "" {
+			if c.Templates[i].Path == "" {
+				return nil, errors.New("path to the template " + c.Templates[i].Name + " not provided")
+			}
+
+			if err := tpl.loadContentFromFile(c.Templates[i].Path); err != nil {
+				return nil, err
+			}
+		} else {
+			tpl.content = []byte(c.Templates[i].Content)
+		}
+
+		cfg.Templates = append(cfg.Templates, tpl)
+	}
+
+	cfg.Pages = make(map[string]Page, len(c.Pages))
+
+	for code, p := range c.Pages {
+		cfg.Pages[code] = Page{code: code, message: p.Message, description: p.Description}
+	}
+
+	cfg.Formats = make(map[string]Format, len(c.Formats))
+
+	for name, f := range c.Formats {
+		cfg.Formats[name] = Format{name: name, content: []byte(strings.TrimSpace(f.Content))}
+	}
+
+	return cfg, nil
+}
+
+// FromYaml creates new Config instance using YAML-structured content.
+func FromYaml(in []byte) (_ *Config, err error) {
+	in, err = envsubst.Bytes(in)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &config{}
+
+	if err = yaml.Unmarshal(in, c); err != nil {
+		return nil, errors.Wrap(err, "cannot parse configuration file")
+	}
+
+	var basename string
+
+	for i := 0; i < len(c.Templates); i++ {
+		if c.Templates[i].Name == "" { // set the template name from file path
+			basename = filepath.Base(c.Templates[i].Path)
+			c.Templates[i].Name = strings.TrimSuffix(basename, filepath.Ext(basename))
+		}
+	}
+
+	if err = c.Validate(); err != nil {
+		return nil, err
+	}
+
+	return c.Export()
+}
+
+// FromYamlFile creates new Config instance using YAML file.
+func FromYamlFile(filepath string) (*Config, error) {
+	bytes, err := os.ReadFile(filepath)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot read configuration file")
+	}
+
+	// the following code makes it possible to use the relative links in the config file (`.` means "directory with
+	// the config file")
+	cwd, err := os.Getwd()
+	if err == nil {
+		if err = os.Chdir(path.Dir(filepath)); err != nil {
+			return nil, err
+		}
+
+		defer func() { _ = os.Chdir(cwd) }()
+	}
+
+	return FromYaml(bytes)
+}

internal/config/config_test.go

@@ -0,0 +1,196 @@
+package config_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/config"
+)
+
+func TestFromYaml(t *testing.T) {
+	var cases = map[string]struct { //nolint:maligned
+		giveYaml      []byte
+		giveEnv       map[string]string
+		wantErr       bool
+		checkResultFn func(*testing.T, *config.Config)
+	}{
+		"with all possible values": {
+			giveEnv: map[string]string{
+				"__FOO_TPL_PATH": "./testdata/foo-tpl.html",
+				"__FOO_TPL_NAME": "Foo Template",
+			},
+			giveYaml: []byte(`
+templates:
+  - path: ${__FOO_TPL_PATH}
+    name: ${__FOO_TPL_NAME:-default_value} # name is optional
+  - path: ./testdata/bar-tpl.html
+  - name: Baz
+    content: |
+      Some content {{ code }}
+      New line
+
+formats:
+  json:
+    content: |
+      {"code": "{{code}}"}
+  Avada_Kedavra:
+    content: "{{ message }}"
+
+pages:
+  400:
+    message: Bad Request
+    description: The server did not understand the request
+
+  401:
+    message: Unauthorized
+    description: The requested page needs a username and a password
+`),
+			wantErr: false,
+			checkResultFn: func(t *testing.T, cfg *config.Config) {
+				assert.Len(t, cfg.Templates, 3)
+
+				tpl, found := cfg.Template("Foo Template")
+				assert.True(t, found)
+				assert.Equal(t, "Foo Template", tpl.Name())
+				assert.Equal(t, "<html><body>foo {{ code }}</body></html>\n", string(tpl.Content()))
+
+				tpl, found = cfg.Template("bar-tpl")
+				assert.True(t, found)
+				assert.Equal(t, "bar-tpl", tpl.Name())
+				assert.Equal(t, "<html><body>bar {{ code }}</body></html>\n", string(tpl.Content()))
+
+				tpl, found = cfg.Template("Baz")
+				assert.True(t, found)
+				assert.Equal(t, "Baz", tpl.Name())
+				assert.Equal(t, "Some content {{ code }}\nNew line\n", string(tpl.Content()))
+
+				tpl, found = cfg.Template("NonExists")
+				assert.False(t, found)
+				assert.Equal(t, "", tpl.Name())
+				assert.Equal(t, "", string(tpl.Content()))
+
+				assert.Len(t, cfg.Formats, 2)
+
+				format, found := cfg.Formats["json"]
+				assert.True(t, found)
+				assert.Equal(t, `{"code": "{{code}}"}`, string(format.Content()))
+
+				format, found = cfg.Formats["Avada_Kedavra"]
+				assert.True(t, found)
+				assert.Equal(t, "{{ message }}", string(format.Content()))
+
+				assert.Len(t, cfg.Pages, 2)
+
+				errPage, found := cfg.Pages["400"]
+				assert.True(t, found)
+				assert.Equal(t, "400", errPage.Code())
+				assert.Equal(t, "Bad Request", errPage.Message())
+				assert.Equal(t, "The server did not understand the request", errPage.Description())
+
+				errPage, found = cfg.Pages["401"]
+				assert.True(t, found)
+				assert.Equal(t, "401", errPage.Code())
+				assert.Equal(t, "Unauthorized", errPage.Message())
+				assert.Equal(t, "The requested page needs a username and a password", errPage.Description())
+
+				errPage, found = cfg.Pages["666"]
+				assert.False(t, found)
+				assert.Equal(t, "", errPage.Message())
+				assert.Equal(t, "", errPage.Code())
+				assert.Equal(t, "", errPage.Description())
+			},
+		},
+		"broken yaml": {
+			giveYaml: []byte(`foo bar`),
+			wantErr:  true,
+		},
+	}
+
+	for name, tt := range cases {
+		t.Run(name, func(t *testing.T) {
+			if tt.giveEnv != nil {
+				for key, value := range tt.giveEnv {
+					assert.NoError(t, os.Setenv(key, value))
+				}
+			}
+
+			conf, err := config.FromYaml(tt.giveYaml)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.Nil(t, err)
+				tt.checkResultFn(t, conf)
+			}
+
+			if tt.giveEnv != nil {
+				for key := range tt.giveEnv {
+					assert.NoError(t, os.Unsetenv(key))
+				}
+			}
+		})
+	}
+}
+
+func TestFromYamlFile(t *testing.T) {
+	var cases = map[string]struct { //nolint:maligned
+		giveYamlFilePath string
+		wantErr          bool
+		checkResultFn    func(*testing.T, *config.Config)
+	}{
+		"with all possible values": {
+			giveYamlFilePath: "./testdata/simple.yml",
+			wantErr:          false,
+			checkResultFn: func(t *testing.T, cfg *config.Config) {
+				assert.Len(t, cfg.Templates, 2)
+
+				tpl, found := cfg.Template("ghost")
+				assert.True(t, found)
+				assert.Equal(t, "ghost", tpl.Name())
+				assert.Equal(t, "<html><body>foo {{ code }}</body></html>\n", string(tpl.Content()))
+
+				tpl, found = cfg.Template("bar-tpl")
+				assert.True(t, found)
+				assert.Equal(t, "bar-tpl", tpl.Name())
+				assert.Equal(t, "<html><body>bar {{ code }}</body></html>\n", string(tpl.Content()))
+
+				assert.Len(t, cfg.Pages, 2)
+
+				errPage, found := cfg.Pages["400"]
+				assert.True(t, found)
+				assert.Equal(t, "400", errPage.Code())
+				assert.Equal(t, "Bad Request", errPage.Message())
+				assert.Equal(t, "The server did not understand the request", errPage.Description())
+
+				errPage, found = cfg.Pages["401"]
+				assert.True(t, found)
+				assert.Equal(t, "401", errPage.Code())
+				assert.Equal(t, "Unauthorized", errPage.Message())
+				assert.Equal(t, "The requested page needs a username and a password", errPage.Description())
+			},
+		},
+		"broken yaml": {
+			giveYamlFilePath: "./testdata/broken.yml",
+			wantErr:          true,
+		},
+		"wrong file path": {
+			giveYamlFilePath: "foo bar",
+			wantErr:          true,
+		},
+	}
+
+	for name, tt := range cases {
+		t.Run(name, func(t *testing.T) {
+			conf, err := config.FromYamlFile(tt.giveYamlFilePath)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.Nil(t, err)
+				tt.checkResultFn(t, conf)
+			}
+		})
+	}
+}

internal/config/testdata/bar-tpl.html

@@ -0,0 +1 @@
+<html><body>bar {{ code }}</body></html>

internal/config/testdata/broken.yml

@@ -0,0 +1 @@
+foo bar

internal/config/testdata/foo-tpl.html

@@ -0,0 +1 @@
+<html><body>foo {{ code }}</body></html>

internal/config/testdata/simple.yml

@@ -0,0 +1,13 @@
+templates:
+  - path: ./foo-tpl.html
+    name: ghost # name is optional
+  - path: ./bar-tpl.html
+
+pages:
+  400:
+    message: Bad Request
+    description: The server did not understand the request
+
+  401:
+    message: Unauthorized
+    description: The requested page needs a username and a password

internal/env/env.go

@@ -0,0 +1,31 @@
+// Package env contains all about environment variables, that can be used by current application.
+package env
+
+import "os"
+
+type envVariable string
+
+const (
+	LogLevel  envVariable = "LOG_LEVEL"  // logging level
+	LogFormat envVariable = "LOG_FORMAT" // logging format (json|console)
+
+	ListenAddr       envVariable = "LISTEN_ADDR"        // IP address for listening
+	ListenPort       envVariable = "LISTEN_PORT"        // port number for listening
+	TemplateName     envVariable = "TEMPLATE_NAME"      // template name
+	ConfigFilePath   envVariable = "CONFIG_FILE"        // path to the config file
+	DefaultErrorPage envVariable = "DEFAULT_ERROR_PAGE" // default error page (code)
+	DefaultHTTPCode  envVariable = "DEFAULT_HTTP_CODE"  // default HTTP response code
+	ShowDetails      envVariable = "SHOW_DETAILS"       // show request details in response
+	ProxyHTTPHeaders envVariable = "PROXY_HTTP_HEADERS" // proxy HTTP request headers list (request -> response)
+	DisableL10n      envVariable = "DISABLE_L10N"       // disable pages localization
+	CatchAll         envVariable = "CATCH_ALL"          // catch all pages
+	ReadBufferSize   envVariable = "READ_BUFFER_SIZE"   // https://github.com/tarampampam/error-pages/issues/238
+)
+
+// String returns environment variable name in the string representation.
+func (e envVariable) String() string { return string(e) }
+
+// Lookup retrieves the value of the environment variable. If the variable is present in the environment the value
+// (which may be empty) is returned and the boolean is true. Otherwise the returned value will be empty and the
+// boolean will be false.
+func (e envVariable) Lookup() (string, bool) { return os.LookupEnv(string(e)) }

internal/env/env_test.go

@@ -0,0 +1,59 @@
+package env
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConstants(t *testing.T) {
+	assert.Equal(t, "LISTEN_ADDR", string(ListenAddr))
+	assert.Equal(t, "LISTEN_PORT", string(ListenPort))
+	assert.Equal(t, "TEMPLATE_NAME", string(TemplateName))
+	assert.Equal(t, "CONFIG_FILE", string(ConfigFilePath))
+	assert.Equal(t, "DEFAULT_ERROR_PAGE", string(DefaultErrorPage))
+	assert.Equal(t, "DEFAULT_HTTP_CODE", string(DefaultHTTPCode))
+	assert.Equal(t, "SHOW_DETAILS", string(ShowDetails))
+	assert.Equal(t, "PROXY_HTTP_HEADERS", string(ProxyHTTPHeaders))
+	assert.Equal(t, "DISABLE_L10N", string(DisableL10n))
+	assert.Equal(t, "CATCH_ALL", string(CatchAll))
+	assert.Equal(t, "READ_BUFFER_SIZE", string(ReadBufferSize))
+}
+
+func TestEnvVariable_Lookup(t *testing.T) {
+	cases := []struct {
+		giveEnv envVariable
+	}{
+		{giveEnv: ListenAddr},
+		{giveEnv: ListenPort},
+		{giveEnv: TemplateName},
+		{giveEnv: ConfigFilePath},
+		{giveEnv: DefaultErrorPage},
+		{giveEnv: DefaultHTTPCode},
+		{giveEnv: ShowDetails},
+		{giveEnv: ProxyHTTPHeaders},
+		{giveEnv: DisableL10n},
+		{giveEnv: CatchAll},
+		{giveEnv: ReadBufferSize},
+	}
+
+	for _, tt := range cases {
+		tt := tt
+		t.Run(tt.giveEnv.String(), func(t *testing.T) {
+			assert.NoError(t, os.Unsetenv(tt.giveEnv.String())) // make sure that env is unset for test
+
+			defer func() { assert.NoError(t, os.Unsetenv(tt.giveEnv.String())) }()
+
+			value, exists := tt.giveEnv.Lookup()
+			assert.False(t, exists)
+			assert.Empty(t, value)
+
+			assert.NoError(t, os.Setenv(tt.giveEnv.String(), "foo"))
+
+			value, exists = tt.giveEnv.Lookup()
+			assert.True(t, exists)
+			assert.Equal(t, "foo", value)
+		})
+	}
+}

internal/http/common/middlewares.go

@@ -0,0 +1,68 @@
+package common
+
+import (
+	"strings"
+	"time"
+
+	"github.com/valyala/fasthttp"
+	"go.uber.org/zap"
+)
+
+func LogRequest(h fasthttp.RequestHandler, log *zap.Logger) fasthttp.RequestHandler {
+	const headersSeparator = ": "
+
+	return func(ctx *fasthttp.RequestCtx) {
+		var ua = string(ctx.UserAgent())
+
+		if strings.Contains(strings.ToLower(ua), "healthcheck") { // skip healthcheck requests logging
+			h(ctx)
+
+			return
+		}
+
+		var reqHeaders = make([]string, 0, 24) //nolint:gomnd
+
+		ctx.Request.Header.VisitAll(func(key, value []byte) {
+			reqHeaders = append(reqHeaders, string(key)+headersSeparator+string(value))
+		})
+
+		var startedAt = time.Now()
+
+		h(ctx)
+
+		var respHeaders = make([]string, 0, 16) //nolint:gomnd
+
+		ctx.Response.Header.VisitAll(func(key, value []byte) {
+			respHeaders = append(respHeaders, string(key)+headersSeparator+string(value))
+		})
+
+		log.Info("HTTP request processed",
+			zap.String("useragent", ua),
+			zap.String("method", string(ctx.Method())),
+			zap.String("url", string(ctx.RequestURI())),
+			zap.String("referer", string(ctx.Referer())),
+			zap.Int("status_code", ctx.Response.StatusCode()),
+			zap.String("content_type", string(ctx.Response.Header.ContentType())),
+			zap.Bool("connection_close", ctx.Response.ConnectionClose()),
+			zap.Duration("duration", time.Since(startedAt)),
+			zap.Strings("request_headers", reqHeaders),
+			zap.Strings("response_headers", respHeaders),
+		)
+	}
+}
+
+type metrics interface {
+	IncrementTotalRequests()
+	ObserveRequestDuration(t time.Duration)
+}
+
+func DurationMetrics(h fasthttp.RequestHandler, m metrics) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		var startedAt = time.Now()
+
+		h(ctx)
+
+		m.IncrementTotalRequests()
+		m.ObserveRequestDuration(time.Since(startedAt))
+	}
+}

internal/http/common/middlewares_test.go

@@ -0,0 +1,7 @@
+package common_test
+
+import "testing"
+
+func TestNothing2(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/core/errorpage.go

@@ -0,0 +1,127 @@
+package core
+
+import (
+	"strconv"
+
+	"github.com/valyala/fasthttp"
+
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+type templatePicker interface {
+	// Pick the template name for responding.
+	Pick() string
+}
+
+type renderer interface {
+	Render(content []byte, props tpl.Properties) ([]byte, error)
+}
+
+func RespondWithErrorPage( //nolint:funlen,gocyclo
+	ctx *fasthttp.RequestCtx,
+	cfg *config.Config,
+	p templatePicker,
+	rdr renderer,
+	pageCode string,
+	httpCode int,
+	opt options.ErrorPage,
+) {
+	ctx.Response.Header.Set("X-Robots-Tag", "noindex") // block Search indexing
+
+	var (
+		clientWant    = ClientWantFormat(ctx)
+		json, canJSON = cfg.JSONFormat()
+		xml, canXML   = cfg.XMLFormat()
+		props         = tpl.Properties{
+			Code:               pageCode,
+			ShowRequestDetails: opt.ShowDetails,
+			L10nDisabled:       opt.L10n.Disabled,
+		}
+	)
+
+	if opt.ShowDetails {
+		props.OriginalURI = string(ctx.Request.Header.Peek(OriginalURI))
+		props.Namespace = string(ctx.Request.Header.Peek(Namespace))
+		props.IngressName = string(ctx.Request.Header.Peek(IngressName))
+		props.ServiceName = string(ctx.Request.Header.Peek(ServiceName))
+		props.ServicePort = string(ctx.Request.Header.Peek(ServicePort))
+		props.RequestID = string(ctx.Request.Header.Peek(RequestID))
+		props.ForwardedFor = string(ctx.Request.Header.Peek(ForwardedFor))
+		props.Host = string(ctx.Request.Header.Peek(Host))
+	}
+
+	if page, exists := cfg.Pages[pageCode]; exists {
+		props.Message = page.Message()
+		props.Description = page.Description()
+	} else if c, err := strconv.Atoi(pageCode); err == nil {
+		if s := fasthttp.StatusMessage(c); s != "Unknown Status Code" { // as a fallback
+			props.Message = s
+		}
+	}
+
+	SetClientFormat(ctx, PlainTextContentType) // set default content type
+
+	if props.Message == "" {
+		ctx.SetStatusCode(fasthttp.StatusNotFound)
+		_, _ = ctx.WriteString("requested pageCode (" + pageCode + ") not available")
+
+		return
+	}
+
+	// proxy required HTTP headers from the request to the response
+	for _, headerToProxy := range opt.ProxyHTTPHeaders {
+		if reqHeader := ctx.Request.Header.Peek(headerToProxy); len(reqHeader) > 0 {
+			ctx.Response.Header.SetBytesV(headerToProxy, reqHeader)
+		}
+	}
+
+	switch {
+	case clientWant == JSONContentType && canJSON: // JSON
+		{
+			SetClientFormat(ctx, JSONContentType)
+
+			if content, err := rdr.Render(json.Content(), props); err == nil {
+				ctx.SetStatusCode(httpCode)
+				_, _ = ctx.Write(content)
+			} else {
+				ctx.SetStatusCode(fasthttp.StatusInternalServerError)
+				_, _ = ctx.WriteString("cannot render JSON template: " + err.Error())
+			}
+		}
+
+	case clientWant == XMLContentType && canXML: // XML
+		{
+			SetClientFormat(ctx, XMLContentType)
+
+			if content, err := rdr.Render(xml.Content(), props); err == nil {
+				ctx.SetStatusCode(httpCode)
+				_, _ = ctx.Write(content)
+			} else {
+				ctx.SetStatusCode(fasthttp.StatusInternalServerError)
+				_, _ = ctx.WriteString("cannot render XML template: " + err.Error())
+			}
+		}
+
+	default: // HTML
+		{
+			SetClientFormat(ctx, HTMLContentType)
+
+			var templateName = p.Pick()
+
+			if template, exists := cfg.Template(templateName); exists {
+				if content, err := rdr.Render(template.Content(), props); err == nil {
+					ctx.SetStatusCode(httpCode)
+					_, _ = ctx.Write(content)
+				} else {
+					ctx.SetStatusCode(fasthttp.StatusInternalServerError)
+					_, _ = ctx.WriteString("cannot render HTML template: " + err.Error())
+				}
+			} else {
+				ctx.SetStatusCode(fasthttp.StatusInternalServerError)
+				_, _ = ctx.WriteString("template " + templateName + " not exists")
+			}
+		}
+	}
+}

internal/http/core/formats.go

@@ -0,0 +1,102 @@
+package core
+
+import (
+	"bytes"
+	"sort"
+	"strconv"
+
+	"github.com/valyala/fasthttp"
+)
+
+type ContentType = byte
+
+const (
+	UnknownContentType ContentType = iota // should be first
+	JSONContentType
+	XMLContentType
+	HTMLContentType
+	PlainTextContentType
+)
+
+func ClientWantFormat(ctx *fasthttp.RequestCtx) ContentType {
+	// parse "Content-Type" header (e.g.: `application/json;charset=UTF-8`)
+	if ct := bytes.ToLower(ctx.Request.Header.ContentType()); len(ct) > 4 { //nolint:gomnd
+		return mimeTypeToContentType(ct)
+	}
+
+	// parse `X-Format` header (aka `Accept`) for the Ingress support
+	// e.g.: `text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8`
+	if h := bytes.ToLower(bytes.TrimSpace(ctx.Request.Header.Peek(FormatHeader))); len(h) > 2 { //nolint:gomnd,nestif
+		type format struct {
+			mimeType []byte
+			weight   float32
+		}
+
+		var formats = make([]format, 0, 8) //nolint:gomnd
+
+		for _, b := range bytes.FieldsFunc(h, func(r rune) bool { return r == ',' }) {
+			if idx := bytes.Index(b, []byte(";q=")); idx > 0 && idx < len(b) {
+				f := format{b[0:idx], 0}
+
+				if len(b) > idx+3 {
+					if weight, err := strconv.ParseFloat(string(b[idx+3:]), 32); err == nil {
+						f.weight = float32(weight)
+					}
+				}
+
+				formats = append(formats, f)
+			} else {
+				formats = append(formats, format{b, 1})
+			}
+		}
+
+		switch l := len(formats); {
+		case l == 0:
+			return UnknownContentType
+
+		case l == 1:
+			return mimeTypeToContentType(formats[0].mimeType)
+
+		default:
+			sort.SliceStable(formats, func(i, j int) bool { return formats[i].weight > formats[j].weight })
+
+			return mimeTypeToContentType(formats[0].mimeType)
+		}
+	}
+
+	return UnknownContentType
+}
+
+func mimeTypeToContentType(mimeType []byte) ContentType {
+	switch {
+	case bytes.Contains(mimeType, []byte("application/json")), bytes.Contains(mimeType, []byte("text/json")):
+		return JSONContentType
+
+	case bytes.Contains(mimeType, []byte("application/xml")), bytes.Contains(mimeType, []byte("text/xml")):
+		return XMLContentType
+
+	case bytes.Contains(mimeType, []byte("text/html")):
+		return HTMLContentType
+
+	case bytes.Contains(mimeType, []byte("text/plain")):
+		return PlainTextContentType
+	}
+
+	return UnknownContentType
+}
+
+func SetClientFormat(ctx *fasthttp.RequestCtx, t ContentType) {
+	switch t {
+	case JSONContentType:
+		ctx.SetContentType("application/json; charset=utf-8")
+
+	case XMLContentType:
+		ctx.SetContentType("application/xml; charset=utf-8")
+
+	case HTMLContentType:
+		ctx.SetContentType("text/html; charset=utf-8")
+
+	case PlainTextContentType:
+		ctx.SetContentType("text/plain; charset=utf-8")
+	}
+}

internal/http/core/formats_test.go

@@ -0,0 +1,118 @@
+package core_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/valyala/fasthttp"
+
+	"gh.tarampamp.am/error-pages/internal/http/core"
+)
+
+func TestClientWantFormat(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveContentTypeHeader string
+		giveFormatHeader      string
+		giveReqCtx            func() *fasthttp.RequestCtx
+		wantFormat            core.ContentType
+	}{
+		"priority": {
+			giveFormatHeader:      "application/xml",
+			giveContentTypeHeader: "text/plain",
+			wantFormat:            core.PlainTextContentType,
+		},
+		"format respects weight": {
+			giveFormatHeader: "text/html;q=0.5,application/xhtml+xml;q=0.9,application/xml;q=1,*/*;q=0.8",
+			wantFormat:       core.XMLContentType,
+		},
+		"wrong format value": {
+			giveFormatHeader: ";q=foobar,bar/baz;;;;;application/xml",
+			wantFormat:       core.UnknownContentType,
+		},
+
+		"content type - application/json": {
+			giveContentTypeHeader: "application/jsoN; charset=utf-8", wantFormat: core.JSONContentType,
+		},
+		"content type - text/json": {
+			giveContentTypeHeader: "text/Json; charset=utf-8", wantFormat: core.JSONContentType,
+		},
+		"format - json": {
+			giveFormatHeader: "application/jsoN,*/*;q=0.8", wantFormat: core.JSONContentType,
+		},
+
+		"content type - application/xml": {
+			giveContentTypeHeader: "application/xmL; charset=utf-8", wantFormat: core.XMLContentType,
+		},
+		"content type - text/xml": {
+			giveContentTypeHeader: "text/Xml; charset=utf-8", wantFormat: core.XMLContentType,
+		},
+		"format - xml": {
+			giveFormatHeader: "text/Xml", wantFormat: core.XMLContentType,
+		},
+
+		"content type - text/html": {
+			giveContentTypeHeader: "text/htMl; charset=utf-8", wantFormat: core.HTMLContentType,
+		},
+		"format - html": {
+			giveFormatHeader: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+			wantFormat:       core.HTMLContentType,
+		},
+
+		"content type - text/plain": {
+			giveContentTypeHeader: "text/plaiN; charset=utf-8", wantFormat: core.PlainTextContentType,
+		},
+		"format - plain": {
+			giveFormatHeader: "text/plaiN,text/html,application/xml;q=0.9,,,*/*;q=0.8", wantFormat: core.PlainTextContentType,
+		},
+
+		"unknown on empty": {
+			wantFormat: core.UnknownContentType,
+		},
+		"unknown on foo/bar": {
+			giveContentTypeHeader: "foo/bar; charset=utf-8",
+			giveFormatHeader:      "foo/bar; charset=utf-8",
+			wantFormat:            core.UnknownContentType,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			h := &fasthttp.RequestHeader{}
+			h.Set(fasthttp.HeaderContentType, tt.giveContentTypeHeader)
+			h.Set(core.FormatHeader, tt.giveFormatHeader)
+
+			ctx := &fasthttp.RequestCtx{
+				Request: fasthttp.Request{
+					Header: *h, //nolint:govet
+				},
+			}
+
+			assert.Equal(t, tt.wantFormat, core.ClientWantFormat(ctx))
+		})
+	}
+}
+
+func TestSetClientFormat(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveContentType core.ContentType
+		wantHeaderValue string
+	}{
+		"plain on unknown": {giveContentType: core.UnknownContentType, wantHeaderValue: "text/plain; charset=utf-8"},
+		"json":             {giveContentType: core.JSONContentType, wantHeaderValue: "application/json; charset=utf-8"},
+		"xml":              {giveContentType: core.XMLContentType, wantHeaderValue: "application/xml; charset=utf-8"},
+		"html":             {giveContentType: core.HTMLContentType, wantHeaderValue: "text/html; charset=utf-8"},
+		"plain":            {giveContentType: core.PlainTextContentType, wantHeaderValue: "text/plain; charset=utf-8"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			ctx := &fasthttp.RequestCtx{
+				Response: fasthttp.Response{
+					Header: fasthttp.ResponseHeader{},
+				},
+			}
+
+			assert.Empty(t, "", ctx.Response.Header.Peek(fasthttp.HeaderContentType))
+
+			core.SetClientFormat(ctx, tt.giveContentType)
+
+			assert.Equal(t, tt.wantHeaderValue, string(ctx.Response.Header.Peek(fasthttp.HeaderContentType)))
+		})
+	}
+}

internal/http/core/headers.go

@@ -0,0 +1,33 @@
+package core
+
+const (
+	// FormatHeader name of the header used to extract the format
+	FormatHeader = "X-Format"
+
+	// CodeHeader name of the header used as source of the HTTP status code to return
+	CodeHeader = "X-Code"
+
+	// OriginalURI name of the header with the original URL from NGINX
+	OriginalURI = "X-Original-URI"
+
+	// Namespace name of the header that contains information about the Ingress namespace
+	Namespace = "X-Namespace"
+
+	// IngressName name of the header that contains the matched Ingress
+	IngressName = "X-Ingress-Name"
+
+	// ServiceName name of the header that contains the matched Service in the Ingress
+	ServiceName = "X-Service-Name"
+
+	// ServicePort name of the header that contains the matched Service port in the Ingress
+	ServicePort = "X-Service-Port"
+
+	// RequestID is a unique ID that identifies the request - same as for backend service
+	RequestID = "X-Request-ID"
+
+	// ForwardedFor identifies the user of this session
+	ForwardedFor = "X-Forwarded-For"
+
+	// Host identifies the hosts origin
+	Host = "Host"
+)

internal/http/handlers/errorpage/handler.go

@@ -0,0 +1,35 @@
+package errorpage
+
+import (
+	"github.com/valyala/fasthttp"
+
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/http/core"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+type (
+	templatePicker interface {
+		// Pick the template name for responding.
+		Pick() string
+	}
+
+	renderer interface {
+		Render(content []byte, props tpl.Properties) ([]byte, error)
+	}
+)
+
+// NewHandler creates handler for error pages serving.
+func NewHandler(cfg *config.Config, p templatePicker, rdr renderer, opt options.ErrorPage) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		core.SetClientFormat(ctx, core.PlainTextContentType) // default content type
+
+		if code, ok := ctx.UserValue("code").(string); ok {
+			core.RespondWithErrorPage(ctx, cfg, p, rdr, code, fasthttp.StatusOK, opt)
+		} else { // will never occur
+			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
+			_, _ = ctx.WriteString("cannot extract requested code from the request")
+		}
+	}
+}

internal/http/handlers/errorpage/handler_test.go

@@ -0,0 +1,7 @@
+package errorpage_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/handlers/healthz/handler.go

@@ -0,0 +1,24 @@
+package healthz
+
+import "github.com/valyala/fasthttp"
+
+// checker allows to check some service part.
+type checker interface {
+	// Check makes a check and return error only if something is wrong.
+	Check() error
+}
+
+// NewHandler creates healthcheck handler.
+func NewHandler(checker checker) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		if err := checker.Check(); err != nil {
+			ctx.SetStatusCode(fasthttp.StatusServiceUnavailable)
+			_, _ = ctx.WriteString(err.Error())
+
+			return
+		}
+
+		ctx.SetStatusCode(fasthttp.StatusOK)
+		_, _ = ctx.WriteString("OK")
+	}
+}

internal/http/handlers/healthz/handler_test.go

@@ -0,0 +1,7 @@
+package healthz_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/handlers/index/handler.go

@@ -0,0 +1,50 @@
+package index
+
+import (
+	"strconv"
+
+	"github.com/valyala/fasthttp"
+
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/http/core"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+type (
+	templatePicker interface {
+		// Pick the template name for responding.
+		Pick() string
+	}
+
+	renderer interface {
+		Render(content []byte, props tpl.Properties) ([]byte, error)
+	}
+)
+
+// NewHandler creates handler for the index page serving.
+func NewHandler(cfg *config.Config, p templatePicker, rdr renderer, opt options.ErrorPage) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		pageCode, httpCode := opt.Default.PageCode, int(opt.Default.HTTPCode)
+
+		if returnCode, ok := extractCodeToReturn(ctx); ok {
+			pageCode, httpCode = strconv.Itoa(returnCode), returnCode
+		}
+
+		core.RespondWithErrorPage(ctx, cfg, p, rdr, pageCode, httpCode, opt)
+	}
+}
+
+func extractCodeToReturn(ctx *fasthttp.RequestCtx) (int, bool) { // for the Ingress support
+	var ch = ctx.Request.Header.Peek(core.CodeHeader)
+
+	if len(ch) > 0 && len(ch) <= 3 {
+		if code, err := strconv.Atoi(string(ch)); err == nil {
+			if code > 0 && code <= 599 {
+				return code, true
+			}
+		}
+	}
+
+	return 0, false
+}

internal/http/handlers/index/handler_test.go

@@ -0,0 +1,7 @@
+package index_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/handlers/metrics/handler.go

@@ -0,0 +1,16 @@
+// Package metrics contains HTTP handler for application metrics (prometheus format) generation.
+package metrics
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/valyala/fasthttp"
+	"github.com/valyala/fasthttp/fasthttpadaptor"
+)
+
+// NewHandler creates metrics handler.
+func NewHandler(registry prometheus.Gatherer) fasthttp.RequestHandler {
+	return fasthttpadaptor.NewFastHTTPHandler(
+		promhttp.HandlerFor(registry, promhttp.HandlerOpts{ErrorHandling: promhttp.ContinueOnError}),
+	)
+}

internal/http/handlers/metrics/handler_test.go

@@ -0,0 +1,7 @@
+package metrics_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/handlers/notfound/handler.go

@@ -0,0 +1,28 @@
+package notfound
+
+import (
+	"github.com/valyala/fasthttp"
+
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/http/core"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+type (
+	templatePicker interface {
+		// Pick the template name for responding.
+		Pick() string
+	}
+
+	renderer interface {
+		Render(content []byte, props tpl.Properties) ([]byte, error)
+	}
+)
+
+// NewHandler creates handler missing requests handling.
+func NewHandler(cfg *config.Config, p templatePicker, rdr renderer, opt options.ErrorPage) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		core.RespondWithErrorPage(ctx, cfg, p, rdr, "404", fasthttp.StatusNotFound, opt)
+	}
+}

internal/http/handlers/notfound/handler_test.go

@@ -0,0 +1,7 @@
+package notfound_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/handlers/version/handler.go

@@ -0,0 +1,26 @@
+package version
+
+import (
+	"encoding/json"
+
+	"github.com/valyala/fasthttp"
+)
+
+// NewHandler creates version handler.
+func NewHandler(ver string) fasthttp.RequestHandler {
+	var cache []byte
+
+	return func(ctx *fasthttp.RequestCtx) {
+		if cache == nil {
+			cache, _ = json.Marshal(struct {
+				Version string `json:"version"`
+			}{
+				Version: ver,
+			})
+		}
+
+		ctx.SetContentType("application/json")
+		ctx.SetStatusCode(fasthttp.StatusOK)
+		_, _ = ctx.Write(cache)
+	}
+}

internal/http/handlers/version/handler_test.go

@@ -0,0 +1,7 @@
+package version_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/http/server.go

@@ -0,0 +1,131 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"time"
+
+	"github.com/fasthttp/router"
+	"github.com/valyala/fasthttp"
+	"go.uber.org/zap"
+
+	"gh.tarampamp.am/error-pages/internal/checkers"
+	"gh.tarampamp.am/error-pages/internal/config"
+	"gh.tarampamp.am/error-pages/internal/http/common"
+	errorpageHandler "gh.tarampamp.am/error-pages/internal/http/handlers/errorpage"
+	healthzHandler "gh.tarampamp.am/error-pages/internal/http/handlers/healthz"
+	indexHandler "gh.tarampamp.am/error-pages/internal/http/handlers/index"
+	metricsHandler "gh.tarampamp.am/error-pages/internal/http/handlers/metrics"
+	notfoundHandler "gh.tarampamp.am/error-pages/internal/http/handlers/notfound"
+	versionHandler "gh.tarampamp.am/error-pages/internal/http/handlers/version"
+	"gh.tarampamp.am/error-pages/internal/metrics"
+	"gh.tarampamp.am/error-pages/internal/options"
+	"gh.tarampamp.am/error-pages/internal/tpl"
+	"gh.tarampamp.am/error-pages/internal/version"
+)
+
+type Server struct {
+	log    *zap.Logger
+	fast   *fasthttp.Server
+	router *router.Router
+	rdr    *tpl.TemplateRenderer
+}
+
+const (
+	defaultWriteTimeout = time.Second * 4
+	defaultReadTimeout  = time.Second * 4
+	defaultIdleTimeout  = time.Second * 6
+)
+
+func NewServer(log *zap.Logger, readBufferSize uint) Server {
+	rdr := tpl.NewTemplateRenderer()
+
+	return Server{
+		// fasthttp docs: <https://github.com/valyala/fasthttp>
+		fast: &fasthttp.Server{
+			WriteTimeout:          defaultWriteTimeout,
+			ReadBufferSize:        int(readBufferSize),
+			ReadTimeout:           defaultReadTimeout,
+			IdleTimeout:           defaultIdleTimeout,
+			NoDefaultServerHeader: true,
+			ReduceMemoryUsage:     true,
+			CloseOnShutdown:       true,
+			Logger:                zap.NewStdLog(log),
+		},
+		router: router.New(),
+		log:    log,
+		rdr:    rdr,
+	}
+}
+
+// Start server.
+func (s *Server) Start(ip string, port uint16) (err error) {
+	if net.ParseIP(ip) == nil {
+		return errors.New("invalid IP address")
+	}
+
+	var ln net.Listener
+
+	if strings.Count(ip, ":") >= 2 { //nolint:gomnd // ipv6
+		if ln, err = net.Listen("tcp6", fmt.Sprintf("[%s]:%d", ip, port)); err != nil {
+			return err
+		}
+	} else { // ipv4
+		if ln, err = net.Listen("tcp4", fmt.Sprintf("%s:%d", ip, port)); err != nil {
+			return err
+		}
+	}
+
+	return s.fast.Serve(ln)
+}
+
+type templatePicker interface {
+	// Pick the template name for responding.
+	Pick() string
+}
+
+// Register server routes, middlewares, etc.
+// Router docs: <https://github.com/fasthttp/router>
+func (s *Server) Register(cfg *config.Config, templatePicker templatePicker, opt options.ErrorPage) error {
+	reg, m := metrics.NewRegistry(), metrics.NewMetrics()
+
+	if err := m.Register(reg); err != nil {
+		return err
+	}
+
+	s.fast.Handler = common.DurationMetrics(common.LogRequest(s.router.Handler, s.log), &m)
+
+	s.router.GET("/", indexHandler.NewHandler(cfg, templatePicker, s.rdr, opt))
+	s.router.GET("/{code}.html", errorpageHandler.NewHandler(cfg, templatePicker, s.rdr, opt))
+
+	s.router.GET("/version", versionHandler.NewHandler(version.Version()))
+
+	liveHandler := healthzHandler.NewHandler(checkers.NewLiveChecker())
+	s.router.ANY("/healthz", liveHandler)
+	s.router.ANY("/health/live", liveHandler) // deprecated
+
+	s.router.GET("/metrics", metricsHandler.NewHandler(reg))
+
+	// use index handler to catch all paths? Uses DEFAULT_ERROR_PAGE
+	if opt.CatchAll {
+		s.router.NotFound = indexHandler.NewHandler(cfg, templatePicker, s.rdr, opt)
+	} else {
+		// use default not found handler
+		s.router.NotFound = notfoundHandler.NewHandler(cfg, templatePicker, s.rdr, opt)
+	}
+
+	return nil
+}
+
+// Stop server.
+func (s *Server) Stop() error {
+	if err := s.rdr.Close(); err != nil {
+		defer func() { _ = s.fast.Shutdown() }()
+
+		return err
+	}
+
+	return s.fast.Shutdown()
+}

internal/http/server_test.go

@@ -0,0 +1,7 @@
+package http
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

internal/logger/format.go

@@ -0,0 +1,68 @@
+package logger
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A Format is a logging format.
+type Format uint8
+
+const (
+	ConsoleFormat Format = iota // useful for console output (for humans)
+	JSONFormat                  // useful for logging aggregation systems (for robots)
+)
+
+// String returns a lower-case ASCII representation of the log format.
+func (f Format) String() string {
+	switch f {
+	case ConsoleFormat:
+		return "console"
+	case JSONFormat:
+		return "json"
+	}
+
+	return fmt.Sprintf("format(%d)", f)
+}
+
+// Formats returns a slice of all logging formats.
+func Formats() []Format {
+	return []Format{ConsoleFormat, JSONFormat}
+}
+
+// FormatStrings returns a slice of all logging formats as strings.
+func FormatStrings() []string {
+	var (
+		formats = Formats()
+		result  = make([]string, len(formats))
+	)
+
+	for i := range formats {
+		result[i] = formats[i].String()
+	}
+
+	return result
+}
+
+// ParseFormat parses a format (case is ignored) based on the ASCII representation of the log format.
+// If the provided ASCII representation is invalid an error is returned.
+//
+// This is particularly useful when dealing with text input to configure log formats.
+func ParseFormat[T string | []byte](text T) (Format, error) {
+	var format string
+
+	if s, ok := any(text).(string); ok {
+		format = s
+	} else {
+		format = string(any(text).([]byte))
+	}
+
+	switch strings.ToLower(format) {
+	case "console", "": // make the zero value useful
+		return ConsoleFormat, nil
+	case "json":
+		return JSONFormat, nil
+	}
+
+	return Format(0), fmt.Errorf("unrecognized logging format: %q", text)
+}

internal/logger/format_test.go

@@ -0,0 +1,62 @@
+package logger_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"gh.tarampamp.am/error-pages/internal/logger"
+)
+
+func TestFormat_String(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveFormat logger.Format
+		wantString string
+	}{
+		"json":      {giveFormat: logger.JSONFormat, wantString: "json"},
+		"console":   {giveFormat: logger.ConsoleFormat, wantString: "console"},
+		"<unknown>": {giveFormat: logger.Format(255), wantString: "format(255)"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, tt.wantString, tt.giveFormat.String())
+		})
+	}
+}
+
+func TestParseFormat(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveBytes  []byte
+		giveString string
+		wantFormat logger.Format
+		wantError  error
+	}{
+		"<empty value>":          {giveBytes: []byte(""), wantFormat: logger.ConsoleFormat},
+		"<empty value> (string)": {giveString: "", wantFormat: logger.ConsoleFormat},
+		"console":                {giveBytes: []byte("console"), wantFormat: logger.ConsoleFormat},
+		"console (string)":       {giveString: "console", wantFormat: logger.ConsoleFormat},
+		"json":                   {giveBytes: []byte("json"), wantFormat: logger.JSONFormat},
+		"json (string)":          {giveString: "json", wantFormat: logger.JSONFormat},
+		"foobar":                 {giveBytes: []byte("foobar"), wantError: errors.New("unrecognized logging format: \"foobar\"")}, //nolint:lll
+	} {
+		t.Run(name, func(t *testing.T) {
+			var (
+				f   logger.Format
+				err error
+			)
+
+			if tt.giveString != "" {
+				f, err = logger.ParseFormat(tt.giveString)
+			} else {
+				f, err = logger.ParseFormat(tt.giveBytes)
+			}
+
+			if tt.wantError == nil {
+				require.NoError(t, err)
+				require.Equal(t, tt.wantFormat, f)
+			} else {
+				require.EqualError(t, err, tt.wantError.Error())
+			}
+		})
+	}
+}

internal/logger/level.go

@@ -0,0 +1,83 @@
+package logger
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A Level is a logging level.
+type Level int8
+
+const (
+	DebugLevel Level = iota - 1
+	InfoLevel        // default level (zero-value)
+	WarnLevel
+	ErrorLevel
+	FatalLevel
+)
+
+// String returns a lower-case ASCII representation of the log level.
+func (l Level) String() string {
+	switch l {
+	case DebugLevel:
+		return "debug"
+	case InfoLevel:
+		return "info"
+	case WarnLevel:
+		return "warn"
+	case ErrorLevel:
+		return "error"
+	case FatalLevel:
+		return "fatal"
+	}
+
+	return fmt.Sprintf("level(%d)", l)
+}
+
+// Levels returns a slice of all logging levels.
+func Levels() []Level {
+	return []Level{DebugLevel, InfoLevel, WarnLevel, ErrorLevel, FatalLevel}
+}
+
+// LevelStrings returns a slice of all logging levels as strings.
+func LevelStrings() []string {
+	var (
+		levels = Levels()
+		result = make([]string, len(levels))
+	)
+
+	for i := range levels {
+		result[i] = levels[i].String()
+	}
+
+	return result
+}
+
+// ParseLevel parses a level (case is ignored) based on the ASCII representation of the log level.
+// If the provided ASCII representation is invalid an error is returned.
+//
+// This is particularly useful when dealing with text input to configure log levels.
+func ParseLevel[T string | []byte](text T) (Level, error) {
+	var lvl string
+
+	if s, ok := any(text).(string); ok {
+		lvl = s
+	} else {
+		lvl = string(any(text).([]byte))
+	}
+
+	switch strings.ToLower(lvl) {
+	case "debug", "verbose", "trace":
+		return DebugLevel, nil
+	case "info", "": // make the zero value useful
+		return InfoLevel, nil
+	case "warn":
+		return WarnLevel, nil
+	case "error":
+		return ErrorLevel, nil
+	case "fatal":
+		return FatalLevel, nil
+	}
+
+	return Level(0), fmt.Errorf("unrecognized logging level: %q", text)
+}

internal/logger/level_test.go

@@ -0,0 +1,84 @@
+package logger_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"gh.tarampamp.am/error-pages/internal/logger"
+)
+
+func TestLevel_String(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveLevel  logger.Level
+		wantString string
+	}{
+		"debug":     {giveLevel: logger.DebugLevel, wantString: "debug"},
+		"info":      {giveLevel: logger.InfoLevel, wantString: "info"},
+		"warn":      {giveLevel: logger.WarnLevel, wantString: "warn"},
+		"error":     {giveLevel: logger.ErrorLevel, wantString: "error"},
+		"fatal":     {giveLevel: logger.FatalLevel, wantString: "fatal"},
+		"<unknown>": {giveLevel: logger.Level(127), wantString: "level(127)"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, tt.wantString, tt.giveLevel.String())
+		})
+	}
+}
+
+func TestParseLevel(t *testing.T) {
+	for name, tt := range map[string]struct {
+		giveBytes  []byte
+		giveString string
+		wantLevel  logger.Level
+		wantError  error
+	}{
+		"<empty value>":          {giveBytes: []byte(""), wantLevel: logger.InfoLevel},
+		"<empty value> (string)": {giveString: "", wantLevel: logger.InfoLevel},
+		"trace":                  {giveBytes: []byte("debug"), wantLevel: logger.DebugLevel},
+		"verbose":                {giveBytes: []byte("debug"), wantLevel: logger.DebugLevel},
+		"debug":                  {giveBytes: []byte("debug"), wantLevel: logger.DebugLevel},
+		"debug (string)":         {giveString: "debug", wantLevel: logger.DebugLevel},
+		"info":                   {giveBytes: []byte("info"), wantLevel: logger.InfoLevel},
+		"warn":                   {giveBytes: []byte("warn"), wantLevel: logger.WarnLevel},
+		"error":                  {giveBytes: []byte("error"), wantLevel: logger.ErrorLevel},
+		"fatal":                  {giveBytes: []byte("fatal"), wantLevel: logger.FatalLevel},
+		"fatal (string)":         {giveString: "fatal", wantLevel: logger.FatalLevel},
+		"foobar":                 {giveBytes: []byte("foobar"), wantError: errors.New("unrecognized logging level: \"foobar\"")}, //nolint:lll
+	} {
+		t.Run(name, func(t *testing.T) {
+			var (
+				l   logger.Level
+				err error
+			)
+
+			if tt.giveString != "" {
+				l, err = logger.ParseLevel(tt.giveString)
+			} else {
+				l, err = logger.ParseLevel(tt.giveBytes)
+			}
+
+			if tt.wantError == nil {
+				require.NoError(t, err)
+				require.Equal(t, tt.wantLevel, l)
+			} else {
+				require.EqualError(t, err, tt.wantError.Error())
+			}
+		})
+	}
+}
+
+func TestLevels(t *testing.T) {
+	require.Equal(t, []logger.Level{
+		logger.DebugLevel,
+		logger.InfoLevel,
+		logger.WarnLevel,
+		logger.ErrorLevel,
+		logger.FatalLevel,
+	}, logger.Levels())
+}
+
+func TestLevelStrings(t *testing.T) {
+	require.Equal(t, []string{"debug", "info", "warn", "error", "fatal"}, logger.LevelStrings())
+}

internal/logger/logger.go

@@ -0,0 +1,61 @@
+// Package logger contains functions for a working with application logging.
+package logger
+
+import (
+	"errors"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// New creates new "zap" logger with a small customization.
+func New(l Level, f Format) (*zap.Logger, error) {
+	var config zap.Config
+
+	switch f {
+	case ConsoleFormat:
+		config = zap.NewDevelopmentConfig()
+		config.EncoderConfig.EncodeLevel = zapcore.LowercaseColorLevelEncoder
+		config.EncoderConfig.EncodeTime = zapcore.TimeEncoderOfLayout("15:04:05")
+
+	case JSONFormat:
+		config = zap.NewProductionConfig() // json encoder is used by default
+
+	default:
+		return nil, errors.New("unsupported logging format")
+	}
+
+	// default configuration for all encoders
+	config.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
+	config.Development = false
+	config.DisableStacktrace = true
+	config.DisableCaller = true
+
+	// enable additional features for debugging
+	if l <= DebugLevel {
+		config.Development = true
+		config.DisableStacktrace = false
+		config.DisableCaller = false
+	}
+
+	var zapLvl zapcore.Level
+
+	switch l { // convert level to zap.Level
+	case DebugLevel:
+		zapLvl = zap.DebugLevel
+	case InfoLevel:
+		zapLvl = zap.InfoLevel
+	case WarnLevel:
+		zapLvl = zap.WarnLevel
+	case ErrorLevel:
+		zapLvl = zap.ErrorLevel
+	case FatalLevel:
+		zapLvl = zap.FatalLevel
+	default:
+		return nil, errors.New("unsupported logging level")
+	}
+
+	config.Level = zap.NewAtomicLevelAt(zapLvl)
+
+	return config.Build()
+}

internal/logger/logger_test.go

@@ -0,0 +1,75 @@
+package logger_test
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"gh.tarampamp.am/error-pages/internal/logger"
+)
+
+func TestNewDebugLevelConsoleFormat(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(logger.DebugLevel, logger.ConsoleFormat)
+		require.NoError(t, err)
+
+		log.Debug("dbg msg")
+		log.Info("inf msg")
+		log.Error("err msg")
+	})
+
+	assert.Contains(t, output, time.Now().Format("15:04:05"))
+	assert.Regexp(t, `\t.+info.+\tinf msg`, output)
+	assert.Regexp(t, `\t.+info.+\t.+logger_test\.go:\d+\tinf msg`, output)
+	assert.Contains(t, output, "dbg msg")
+	assert.Contains(t, output, "err msg")
+}
+
+func TestNewErrorLevelConsoleFormat(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(logger.ErrorLevel, logger.ConsoleFormat)
+		require.NoError(t, err)
+
+		log.Debug("dbg msg")
+		log.Info("inf msg")
+		log.Error("err msg")
+	})
+
+	assert.NotContains(t, output, "inf msg")
+	assert.NotContains(t, output, "dbg msg")
+	assert.Contains(t, output, "err msg")
+}
+
+func TestNewWarnLevelJSONFormat(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(logger.WarnLevel, logger.JSONFormat)
+		require.NoError(t, err)
+
+		log.Debug("dbg msg")
+		log.Info("inf msg")
+		log.Warn("warn msg")
+		log.Error("err msg")
+	})
+
+	// replace timestamp field with fixed value
+	fakeTimestamp := regexp.MustCompile(`"ts":\d+\.\d+,`)
+	output = fakeTimestamp.ReplaceAllString(output, `"ts":0.1,`)
+
+	lines := strings.Split(strings.Trim(output, "\n"), "\n")
+
+	assert.JSONEq(t, `{"level":"warn","ts":0.1,"msg":"warn msg"}`, lines[0])
+	assert.JSONEq(t, `{"level":"error","ts":0.1,"msg":"err msg"}`, lines[1])
+}
+
+func TestNewErrors(t *testing.T) {
+	_, err := logger.New(logger.Level(127), logger.ConsoleFormat)
+	require.EqualError(t, err, "unsupported logging level")
+
+	_, err = logger.New(logger.WarnLevel, logger.Format(255))
+	require.EqualError(t, err, "unsupported logging format")
+}

internal/metrics/metrics.go

@@ -0,0 +1,52 @@
+package metrics
+
+import (
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type Metrics struct {
+	total    prometheus.Counter
+	duration prometheus.Histogram
+}
+
+// NewMetrics creates new Metrics collector.
+func NewMetrics() Metrics {
+	const namespace, subsystem = "http", "requests"
+
+	return Metrics{
+		total: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: subsystem,
+			Name:      "total_count",
+			Help:      "Counter of HTTP requests made.",
+		}),
+		duration: prometheus.NewHistogram(prometheus.HistogramOpts{
+			Namespace: namespace,
+			Subsystem: subsystem,
+			Name:      "duration_milliseconds",
+			Help:      "Histogram of the time (in milliseconds) each request took.",
+			Buckets:   append([]float64{.001, .003}, prometheus.DefBuckets...),
+		}),
+	}
+}
+
+// IncrementTotalRequests increments total requests counter.
+func (w *Metrics) IncrementTotalRequests() { w.total.Inc() }
+
+// ObserveRequestDuration observer requests duration histogram.
+func (w *Metrics) ObserveRequestDuration(t time.Duration) { w.duration.Observe(t.Seconds()) }
+
+// Register metrics with registerer.
+func (w *Metrics) Register(reg prometheus.Registerer) error {
+	if err := reg.Register(w.total); err != nil {
+		return err
+	}
+
+	if err := reg.Register(w.duration); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/metrics/metrics_test.go

@@ -0,0 +1,71 @@
+package metrics_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	dto "github.com/prometheus/client_model/go"
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/metrics"
+)
+
+func TestMetrics_Register(t *testing.T) {
+	var (
+		registry = prometheus.NewRegistry()
+		m        = metrics.NewMetrics()
+	)
+
+	assert.NoError(t, m.Register(registry))
+
+	count, err := testutil.GatherAndCount(registry,
+		"http_requests_total_count",
+		"http_requests_duration_milliseconds",
+	)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 2, count)
+}
+
+func TestMetrics_IncrementTotalRequests(t *testing.T) {
+	p := metrics.NewMetrics()
+
+	p.IncrementTotalRequests()
+
+	metric := getMetric(t, &p, "http_requests_total_count")
+	assert.Equal(t, float64(1), metric.Counter.GetValue())
+}
+
+func TestMetrics_ObserveRequestDuration(t *testing.T) {
+	p := metrics.NewMetrics()
+
+	p.ObserveRequestDuration(time.Second)
+
+	metric := getMetric(t, &p, "http_requests_duration_milliseconds")
+	assert.Equal(t, float64(1), metric.Histogram.GetSampleSum())
+}
+
+type registerer interface {
+	Register(prometheus.Registerer) error
+}
+
+func getMetric(t *testing.T, reg registerer, name string) *dto.Metric {
+	t.Helper()
+
+	registry := prometheus.NewRegistry()
+	_ = reg.Register(registry)
+
+	families, _ := registry.Gather()
+
+	for _, family := range families {
+		if family.GetName() == name {
+			return family.Metric[0]
+		}
+	}
+
+	assert.FailNowf(t, "cannot resolve metric for: %s", name)
+
+	return nil
+}

internal/metrics/registry.go

@@ -0,0 +1,20 @@
+// Package metrics contains custom prometheus metrics and registry factories.
+package metrics
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/collectors"
+)
+
+// NewRegistry creates new prometheus registry with pre-registered common collectors.
+func NewRegistry() *prometheus.Registry {
+	registry := prometheus.NewRegistry()
+
+	// register common metric collectors
+	registry.MustRegister(
+		// collectors.NewGoCollector(),
+		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
+	)
+
+	return registry
+}

internal/metrics/registry_test.go

@@ -0,0 +1,19 @@
+package metrics_test
+
+import (
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/metrics"
+)
+
+func TestNewRegistry(t *testing.T) {
+	registry := metrics.NewRegistry()
+
+	count, err := testutil.GatherAndCount(registry)
+
+	assert.NoError(t, err)
+	assert.True(t, count >= 6, "not enough common metrics")
+}

internal/options/errorpage.go

@@ -0,0 +1,17 @@
+package options
+
+type ErrorPage struct {
+	Default struct {
+		PageCode string // default error page code
+		HTTPCode uint16 // default HTTP response code
+	}
+	L10n struct {
+		Disabled bool // disable error pages localization
+	}
+	Template struct {
+		Name string // template name
+	}
+	ShowDetails      bool     // show request details in response
+	ProxyHTTPHeaders []string // proxy HTTP request headers list
+	CatchAll         bool     // catch all pages
+}

internal/pick/picker.go

@@ -0,0 +1,88 @@
+package pick
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+type pickMode = byte
+
+const (
+	First           pickMode = 1 + iota // Always pick the first element (index = 0)
+	RandomOnce                          // Pick random element once (any future Pick calls will return the same element)
+	RandomEveryTime                     // Always Pick the random element
+)
+
+type picker struct {
+	mode   pickMode
+	rand   *rand.Rand // will be nil for the First pick mode
+	maxIdx uint32
+
+	mu      sync.Mutex
+	lastIdx uint32
+}
+
+const unsetIdx uint32 = 4294967295
+
+func NewPicker(maxIdx uint32, mode pickMode) *picker {
+	var p = &picker{
+		maxIdx:  maxIdx,
+		mode:    mode,
+		lastIdx: unsetIdx,
+	}
+
+	if mode != First {
+		p.rand = rand.New(rand.NewSource(time.Now().UnixNano())) //nolint:gosec
+	}
+
+	return p
+}
+
+// NextIndex returns an index for the next element (based on pickMode).
+func (p *picker) NextIndex() uint32 {
+	if p.maxIdx == 0 {
+		return 0
+	}
+
+	switch p.mode {
+	case First:
+		return 0
+
+	case RandomOnce:
+		if p.lastIdx == unsetIdx {
+			return p.randomizeNext()
+		}
+
+		return p.lastIdx
+
+	case RandomEveryTime:
+		return p.randomizeNext()
+
+	default:
+		panic("picker.NextIndex(): unsupported mode")
+	}
+}
+
+func (p *picker) randomizeNext() uint32 {
+	var idx = uint32(p.rand.Intn(int(p.maxIdx + 1)))
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if idx == p.lastIdx {
+		p.lastIdx++
+	} else {
+		p.lastIdx = idx
+	}
+
+	if p.lastIdx > p.maxIdx { // overflow?
+		p.lastIdx = 0
+	}
+
+	if p.lastIdx == unsetIdx {
+		p.lastIdx--
+	}
+
+	return p.lastIdx
+}

internal/pick/picker_test.go

@@ -0,0 +1,58 @@
+package pick_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/pick"
+)
+
+func TestPicker_NextIndex_First(t *testing.T) {
+	for i := uint32(0); i < 100; i++ {
+		p := pick.NewPicker(i, pick.First)
+
+		for j := uint8(0); j < 100; j++ {
+			assert.Equal(t, uint32(0), p.NextIndex())
+		}
+	}
+}
+
+func TestPicker_NextIndex_RandomOnce(t *testing.T) {
+	for i := uint8(0); i < 10; i++ {
+		assert.Equal(t, uint32(0), pick.NewPicker(0, pick.RandomOnce).NextIndex())
+	}
+
+	for i := uint8(10); i < 100; i++ {
+		p := pick.NewPicker(uint32(i), pick.RandomOnce)
+
+		next := p.NextIndex()
+		assert.LessOrEqual(t, next, uint32(i))
+
+		for j := uint8(0); j < 100; j++ {
+			assert.Equal(t, next, p.NextIndex())
+		}
+	}
+}
+
+func TestPicker_NextIndex_RandomEveryTime(t *testing.T) {
+	for i := uint8(0); i < 10; i++ {
+		assert.Equal(t, uint32(0), pick.NewPicker(0, pick.RandomEveryTime).NextIndex())
+	}
+
+	for i := uint8(1); i < 100; i++ {
+		p := pick.NewPicker(uint32(i), pick.RandomEveryTime)
+
+		for j := uint8(0); j < 100; j++ {
+			one, two := p.NextIndex(), p.NextIndex()
+
+			assert.LessOrEqual(t, one, uint32(i))
+			assert.LessOrEqual(t, two, uint32(i))
+			assert.NotEqual(t, one, two)
+		}
+	}
+}
+
+func TestPicker_NextIndex_Unsupported(t *testing.T) {
+	assert.Panics(t, func() { pick.NewPicker(1, 255).NextIndex() })
+}

internal/pick/strings_slice.go

@@ -0,0 +1,135 @@
+package pick
+
+import (
+	"errors"
+	"sync"
+	"time"
+)
+
+type StringsSlice struct {
+	s []string
+	p *picker
+}
+
+// NewStringsSlice creates new StringsSlice.
+func NewStringsSlice(items []string, mode pickMode) *StringsSlice {
+	maxIdx := len(items) - 1
+
+	if maxIdx < 0 {
+		maxIdx = 0
+	}
+
+	return &StringsSlice{s: items, p: NewPicker(uint32(maxIdx), mode)}
+}
+
+// Pick an element from the strings slice.
+func (s *StringsSlice) Pick() string {
+	if len(s.s) == 0 {
+		return ""
+	}
+
+	return s.s[s.p.NextIndex()]
+}
+
+type StringsSliceWithInterval struct {
+	s []string
+	p *picker
+	d time.Duration
+
+	idxMu sync.RWMutex
+	idx   uint32
+
+	close    chan struct{}
+	closedMu sync.RWMutex
+	closed   bool
+}
+
+// NewStringsSliceWithInterval creates new StringsSliceWithInterval.
+func NewStringsSliceWithInterval(items []string, mode pickMode, interval time.Duration) *StringsSliceWithInterval {
+	maxIdx := len(items) - 1
+
+	if maxIdx < 0 {
+		maxIdx = 0
+	}
+
+	if interval <= time.Duration(0) {
+		panic("NewStringsSliceWithInterval: wrong interval")
+	}
+
+	s := &StringsSliceWithInterval{
+		s:     items,
+		p:     NewPicker(uint32(maxIdx), mode),
+		d:     interval,
+		close: make(chan struct{}, 1),
+	}
+
+	s.next()
+
+	go s.rotate()
+
+	return s
+}
+
+func (s *StringsSliceWithInterval) rotate() {
+	defer close(s.close)
+
+	timer := time.NewTimer(s.d)
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-s.close:
+			return
+
+		case <-timer.C:
+			s.next()
+			timer.Reset(s.d)
+		}
+	}
+}
+
+func (s *StringsSliceWithInterval) next() {
+	idx := s.p.NextIndex()
+
+	s.idxMu.Lock()
+	s.idx = idx
+	s.idxMu.Unlock()
+}
+
+// Pick an element from the strings slice.
+func (s *StringsSliceWithInterval) Pick() string {
+	if s.isClosed() {
+		panic("StringsSliceWithInterval.Pick(): closed")
+	}
+
+	if len(s.s) == 0 {
+		return ""
+	}
+
+	s.idxMu.RLock()
+	defer s.idxMu.RUnlock()
+
+	return s.s[s.idx]
+}
+
+func (s *StringsSliceWithInterval) isClosed() (closed bool) {
+	s.closedMu.RLock()
+	closed = s.closed
+	s.closedMu.RUnlock()
+
+	return
+}
+
+func (s *StringsSliceWithInterval) Close() error {
+	if s.isClosed() {
+		return errors.New("closed")
+	}
+
+	s.closedMu.Lock()
+	s.closed = true
+	s.closedMu.Unlock()
+
+	s.close <- struct{}{}
+
+	return nil
+}

internal/pick/strings_slice_test.go

@@ -0,0 +1,131 @@
+package pick_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/pick"
+)
+
+func TestStringsSlice_Pick(t *testing.T) {
+	t.Run("first", func(t *testing.T) {
+		for i := uint8(0); i < 100; i++ {
+			assert.Equal(t, "", pick.NewStringsSlice([]string{}, pick.First).Pick())
+		}
+
+		p := pick.NewStringsSlice([]string{"foo", "bar", "baz"}, pick.First)
+
+		for i := uint8(0); i < 100; i++ {
+			assert.Equal(t, "foo", p.Pick())
+		}
+	})
+
+	t.Run("random once", func(t *testing.T) {
+		for i := uint8(0); i < 100; i++ {
+			assert.Equal(t, "", pick.NewStringsSlice([]string{}, pick.RandomOnce).Pick())
+		}
+
+		var (
+			p      = pick.NewStringsSlice([]string{"foo", "bar", "baz"}, pick.RandomOnce)
+			picked = p.Pick()
+		)
+
+		for i := uint8(0); i < 100; i++ {
+			assert.Equal(t, picked, p.Pick())
+		}
+	})
+
+	t.Run("random every time", func(t *testing.T) {
+		for i := uint8(0); i < 100; i++ {
+			assert.Equal(t, "", pick.NewStringsSlice([]string{}, pick.RandomEveryTime).Pick())
+		}
+
+		for i := uint8(0); i < 100; i++ {
+			p := pick.NewStringsSlice([]string{"foo", "bar", "baz"}, pick.RandomEveryTime)
+
+			assert.NotEqual(t, p.Pick(), p.Pick())
+		}
+	})
+}
+
+func TestNewStringsSliceWithInterval_Pick(t *testing.T) {
+	t.Run("first", func(t *testing.T) {
+		for i := uint8(0); i < 50; i++ {
+			p := pick.NewStringsSliceWithInterval([]string{}, pick.First, time.Millisecond)
+			assert.Equal(t, "", p.Pick())
+			assert.NoError(t, p.Close())
+			assert.Panics(t, func() { p.Pick() })
+		}
+
+		p := pick.NewStringsSliceWithInterval([]string{"foo", "bar", "baz"}, pick.First, time.Millisecond)
+
+		for i := uint8(0); i < 50; i++ {
+			assert.Equal(t, "foo", p.Pick())
+
+			<-time.After(time.Millisecond * 2)
+		}
+
+		assert.NoError(t, p.Close())
+		assert.Error(t, p.Close())
+		assert.Panics(t, func() { p.Pick() })
+	})
+
+	t.Run("random once", func(t *testing.T) {
+		for i := uint8(0); i < 50; i++ {
+			p := pick.NewStringsSliceWithInterval([]string{}, pick.RandomOnce, time.Millisecond)
+			assert.Equal(t, "", p.Pick())
+			assert.NoError(t, p.Close())
+			assert.Panics(t, func() { p.Pick() })
+		}
+
+		var (
+			p      = pick.NewStringsSliceWithInterval([]string{"foo", "bar", "baz"}, pick.RandomOnce, time.Millisecond)
+			picked = p.Pick()
+		)
+
+		for i := uint8(0); i < 50; i++ {
+			assert.Equal(t, picked, p.Pick())
+
+			<-time.After(time.Millisecond * 2)
+		}
+
+		assert.NoError(t, p.Close())
+		assert.Error(t, p.Close())
+		assert.Panics(t, func() { p.Pick() })
+	})
+
+	t.Run("random every time", func(t *testing.T) {
+		for i := uint8(0); i < 50; i++ {
+			p := pick.NewStringsSliceWithInterval([]string{}, pick.RandomEveryTime, time.Millisecond)
+			assert.Equal(t, "", p.Pick())
+			assert.NoError(t, p.Close())
+			assert.Panics(t, func() { p.Pick() })
+		}
+
+		var changed int
+
+		for i := uint8(0); i < 50; i++ {
+			p := pick.NewStringsSliceWithInterval([]string{"foo", "bar", "baz"}, pick.RandomEveryTime, time.Millisecond) //nolint:lll
+
+			one, two := p.Pick(), p.Pick()
+			assert.Equal(t, one, two)
+
+			<-time.After(time.Millisecond * 2)
+
+			three, four := p.Pick(), p.Pick()
+			assert.Equal(t, three, four)
+
+			if one != three {
+				changed++
+			}
+
+			assert.NoError(t, p.Close())
+			assert.Error(t, p.Close())
+			assert.Panics(t, func() { p.Pick() })
+		}
+
+		assert.GreaterOrEqual(t, changed, 25)
+	})
+}

internal/tpl/hasher.go

@@ -0,0 +1,25 @@
+package tpl
+
+import (
+	"bytes"
+	"crypto/md5" //nolint:gosec
+	"encoding/gob"
+)
+
+const hashLength = 16 // md5 hash length
+
+type Hash [hashLength]byte
+
+func HashStruct(s interface{}) (Hash, error) {
+	var b bytes.Buffer
+
+	if err := gob.NewEncoder(&b).Encode(s); err != nil {
+		return Hash{}, err
+	}
+
+	return md5.Sum(b.Bytes()), nil //nolint:gosec
+}
+
+func HashBytes(b []byte) Hash {
+	return md5.Sum(b) //nolint:gosec
+}

internal/tpl/hasher_test.go

@@ -0,0 +1,36 @@
+package tpl_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+func TestHashBytes(t *testing.T) {
+	assert.NotEqual(t, tpl.HashBytes([]byte{1}), tpl.HashBytes([]byte{2}))
+}
+
+func TestHashStruct(t *testing.T) {
+	type s struct {
+		S string
+		I int
+		B bool
+	}
+
+	h1, err1 := tpl.HashStruct(s{S: "foo", I: 1, B: false})
+	assert.NoError(t, err1)
+
+	h2, err2 := tpl.HashStruct(s{S: "bar", I: 2, B: true})
+	assert.NoError(t, err2)
+
+	assert.NotEqual(t, h1, h2)
+
+	type p struct { // no exported fields
+		any string
+	}
+
+	_, err := tpl.HashStruct(p{any: "foo"})
+	assert.Error(t, err)
+}

internal/tpl/properties.go

@@ -0,0 +1,40 @@
+package tpl
+
+import (
+	"reflect"
+)
+
+type Properties struct { // only string properties with a "token" tag, please
+	Code               string `token:"code"`
+	Message            string `token:"message"`
+	Description        string `token:"description"`
+	OriginalURI        string `token:"original_uri"`
+	Namespace          string `token:"namespace"`
+	IngressName        string `token:"ingress_name"`
+	ServiceName        string `token:"service_name"`
+	ServicePort        string `token:"service_port"`
+	RequestID          string `token:"request_id"`
+	ForwardedFor       string `token:"forwarded_for"`
+	Host               string `token:"host"`
+	L10nDisabled       bool
+	ShowRequestDetails bool
+}
+
+// Replaces return a map with strings for the replacing, where the map key is a token.
+func (p *Properties) Replaces() map[string]string {
+	var replaces = make(map[string]string, reflect.ValueOf(*p).NumField())
+
+	for i, v := 0, reflect.ValueOf(*p); i < v.NumField(); i++ {
+		if keyword, tagExists := v.Type().Field(i).Tag.Lookup("token"); tagExists {
+			if sv, isString := v.Field(i).Interface().(string); isString && len(sv) > 0 {
+				replaces[keyword] = sv
+			} else {
+				replaces[keyword] = ""
+			}
+		}
+	}
+
+	return replaces
+}
+
+func (p *Properties) Hash() (Hash, error) { return HashStruct(p) }

internal/tpl/properties_test.go

@@ -0,0 +1,67 @@
+package tpl_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+func TestProperties_Replaces(t *testing.T) {
+	props := tpl.Properties{
+		Code:         "foo",
+		Message:      "bar",
+		Description:  "baz",
+		OriginalURI:  "aaa",
+		Namespace:    "bbb",
+		IngressName:  "ccc",
+		ServiceName:  "ddd",
+		ServicePort:  "eee",
+		RequestID:    "fff",
+		ForwardedFor: "ggg",
+		Host:         "hhh",
+	}
+
+	r := props.Replaces()
+
+	assert.Equal(t, "foo", r["code"])
+	assert.Equal(t, "bar", r["message"])
+	assert.Equal(t, "baz", r["description"])
+	assert.Equal(t, "aaa", r["original_uri"])
+	assert.Equal(t, "bbb", r["namespace"])
+	assert.Equal(t, "ccc", r["ingress_name"])
+	assert.Equal(t, "ddd", r["service_name"])
+	assert.Equal(t, "eee", r["service_port"])
+	assert.Equal(t, "fff", r["request_id"])
+	assert.Equal(t, "ggg", r["forwarded_for"])
+	assert.Equal(t, "hhh", r["host"])
+
+	props.Code, props.Message, props.Description = "", "", ""
+
+	r = props.Replaces()
+
+	assert.Equal(t, "", r["code"])
+	assert.Equal(t, "", r["message"])
+	assert.Equal(t, "", r["description"])
+}
+
+func TestProperties_Hash(t *testing.T) {
+	props1 := tpl.Properties{Code: "123"}
+	props2 := tpl.Properties{Code: "123"}
+
+	hash1, err := props1.Hash()
+	assert.NoError(t, err)
+
+	hash2, err := props2.Hash()
+	assert.NoError(t, err)
+
+	assert.Equal(t, hash1, hash2)
+
+	props2.Code = "321"
+
+	hash2, err = props2.Hash()
+	assert.NoError(t, err)
+
+	assert.NotEqual(t, hash1, hash2)
+}

internal/tpl/render.go

@@ -0,0 +1,220 @@
+package tpl
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"strconv"
+	"sync"
+	"text/template"
+	"time"
+
+	"github.com/pkg/errors"
+
+	"gh.tarampamp.am/error-pages/internal/version"
+)
+
+// These functions are always allowed in the templates.
+var tplFnMap = template.FuncMap{ //nolint:gochecknoglobals
+	"now":      time.Now,
+	"hostname": os.Hostname,
+	"json":     func(v interface{}) string { b, _ := json.Marshal(v); return string(b) }, //nolint:nlreturn
+	"version":  version.Version,
+	"int": func(v interface{}) int {
+		if s, ok := v.(string); ok {
+			if i, err := strconv.Atoi(s); err == nil {
+				return i
+			}
+		} else if i, ok := v.(int); ok {
+			return i
+		}
+
+		return 0
+	},
+	"env": os.Getenv,
+}
+
+var ErrClosed = errors.New("closed")
+
+type TemplateRenderer struct {
+	cacheMu sync.RWMutex
+	cache   map[cacheEntryHash]cacheItem // map key is a unique hash
+
+	cacheCleanupInterval time.Duration
+	cacheItemLifetime    time.Duration
+
+	close    chan struct{}
+	closedMu sync.RWMutex
+	closed   bool
+}
+
+type (
+	cacheEntryHash = [hashLength * 2]byte // two md5 hashes
+	cacheItem      struct {
+		data          []byte
+		expiresAtNano int64
+	}
+)
+
+const (
+	cacheCleanupInterval = time.Second
+	cacheItemLifetime    = time.Second * 2
+)
+
+// NewTemplateRenderer returns new template renderer. Don't forget to call Close() function!
+func NewTemplateRenderer() *TemplateRenderer {
+	tr := &TemplateRenderer{
+		cache:                make(map[cacheEntryHash]cacheItem),
+		cacheCleanupInterval: cacheCleanupInterval,
+		cacheItemLifetime:    cacheItemLifetime,
+		close:                make(chan struct{}, 1),
+	}
+
+	go tr.cleanup()
+
+	return tr
+}
+
+func (tr *TemplateRenderer) cleanup() {
+	defer close(tr.close)
+
+	timer := time.NewTimer(tr.cacheCleanupInterval)
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-tr.close:
+			tr.cacheMu.Lock()
+			for hash := range tr.cache {
+				delete(tr.cache, hash)
+			}
+			tr.cacheMu.Unlock()
+
+			return
+
+		case <-timer.C:
+			tr.cacheMu.Lock()
+			var now = time.Now().UnixNano()
+
+			for hash, item := range tr.cache {
+				if now > item.expiresAtNano {
+					delete(tr.cache, hash)
+				}
+			}
+			tr.cacheMu.Unlock()
+
+			timer.Reset(tr.cacheCleanupInterval)
+		}
+	}
+}
+
+func (tr *TemplateRenderer) Render(content []byte, props Properties) ([]byte, error) { //nolint:funlen
+	if tr.isClosed() {
+		return nil, ErrClosed
+	}
+
+	if len(content) == 0 {
+		return content, nil
+	}
+
+	var (
+		cacheKey     cacheEntryHash
+		cacheKeyInit bool
+	)
+
+	if propsHash, err := props.Hash(); err == nil {
+		cacheKeyInit, cacheKey = true, tr.mixHashes(propsHash, HashBytes(content))
+
+		tr.cacheMu.RLock()
+		item, hit := tr.cache[cacheKey]
+		tr.cacheMu.RUnlock()
+
+		if hit {
+			// cache item has been expired?
+			if time.Now().UnixNano() > item.expiresAtNano {
+				tr.cacheMu.Lock()
+				delete(tr.cache, cacheKey)
+				tr.cacheMu.Unlock()
+			} else {
+				return item.data, nil
+			}
+		}
+	}
+
+	var funcMap = template.FuncMap{
+		"show_details":  func() bool { return props.ShowRequestDetails },
+		"hide_details":  func() bool { return !props.ShowRequestDetails },
+		"l10n_disabled": func() bool { return props.L10nDisabled },
+		"l10n_enabled":  func() bool { return !props.L10nDisabled },
+	}
+
+	// make a copy of template functions map
+	for s, i := range tplFnMap {
+		funcMap[s] = i
+	}
+
+	// and allow the direct calling of Properties tokens, e.g. `{{ code | json }}`
+	for what, with := range props.Replaces() {
+		var n, s = what, with
+
+		funcMap[n] = func() string { return s }
+	}
+
+	t, err := template.New("").Funcs(funcMap).Parse(string(content))
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+
+	if err = t.Execute(&buf, props); err != nil {
+		return nil, err
+	}
+
+	b := buf.Bytes()
+
+	if cacheKeyInit {
+		tr.cacheMu.Lock()
+		tr.cache[cacheKey] = cacheItem{
+			data:          b,
+			expiresAtNano: time.Now().UnixNano() + tr.cacheItemLifetime.Nanoseconds(),
+		}
+		tr.cacheMu.Unlock()
+	}
+
+	return b, nil
+}
+
+func (tr *TemplateRenderer) isClosed() (closed bool) {
+	tr.closedMu.RLock()
+	closed = tr.closed
+	tr.closedMu.RUnlock()
+
+	return
+}
+
+func (tr *TemplateRenderer) Close() error {
+	if tr.isClosed() {
+		return ErrClosed
+	}
+
+	tr.closedMu.Lock()
+	tr.closed = true
+	tr.closedMu.Unlock()
+
+	tr.close <- struct{}{}
+
+	return nil
+}
+
+func (tr *TemplateRenderer) mixHashes(a, b Hash) (result cacheEntryHash) {
+	for i := 0; i < len(a); i++ { //nolint:gosimple
+		result[i] = a[i]
+	}
+
+	for i := 0; i < len(b); i++ {
+		result[i+len(a)] = b[i]
+	}
+
+	return
+}

internal/tpl/render_test.go

@@ -0,0 +1,142 @@
+package tpl_test
+
+import (
+	"math/rand"
+	"os"
+	"strconv"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"gh.tarampamp.am/error-pages/internal/tpl"
+)
+
+func Test_Render(t *testing.T) {
+	renderer := tpl.NewTemplateRenderer()
+	defer func() { _ = renderer.Close() }()
+
+	require.NoError(t, os.Setenv("TEST_ENV_VAR", "unit-test"))
+
+	defer func() { require.NoError(t, os.Unsetenv("TEST_ENV_VAR")) }()
+
+	for name, tt := range map[string]struct {
+		giveContent string
+		giveProps   tpl.Properties
+		wantContent string
+		wantError   bool
+	}{
+		"common case": {
+			giveContent: "{{code}}: {{ message }} {{description}}",
+			giveProps:   tpl.Properties{Code: "404", Message: "Not found", Description: "Blah"},
+			wantContent: "404: Not found Blah",
+		},
+		"html markup": {
+			giveContent: "<!-- comment --><html><body>{{code}}: {{ message }} {{description}}</body></html>",
+			giveProps:   tpl.Properties{Code: "201", Message: "lorem ipsum"},
+			wantContent: "<!-- comment --><html><body>201: lorem ipsum </body></html>",
+		},
+		"with line breakers": {
+			giveContent: "\t {{code}}: {{ message }} {{description}}\n",
+			giveProps:   tpl.Properties{},
+			wantContent: "\t :  \n",
+		},
+		"golang template": {
+			giveContent: "\t {{code}} {{ .Code }}{{ if .Message }} Yeah {{end}}",
+			giveProps:   tpl.Properties{Code: "201", Message: "lorem ipsum"},
+			wantContent: "\t 201 201 Yeah ",
+		},
+		"wrong golang template": {
+			giveContent: "{{ if foo() }} Test {{ end }}",
+			giveProps:   tpl.Properties{},
+			wantError:   true,
+		},
+
+		"json common case": {
+			giveContent: `{"code": {{code | json}}, "message": {"here":[ {{ message | json }} ]}, "desc": "{{description}}"}`,
+			giveProps:   tpl.Properties{Code: `404'"{`, Message: "Not found\t\r\n"},
+			wantContent: `{"code": "404'\"{", "message": {"here":[ "Not found\t\r\n" ]}, "desc": ""}`,
+		},
+		"json golang template": {
+			giveContent: `{"code": "{{code}}", "message": {"here":[ "{{ if .Message }} Yeah {{end}}" ]}}`,
+			giveProps:   tpl.Properties{Code: "201", Message: "lorem ipsum"},
+			wantContent: `{"code": "201", "message": {"here":[ " Yeah " ]}}`,
+		},
+
+		"fn l10n_enabled": {
+			giveContent: "{{ if l10n_enabled }}Y{{ else }}N{{ end }}",
+			giveProps:   tpl.Properties{L10nDisabled: true},
+			wantContent: "N",
+		},
+		"fn l10n_disabled": {
+			giveContent: "{{ if l10n_disabled }}Y{{ else }}N{{ end }}",
+			giveProps:   tpl.Properties{L10nDisabled: true},
+			wantContent: "Y",
+		},
+
+		"env": {
+			giveContent: `{{ env "TEST_ENV_VAR" }}`,
+			wantContent: "unit-test",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			content, err := renderer.Render([]byte(tt.giveContent), tt.giveProps)
+
+			if tt.wantError == true {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.wantContent, string(content))
+			}
+		})
+	}
+}
+
+func TestTemplateRenderer_Render_Concurrent(t *testing.T) {
+	renderer := tpl.NewTemplateRenderer()
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			props := tpl.Properties{
+				Code:        strconv.Itoa(rand.Intn(599-300+1) + 300), //nolint:gosec
+				Message:     "Not found",
+				Description: "Blah",
+			}
+
+			content, err := renderer.Render([]byte("{{code}}: {{ message }} {{description}}"), props)
+
+			assert.NoError(t, err)
+			assert.NotEmpty(t, content)
+		}()
+	}
+
+	wg.Wait()
+
+	assert.NoError(t, renderer.Close())
+	assert.EqualError(t, renderer.Close(), tpl.ErrClosed.Error())
+
+	content, err := renderer.Render([]byte{}, tpl.Properties{})
+	assert.Nil(t, content)
+	assert.EqualError(t, err, tpl.ErrClosed.Error())
+}
+
+func BenchmarkRenderHTML(b *testing.B) {
+	b.ReportAllocs()
+
+	renderer := tpl.NewTemplateRenderer()
+	defer func() { _ = renderer.Close() }()
+
+	for i := 0; i < b.N; i++ {
+		_, _ = renderer.Render(
+			[]byte("{{code}}: {{ message }} {{description}}"),
+			tpl.Properties{Code: "404", Message: "Not found", Description: "Blah"},
+		)
+	}
+}

internal/version/version.go

@@ -0,0 +1,18 @@
+// Package version is used as a place, where application version defined.
+package version
+
+import "strings"
+
+// version value will be set during compilation.
+var version = "v0.0.0@undefined"
+
+// Version returns version value (without `v` prefix).
+func Version() string {
+	v := strings.TrimSpace(version)
+
+	if len(v) > 1 && ((v[0] == 'v' || v[0] == 'V') && (v[1] >= '0' && v[1] <= '9')) {
+		return v[1:]
+	}
+
+	return v
+}

internal/version/version_test.go

@@ -0,0 +1,38 @@
+package version
+
+import (
+	"testing"
+)
+
+func TestVersion(t *testing.T) {
+	for give, want := range map[string]string{
+		// without changes
+		"vvv":     "vvv",
+		"victory": "victory",
+		"voodoo":  "voodoo",
+		"foo":     "foo",
+		"0.0.0":   "0.0.0",
+		"v":       "v",
+		"V":       "V",
+
+		// "v" prefix removal
+		"v0.0.0": "0.0.0",
+		"V0.0.0": "0.0.0",
+		"v1":     "1",
+		"V1":     "1",
+
+		// with spaces
+		" 0.0.0":  "0.0.0",
+		"v0.0.0 ": "0.0.0",
+		" V0.0.0": "0.0.0",
+		"v1 ":     "1",
+		" V1":     "1",
+		"v ":      "v",
+	} {
+		version = give
+
+		if v := Version(); v != want {
+			t.Errorf("want: %s, got: %s", want, v)
+		}
+	}
+}

l10n/.eslintrc.json

@@ -0,0 +1,11 @@
+{
+    "extends": [
+        "eslint:recommended"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 2017
+    },
+    "env": {
+        "browser": true
+    }
+}

l10n/l10n.js

@@ -0,0 +1,942 @@
+Object.defineProperty(window, 'l10n', {
+    value: new function () {
+        // language codes list: <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>
+        const data = { // all keys should be in english (it is default/main locale)
+            'Error': {
+                fr: 'Erreur',
+                ru: 'Ошибка',
+                uk: 'Помилка',
+                pt: 'Erro',
+                nl: 'Fout',
+                de: 'Fehler',
+                es: 'Error',
+                zh: '错误',
+                id: 'Kesalahan',
+                pl: 'Błąd',
+            },
+            'Good luck': {
+                fr: 'Bonne chance',
+                ru: 'Удачи',
+                uk: 'Успіхів',
+                pt: 'Boa sorte',
+                nl: 'Veel succes',
+                de: 'Viel Glück',
+                es: 'Buena Suerte',
+                zh: '祝好运',
+                id: 'Semoga berhasil!',
+                pl: 'Powodzenia',
+            },
+            'UH OH': {
+                fr: 'Oups',
+                ru: 'Ох',
+                uk: 'Упс',
+                pt: 'Ops',
+                nl: 'Oeps',
+                de: 'Hoppla',
+                es: 'Uy',
+                zh: '哎呀',
+                id: 'Ups',
+                pl: 'Ojej',
+            },
+            'Request details': {
+                fr: 'Détails de la requête',
+                ru: 'Детали запроса',
+                uk: 'Деталі запиту',
+                pt: 'Detalhes da solicitação',
+                nl: 'Details van verzoek',
+                de: 'Details der Anfrage',
+                es: 'Detalles de la petición',
+                zh: '请求详情',
+                id: 'Rincian permintaan',
+                pl: 'Poproś o szczegóły',
+            },
+            'Double-check the URL': {
+                fr: 'Vérifiez l’URL',
+                ru: 'Дважды проверьте URL',
+                uk: 'Двічі перевіряйте URL-адресу',
+                pt: 'Verifique novamente a URL',
+                nl: 'Controleer de URL',
+                de: 'Überprüfen Sie die URL',
+                es: 'Verifique la url',
+                zh: '请再次检查地址',
+                id: 'Periksa URL',
+                pl: 'Sprawdź adres URL',
+            },
+            'Alternatively, go back': {
+                fr: 'Essayer de revenir en arrière',
+                ru: 'Или можете вернуться назад',
+                uk: 'Або можете повернутися назад',
+                pt: "Como alternativa, tente voltar",
+                nl: 'Of ga terug',
+                de: 'Alternativ gehen Sie zurück',
+                es: 'Como alternativa, vuelva atrás',
+                zh: '或返回上一页',
+                id: 'Atau, kembali',
+                pl: 'Alternatywnie wróć',
+            },
+            'Here\'s what might have happened': {
+                fr: 'Voici ce qui aurait pu se passer',
+                ru: 'Из-за чего это могло случиться',
+                uk: 'Ось що могло трапитися',
+                pt: 'Aqui está o que pode ter acontecido',
+                nl: 'Wat er gebeurd kan zijn',
+                de: 'Folgendes könnte passiert sein',
+                es: 'Esto es lo que ha podido pasar',
+                zh: '可能原因有',
+                id: 'Inilah yang bisa saja terjadi',
+                pl: 'Oto, co mogło się wydarzyć',
+            },
+            'You may have mistyped the URL': {
+                fr: 'Vous avez peut-être mal tapé l’URL',
+                ru: 'Вы могли ошибиться в URL',
+                uk: 'Ви могли помилитися в URL-адресі',
+                pt: 'Você pode ter digitado incorretamente a URL',
+                nl: 'De URL bevat een typefout',
+                de: 'Möglicherweise haben Sie die URL falsch eingegeben',
+                es: 'Quizá ha escrito mal la URL',
+                zh: '您可能输入了错误的地址',
+                id: 'Anda mungkin tersalah memasukkan URL',
+                pl: 'Być może błędnie wpisałeś adres URL',
+            },
+            'The site was moved': {
+                fr: 'Le site a été déplacé',
+                ru: 'Сайт был перемещён',
+                uk: 'Сайт був переміщений',
+                pt: 'O site foi movido',
+                nl: 'De site is verplaatst',
+                de: 'Die Seite wurde verschoben',
+                es: 'El sitio se ha trasladado',
+                zh: '站点已被转移',
+                id: 'Halaman dipindahkan',
+                pl: 'Witryna została przeniesiona',
+            },
+            'It was never here': {
+                fr: 'Il n’a jamais été ici',
+                ru: 'Он никогда не был здесь',
+                uk: 'Він ніколи не був тут',
+                pt: 'Nunca esteve aqui',
+                nl: 'Het was hier nooit',
+                de: 'Es war nie hier',
+                es: 'Nunca ha estado aquí',
+                zh: '站点从未存在',
+                id: 'Itu Tidak pernah di sini',
+                pl: 'Nigdy jej nie było',
+            },
+            'Bad Request': {
+                fr: 'Mauvaise requête',
+                ru: 'Некорректный запрос',
+                uk: 'Хибний запит',
+                pt: 'Requisição inválida',
+                nl: 'Foutieve anvraag',
+                de: 'Fehlerhafte Anfrage',
+                es: 'Petición inválida',
+                zh: '错误请求',
+                id: 'Permintaan yang salah',
+                pl: 'Nieprawidłowe żądanie',
+            },
+            'The server did not understand the request': {
+                fr: 'Le serveur ne comprend pas la requête',
+                ru: 'Сервер не смог обработать запрос из-за ошибки в нём',
+                uk: 'Сервер не зміг обробити запит через помилку в ньому',
+                pt: 'O servidor não entendeu a solicitação',
+                nl: 'De server begreep het verzoek niet',
+                de: 'Der Server hat die Anfrage nicht verstanden',
+                es: 'El servidor no entendió la petición',
+                zh: '服务器不理解该请求',
+                id: 'Server tidak memahami permintaan',
+                pl: 'Serwer nie zrozumiał żądania',
+            },
+            'Unauthorized': {
+                fr: 'Non autorisé',
+                ru: 'Запрос не авторизован',
+                uk: 'Несанкціонований доступ',
+                pt: 'Não autorizado',
+                nl: 'Niet geautoriseerd',
+                de: 'Nicht autorisiert',
+                es: 'No autorizado',
+                zh: '未经授权',
+                id: 'Tidak diotorisasi',
+                pl: 'Nieautoryzowany',
+            },
+            'The requested page needs a username and a password': {
+                fr: 'La page demandée nécessite un nom d’utilisateur et un mot de passe',
+                ru: 'Для доступа к странице требуется логин и пароль',
+                uk: 'Щоб отримати доступ до сторінки, потрібний логін та пароль',
+                pt: 'A página solicitada precisa de um nome de usuário e uma senha',
+                nl: 'De pagina heeft een gebruikersnaam en wachtwoord nodig',
+                de: 'Die angeforderte Seite benötigt einen Benutzernamen und ein Passwort',
+                es: 'La página solicitada necesita un usuario y una contraseña',
+                zh: '请求的页面需要用户名和密码',
+                id: 'Halaman yang diminta membutuhkan nama pengguna dan kata sandi',
+                pl: 'Żądana strona wymaga podania nazwy użytkownika i hasła',
+            },
+            'Forbidden': {
+                fr: 'Interdit',
+                ru: 'Запрещено',
+                uk: 'Заборонено',
+                pt: 'Proibido',
+                nl: 'Verboden',
+                de: 'Verboten',
+                es: 'Prohibido',
+                zh: '禁止访问',
+                id: 'Dilarang',
+                pl: 'Zabroniony',
+            },
+            'Access is forbidden to the requested page': {
+                fr: 'Accès interdit à la page demandée',
+                ru: 'Доступ к странице запрещён',
+                uk: 'Доступ до сторінки заборонено',
+                pt: 'É proibido o acesso à página solicitada',
+                nl: 'Toegang tot de pagina is verboden',
+                de: 'Der Zugriff auf die angeforderte Seite ist verboten',
+                es: 'El acceso está prohibido para la página solicitada',
+                zh: '禁止访问请求的页面',
+                id: 'Akses dilarang ke halaman yang diminta',
+                pl: 'Dostęp do żądanej strony jest zabroniony',
+            },
+            'Not Found': {
+                fr: 'Introuvable',
+                ru: 'Страница не найдена',
+                uk: 'Сторінку не знайдено',
+                pt: 'Não encontrado',
+                nl: 'Niet gevonden',
+                de: 'Nicht gefunden',
+                es: 'No encontrado',
+                zh: '未找到',
+                id: 'Tidak ditemukan',
+                pl: 'Nie znaleziono',
+            },
+            'The server can not find the requested page': {
+                fr: 'Le serveur ne peut trouver la page demandée',
+                ru: 'Сервер не смог найти запрашиваемую страницу',
+                uk: 'Сервер не зміг знайти запитану сторінку',
+                pt: 'O servidor não consegue encontrar a página solicitada',
+                nl: 'De server kan de pagina niet vinden',
+                de: 'Der Server kann die angeforderte Seite nicht finden',
+                es: 'El servidor no puede encontrar la página solicitada',
+                zh: '服务器找不到请求的页面',
+                id: 'Server tidak dapat menemukan halaman yang diminta',
+                pl: 'Serwer nie może znaleźć żądanej strony',
+            },
+            'Method Not Allowed': {
+                fr: 'Méthode Non Autorisée',
+                ru: 'Метод не поддерживается',
+                uk: 'Неприпустимий метод',
+                pt: 'Método não permitido',
+                nl: 'Methode niet toegestaan',
+                de: 'Methode nicht erlaubt',
+                es: 'Método no permitido',
+                zh: '方法不被允许',
+                id: 'Metode tidak diizinkan',
+                pl: 'Niedozwolona metoda',
+            },
+            'The method specified in the request is not allowed': {
+                fr: 'La méthode spécifiée dans la requête n’est pas autorisée',
+                ru: 'Указанный в запросе метод не поддерживается',
+                uk: 'Метод, зазначений у запиті, не підтримується',
+                pt: 'O método especificado na solicitação não é permitido',
+                nl: 'De methode in het verzoek is niet toegestaan',
+                de: 'Die in der Anfrage angegebene Methode ist nicht zulässig',
+                es: 'El método especificado en la petición no está permitido',
+                zh: '请求指定的方法不被允许',
+                id: 'Metode dalam permintaan tidak diizinkan',
+                pl: 'Metoda określona w żądaniu jest niedozwolona',
+            },
+            'Proxy Authentication Required': {
+                fr: 'Authentification proxy requise',
+                ru: 'Нужна аутентификация прокси',
+                uk: 'Потрібна ідентифікація проксі',
+                pt: 'Autenticação de proxy necessária',
+                nl: 'Authenticatie op de proxyserver verplicht',
+                de: 'Proxy-Authentifizierung benötigt',
+                es: 'Autenticación de proxy requerida',
+                zh: '需要代理服务器身份验证',
+                id: 'Diperlukan otentikasi proxy',
+                pl: 'Wymagane uwierzytelnianie proxy',
+            },
+            'You must authenticate with a proxy server before this request can be served': {
+                fr: 'Vous devez vous authentifier avec un serveur proxy avant que cette requête puisse être servie',
+                ru: 'Вы должны быть авторизованы на прокси сервере для обработки этого запроса',
+                uk: 'Ви повинні увійти до проксі-сервера для обробки цього запиту',
+                pt: 'Você deve se autenticar com um servidor proxy antes que esta solicitação possa ser atendida',
+                nl: 'Je moet authenticeren bij een proxyserver voordat dit verzoek uitgevoerd kan worden',
+                de: 'Sie müssen sich bei einem Proxy-Server authentifizieren, bevor diese Anfrage bedient werden kann',
+                es: 'Debes autentificarte con un servidor proxy antes de que esta petición pueda ser atendida',
+                zh: '您必须对代理服务器进行身份验证，然后才能让请求得到处理',
+                id: 'Anda harus mengautentikasi dengan server proxy sebelum permintaan ini dapat dilayani',
+                pl: 'Musisz uwierzytelnić się na serwerze proxy, zanim to żądanie będzie mogło zostać obsłużone',
+            },
+            'Request Timeout': {
+                fr: 'Requête expiré',
+                ru: 'Истекло время ожидания',
+                uk: 'Вичерпано час очікування',
+                pt: 'Tempo limite de solicitação excedido',
+                nl: 'Aanvraagtijd verstreken',
+                de: 'Zeitüberschreitung der Anforderung',
+                es: 'Tiempo límite de la petición excedido',
+                zh: '请求超时',
+                id: 'Meminta batas waktu',
+                pl: 'Przekroczenie limitu czasu żądania',
+            },
+            'The request took longer than the server was prepared to wait': {
+                fr: 'La requête prend plus de temps que prévu',
+                ru: 'Отправка запроса заняла слишком много времени',
+                uk: 'Надсилання запиту зайняло надто багато часу',
+                pt: 'A solicitação demorou mais do que o servidor estava preparado para esperar',
+                nl: 'Het verzoek duurde langer dan de server wilde wachten',
+                de: 'Die Anfrage hat länger gedauert, als der Server bereit war zu warten',
+                es: 'La petición esta tardando más de lo que el servidor estaba preparado para esperar',
+                zh: '请求用时超过了服务器设置的最长等待时间',
+                id: 'Permintaan memakan waktu lebih lama dari yang bisa ditunggu oleh server',
+                pl: 'Żądanie trwało dłużej niż serwer był gotowy czekać',
+            },
+            'Conflict': {
+                fr: 'Conflit',
+                ru: 'Конфликт',
+                uk: 'Конфлікт',
+                pt: 'Conflito',
+                nl: 'Conflict',
+                de: 'Konflikt',
+                es: 'Conflicto',
+                zh: '冲突',
+                id: 'Konflik',
+                pl: 'Konflikt',
+            },
+            'The request could not be completed because of a conflict': {
+                fr: 'La requête n’a pas pu être complétée à cause d’un conflit',
+                ru: 'Запрос не может быть обработан из-за конфликта',
+                uk: 'Запит не може бути оброблений через конфлікт',
+                pt: 'A solicitação não pôde ser concluída devido a um conflito',
+                nl: 'Het verzoek kon niet worden verwerkt vanwege een conflict',
+                de: 'Die Anfrage konnte aufgrund eines Konflikts nicht abgeschlossen werden',
+                es: 'La petición no ha podido ser completada por un conflicto',
+                zh: '由于冲突，请求无法完成',
+                id: 'Permintaan tidak dapat diselesaikan karena adanya konflik',
+                pl: 'Żądanie nie mogło zostać wykonane z powodu konfliktu',
+            },
+            'Gone': {
+                fr: 'Supprimé',
+                ru: 'Удалено',
+                uk: 'Вилучений',
+                pt: 'Removido',
+                nl: 'Verdwenen',
+                de: 'Verschwunden',
+                es: 'Eliminado',
+                zh: '已移除',
+                id: 'Menghilang',
+                pl: 'Usunięto',
+            },
+            'The requested page is no longer available': {
+                fr: 'La page demandée n’est plus disponible',
+                ru: 'Запрошенная страница была удалена',
+                uk: 'Запитувана сторінка більше не доступна',
+                pt: 'A página solicitada não está mais disponível',
+                nl: 'De pagina is niet langer beschikbaar',
+                de: 'Die angeforderte Seite ist nicht mehr verfügbar',
+                es: 'La página solicitada no está ya disponible',
+                zh: '请求的页面不再可用',
+                id: 'Halaman yang diminta tidak lagi tersedia',
+                pl: 'Żądana strona nie jest już dostępna',
+            },
+            'Length Required': {
+                fr: 'Longueur requise',
+                ru: 'Необходима длина',
+                uk: 'Потрібно вказати довжину',
+                pt: 'Content-Length necessário',
+                nl: 'Lengte benodigd',
+                de: 'Länge benötigt',
+                es: 'Longitud requerida',
+                zh: '需要长度',
+                id: 'Panjang yang diperlukan',
+                pl: 'Wymagana długość',
+            },
+            'The "Content-Length" is not defined. The server will not accept the request without it': {
+                fr: 'Le "Content-Length" n’est pas défini. Le serveur ne prendra pas en compte la requête',
+                ru: 'Заголовок "Content-Length" не был передан. Сервер не может обработать запрос без него',
+                uk: 'Заголовок "Content-Length" не був переданий. Сервер не може обробити запит без нього',
+                pt: 'O "Content-Length" não está definido. O servidor não aceitará a solicitação sem ele',
+                nl: 'De "Content-Length" is niet gespecificeerd. De server accepteert het verzoek niet zonder',
+                de: 'Die "Content-Length" ist nicht definiert. Ohne sie akzeptiert der Server die Anfrage nicht',
+                es: 'El "Content-Legth" no eta definido. Este servidor no aceptará la petición sin él',
+                zh: '未指定Content-Length(内容长度)。服务器将不接受不包含此头信息的请求',
+                id: '"Content-Length" tidak ditentukan. Server tidak akan menerima permintaan tanpa itu',
+                pl: 'Wartość "Content-Length" nie jest zdefiniowana. Serwer nie zaakceptuje żądania bez tego parametru',
+            },
+            'Precondition Failed': {
+                fr: 'Échec de la condition préalable',
+                ru: 'Условие ложно',
+                uk: 'Збій під час обробки попередньої умови',
+                pt: 'Falha na pré-condição',
+                nl: 'Niet voldaan aan vooraf gestelde voorwaarde',
+                de: 'Vorbedingung fehlgeschlagen',
+                es: 'Precondición fallida',
+                zh: '前置条件判定失败',
+                pl: 'Niespełnienie warunku wstępnego',
+            },
+            'The pre condition given in the request evaluated to false by the server': {
+                fr: 'La précondition donnée dans la requête a été évaluée comme étant fausse par le serveur',
+                ru: 'Ни одно из условных полей заголовка запроса не было выполнено',
+                uk: 'Жодна з передумов запиту не була виконана',
+                pt: 'A pré-condição dada na solicitação avaliada como falsa pelo servidor',
+                nl: 'De vooraf gestelde voorwaarde is afgewezen door de server',
+                de: 'Die in der Anfrage angegebene Vorbedingung wird vom Server als falsch bewertet',
+                es: 'La precondición ha sido evaluada como negativa para esta petición por el servidor',
+                zh: '服务器评估请求中给出的前置条件的结果为false(假)',
+                id: 'Prakondisi gagal',
+                pl: 'Warunek wstępny podany w żądaniu został oceniony przez serwer jako nieprawidłowy',
+            },
+            'Payload Too Large': {
+                fr: 'Charge trop volumineuse',
+                ru: 'Слишком большой запрос',
+                uk: 'Занадто великий запит',
+                pt: 'Payload muito grande',
+                nl: 'Aanvraag te grood',
+                de: 'Anfrage zu groß',
+                es: 'Carga demasiado grande',
+                zh: '请求体过大',
+                id: 'Muatan terlalu besar',
+                pl: 'Żądanie jest zbyt duże',
+            },
+            'The server will not accept the request, because the request entity is too large': {
+                fr: 'Le serveur ne prendra pas en compte la requête, car l’entité de la requête est trop volumineuse',
+                ru: 'Сервер не может обработать запрос, так как он слишком большой',
+                uk: 'Сервер не може обробити запит, оскільки він занадто великий',
+                pt: 'O servidor não aceitará a solicitação porque a entidade da solicitação é muito grande',
+                nl: 'De server accepteert het verzoek niet omdat de aanvraag te groot is',
+                de: 'Der Server akzeptiert die Anfrage nicht, da die Datenmenge zu groß ist',
+                es: 'El servidor no aceptará esta petición, porque la carga es demasiado grande',
+                zh: '请求体过大，服务器将不接受该请求',
+                id: 'Server tidak akan menerima permintaan, karena entitas permintaan terlalu besar',
+                pl: 'Serwer nie zaakceptuje żądania, ponieważ żądanie jest zbyt duże',
+            },
+            'Requested Range Not Satisfiable': {
+                fr: 'Requête non satisfaisante',
+                ru: 'Диапазон не достижим',
+                uk: 'Запитуваний діапазон недосяжний',
+                pt: 'Intervalo Solicitado Não Satisfatório',
+                nl: 'Aangevraagd gedeelte niet opvraagbaar',
+                de: 'Anfrage-Bereich nicht erfüllbar',
+                es: 'Intervalo solicitado no satisfactorio',
+                zh: '不满足请求范围',
+                id: 'Rentang yang diminta tidak dapat dipenuhi',
+                pl: 'Żądany zakres nie jest satysfakcjonujący',
+            },
+            'The requested byte range is not available and is out of bounds': {
+                fr: 'Le byte range demandé n’est pas disponible et est hors des limites',
+                ru: 'Запрошенный диапазон данных недоступен или вне допустимых пределов',
+                uk: 'Описаний діапазон даних недоступний або поза допустимими межами',
+                pt: 'O intervalo de bytes solicitado não está disponível e está fora dos limites',
+                nl: 'De aangevraagde bytes zijn buiten het limiet',
+                de: 'Der angefragte Teilbereich der Ressource existiert nicht oder ist ungültig',
+                es: 'El intervalo de bytes requerido no está disponible o se encuentra fuera de los límites',
+                zh: '请求的字节范围不可用，超出边界',
+                id: 'Rentang byte yang diminta tidak tersedia dan di luar batas',
+                pl: 'Żądany zakres bajtów nie jest dostępny i znajduje się poza zakresem',
+            },
+            'I\'m a teapot': {
+                fr: 'Je suis une théière',
+                ru: 'Я чайник',
+                uk: 'Я чайник',
+                pt: 'Eu sou um bule',
+                nl: 'Ik ben een theepot',
+                de: 'Ich bin eine Teekanne',
+                es: 'Soy una tetera',
+                zh: '我是一只茶壶',
+                id: 'Saya adalah teko',
+                pl: 'Jestem czajniczkiem',
+            },
+            'Attempt to brew coffee with a teapot is not supported': {
+                fr: 'Tenter de préparer du café avec une théière n’est pas pris en charge',
+                ru: 'Попытка заварить кофе в чайнике обречена на фиаско',
+                uk: 'Спроба заварити каву в чайнику приречена на фіаско',
+                pt: 'A tentativa de preparar café com um bule não é suportada',
+                nl: 'Koffie maken met een theepot is niet ondersteund',
+                de: 'Der Versuch, Kaffee mit einer Teekanne zuzubereiten, wird nicht unterstützt',
+                es: 'Intentar hacer un café en una tetera no está soportado',
+                zh: '用茶壶泡咖啡不受支持',
+                id: 'Upaya menyeduh kopi dengan teko tidak didukung',
+                pl: 'Próba zaparzenia kawy za pomocą czajniczka nie jest obsługiwana',
+            },
+            'Too Many Requests': {
+                fr: 'Trop de requêtes',
+                ru: 'Слишком много запросов',
+                uk: 'Занадто багато запитів',
+                pt: 'Excesso de solicitações',
+                nl: 'Te veel requests',
+                de: 'Zu viele Anfragen',
+                es: 'Demasiadas peticiones',
+                zh: '请求过多',
+                id: 'Terlalu banyak permintaan',
+                pl: 'Zbyt wiele żądań',
+            },
+            'Too many requests in a given amount of time': {
+                fr: 'Trop de requêtes dans un délai donné',
+                ru: 'Отправлено слишком много запросов за короткое время',
+                uk: 'Надіслано занадто багато запитів за короткий проміжок час',
+                pt: 'Excesso de solicitações em um determinado período de tempo',
+                nl: 'Te veel verzoeken binnen een bepaalde tijd',
+                de: 'Der Client hat zu viele Anfragen in einem bestimmten Zeitraum gesendet',
+                es: 'Demasiadas peticiones en un determinado periodo de tiempo',
+                zh: '在给定的时间内发送了过多请求',
+                id: 'Terlalu banyak permintaan dalam waktu tertentu',
+                pl: 'Zbyt wiele żądań w określonym czasie',
+            },
+            'Internal Server Error': {
+                fr: 'Erreur interne du serveur',
+                ru: 'Внутренняя ошибка сервера',
+                uk: 'Внутрішня помилка сервера',
+                pt: 'Erro do Servidor Interno',
+                nl: 'Interne serverfout',
+                de: 'Interner Server-Fehler',
+                es: 'Error Interno',
+                zh: '内部服务器错误',
+                id: 'Kesalahan server internal',
+                pl: 'Wewnętrzny błąd serwera',
+            },
+            'The server met an unexpected condition': {
+                fr: 'Le serveur a rencontré une condition inattendue',
+                ru: 'Произошло что-то неожиданное на сервере',
+                uk: 'На сервері відбулось щось неочікуване',
+                pt: 'O servidor encontrou uma condição inesperada',
+                nl: 'De server ondervond een onverwachte conditie',
+                de: 'Der Server hat einen internen Fehler festgestellt',
+                es: 'El servidor ha encontrado una condición no esperada',
+                zh: '服务器遇到了意外情况',
+                id: 'Server mengalami kondisi yang tidak terduga',
+                pl: 'Serwer napotkał nieoczekiwany stan',
+            },
+            'Bad Gateway': {
+                fr: 'Mauvaise passerelle',
+                ru: 'Ошибка шлюза',
+                uk: 'Помилка шлюзу',
+                pt: 'Gateway inválido',
+                nl: 'Ongeldige Gateway',
+                de: 'Fehlerhaftes Gateway',
+                es: 'Puerta de enlace no valida',
+                zh: '无效网关',
+                id: 'Gateway yang buruk',
+                pl: 'Błąd bramki',
+            },
+            'The server received an invalid response from the upstream server': {
+                fr: 'Le serveur a reçu une réponse invalide du serveur distant',
+                ru: 'Сервер получил некорректный ответ от вышестоящего сервера',
+                uk: 'Сервер отримав невірну відповідь від попереднього сервера',
+                pt: 'O servidor recebeu uma resposta inválida do servidor upstream',
+                nl: 'De server ontving een ongeldig antwoord van een bovenliggende server',
+                de: 'Der Server hat eine ungültige Antwort vom Upstream-Server erhalten',
+                es: 'El servidor ha recibido una respuesta no válida del servidor de origen',
+                zh: '服务器从上游服务器收到了无效的响应',
+                id: 'Server menerima respons yang tidak valid dari server induk',
+                pl: 'Serwer otrzymał nieprawidłową odpowiedź od serwera nadrzędnego',
+            },
+            'Service Unavailable': {
+                fr: 'Service indisponible',
+                ru: 'Сервис недоступен',
+                uk: 'Сервіс недоступний',
+                pt: 'Serviço não disponível',
+                nl: 'Dienst niet beschikbaar',
+                de: 'Dienst nicht verfügbar',
+                es: 'Servicio no disponible',
+                zh: '服务不可用',
+                id: 'Layanan tidak tersedia',
+                pl: 'Serwis niedostępny',
+            },
+            'The server is temporarily overloading or down': {
+                fr: 'Le serveur est temporairement en surcharge ou indisponible',
+                ru: 'Сервер временно не может обрабатывать запросы по техническим причинам',
+                uk: 'Сервер тимчасово не може обробляти запити з технічних причин',
+                pt: 'O servidor está temporariamente sobrecarregado ou inativo',
+                nl: 'De server is tijdelijk overbelast of niet bereikbaar',
+                de: 'Der Server ist vorübergehend überlastet oder ausgefallen',
+                es: 'El servidor está temporalmente sobrecargado o inactivo',
+                zh: '服务器暂时过载或不可用',
+                id: 'Server untuk sementara kelebihan beban atau tidak tersedia',
+                pl: 'Serwer jest tymczasowo przeciążony lub wyłączony',
+            },
+            'Gateway Timeout': {
+                fr: 'Expiration Passerelle',
+                ru: 'Шлюз не отвечает',
+                uk: 'Шлюз не відповідає',
+                pt: 'Tempo limite do gateway excedido',
+                nl: 'Gateway Verlopen',
+                de: 'Gateway Zeitüberschreitung',
+                es: 'Tiempo límite de puerta de enlace excedido',
+                zh: '网关超时',
+                id: 'Batas waktu gateway',
+                pl: 'Przekroczenie limitu czasu bramki',
+            },
+            'The gateway has timed out': {
+                fr: 'Le temps d’attente de la passerelle est dépassé',
+                ru: 'Сервер не дождался ответа от вышестоящего сервера',
+                uk: 'У шлюзу закінчився час очікування',
+                pt: 'O gateway esgotou o tempo limite',
+                nl: 'De verbinding naar de bovenliggende server is verlopen',
+                de: 'Das Zeitlimit für den Verbindungsaufbau mit dem Upstream-Server ist abgelaufen',
+                es: 'La puerta de enlace ha sobrepasado el tiempo límite',
+                zh: '网关响应已经超时',
+                id: 'Sambungan ke server induk telah kedaluwarsa',
+                pl: 'Bramka przekroczyła limit czasu',
+            },
+            'HTTP Version Not Supported': {
+                fr: 'Version HTTP non prise en charge',
+                ru: 'Версия HTTP не поддерживается',
+                uk: 'Версія НТТР не підтримується',
+                pt: 'Versão HTTP não suportada',
+                nl: 'HTTP-versie wordt niet ondersteunt',
+                de: 'HTTP-Version wird nicht unterstützt',
+                es: 'Versión de HTTP no soportada',
+                zh: 'HTTP版本不受支持',
+                id: 'Versi HTTP tidak didukung',
+                pl: 'Wersja HTTP nie jest obsługiwana',
+            },
+            'The server does not support the "http protocol" version': {
+                fr: 'Le serveur ne supporte pas la version du protocole HTTP',
+                ru: 'Сервер не поддерживает запрошенную версию HTTP протокола',
+                uk: 'Сервер не підтримує запитану версію HTTP-протоколу',
+                pt: 'O servidor não suporta a versão do protocolo HTTP',
+                nl: 'De server ondersteunt deze HTTP-versie niet',
+                de: 'Der Server unterstützt die HTTP-Protokoll-Version nicht',
+                es: 'El servidor no soporta la versión del protocolo HTTP',
+                zh: '服务器不支持该HTTP协议版本',
+                id: 'Server tidak mendukung versi HTTP ini',
+                pl: 'Serwer nie obsługuje wersji "protokołu http"',
+            },
+
+            'Host': {
+                fr: 'Hôte',
+                ru: 'Хост',
+                uk: 'Хост',
+                pt: 'Hospedeiro',
+                nl: 'Host',
+                de: 'Host',
+                es: 'Host',
+                zh: '主机',
+                id: 'Host',
+                pl: 'Host',
+            },
+            'Original URI': {
+                fr: 'URI d’origine',
+                ru: 'Исходный URI',
+                uk: 'Вихідний URI',
+                pt: 'URI original',
+                nl: 'Originele URI',
+                de: 'Originale URI',
+                es: 'URI original',
+                zh: '原始URI',
+                id: 'URL asli',
+                pl: 'Oryginalny URI',
+            },
+            'Forwarded for': {
+                fr: 'Transmis pour',
+                ru: 'Перенаправлен',
+                uk: 'Перенаправлений',
+                pt: 'Encaminhado para',
+                nl: 'Doorgestuurd voor',
+                de: 'Weitergeleitet für',
+                es: 'Remitido para',
+                zh: '转发自',
+                id: 'Diteruskan untuk',
+                pl: 'Przekazane do',
+            },
+            'Namespace': {
+                fr: 'Espace de noms',
+                ru: 'Пространство имён',
+                uk: 'Простір імен',
+                pt: 'Namespace',
+                nl: 'Elementnaam',
+                de: 'Namensraum',
+                es: 'Namespace',
+                zh: '命名空间',
+                id: 'Ruang nama',
+                pl: 'Przestrzeń nazw',
+            },
+            'Ingress name': {
+                fr: 'Nom ingress',
+                ru: 'Имя Ingress',
+                uk: 'Ім\'я входу',
+                pt: 'Nome Ingress',
+                nl: 'Ingress naam',
+                de: 'Ingress Name',
+                es: 'Nombre Ingress',
+                zh: '入口名',
+                id: 'Nama ingress',
+                pl: 'Nazwa wejścia',
+            },
+            'Service name': {
+                fr: 'Nom du service',
+                ru: 'Имя сервиса',
+                uk: 'Ім\'я сервісу',
+                pt: 'Nome do Serviço',
+                nl: 'Service naam',
+                de: 'Service Name',
+                es: 'Nombre del servicio',
+                zh: '服务名',
+                id: 'Nama layanan',
+                pl: 'Nazwa usługi',
+            },
+            'Service port': {
+                fr: 'Port du service',
+                ru: 'Порт сервиса',
+                uk: 'Порт сервісу',
+                pt: 'Porta do serviço',
+                nl: 'Service poort',
+                de: 'Service Port',
+                es: 'Puerto del servicio',
+                zh: '服务端口',
+                id: 'Port layanan',
+                pl: 'Port usługi',
+            },
+            'Request ID': {
+                fr: 'Identifiant de la requête',
+                ru: 'ID запроса',
+                uk: 'ID запиту',
+                pt: 'ID da solicitação',
+                nl: 'ID van het verzoek',
+                de: 'Anfrage ID',
+                es: 'ID de la petición',
+                zh: '请求ID',
+                id: 'ID permintaan',
+                pl: 'Identyfikator żądania',
+            },
+            'Timestamp': {
+                fr: 'Horodatage',
+                ru: 'Временная метка',
+                uk: 'Мітка часу',
+                pt: 'Timestamp',
+                nl: 'Tijdstempel',
+                de: 'Zeitstempel',
+                es: 'Timestamp',
+                zh: '时间戳',
+                id: 'Cap waktu',
+                pl: 'Sygnatura czasowa',
+            },
+
+            'client-side error': {
+                fr: 'Erreur Client',
+                ru: 'ошибка на стороне клиента',
+                uk: 'помилка на стороні клієнта',
+                pt: 'erro do lado do cliente',
+                nl: 'fout aan de gebruikerskant',
+                de: 'Clientseitiger Fehler',
+                es: 'Error del lado del cliente',
+                zh: '客户端错误',
+                id: 'Kesalahan sisi klien',
+                pl: 'błąd po stronie klienta',
+            },
+            'server-side error': {
+                fr: 'Erreur Serveur',
+                ru: 'ошибка на стороне сервера',
+                uk: 'помилка на стороні сервера',
+                pt: 'erro do lado do servidor',
+                nl: 'fout aan de serverkant',
+                de: 'Serverseitiger Fehler',
+                es: 'Error del lado del servidor',
+                zh: '服务端错误',
+                id: 'Kesalahan sisi server',
+                pl: 'błąd po stronie serwera',
+            },
+
+            'Your Client': {
+                fr: 'Votre Client',
+                ru: 'Ваш Браузер',
+                uk: 'Ваш Браузер',
+                pt: 'Seu Cliente',
+                nl: 'Jouw Client',
+                de: 'Ihr Client',
+                es: 'Tu Cliente',
+                zh: '您的客户端',
+                id: 'Klien Anda',
+                pl: 'Klient',
+            },
+            'Network': {
+                fr: 'Réseau',
+                ru: 'Сеть',
+                uk: 'Мережа',
+                pt: 'Rede',
+                nl: 'Netwerk',
+                de: 'Netzwerk',
+                es: 'Red',
+                zh: '网络',
+                id: 'Jaringan',
+                pl: 'Sieć',
+            },
+            'Web Server': {
+                fr: 'Serveur Web',
+                ru: 'Web Сервер',
+                uk: 'Web-сервер',
+                pt: 'Servidor web',
+                nl: 'Web Server',
+                de: 'Webserver',
+                es: 'Servidor Web',
+                zh: 'Web服务器',
+                id: 'Server web',
+                pl: 'Serwer WWW',
+            },
+            'What happened?': {
+                fr: 'Que s’est-il passé ?',
+                ru: 'Что произошло?',
+                uk: 'Що сталося?',
+                pt: 'O que aconteceu?',
+                nl: 'Wat is er gebeurd?',
+                de: 'Was ist passiert?',
+                es: '¿Que ha pasado?',
+                zh: '发生了什么？',
+                id: 'Apa yang terjadi?',
+                pl: 'Co się stało?',
+            },
+            'What can i do?': {
+                fr: 'Que puis-je faire ?',
+                ru: 'Что можно сделать?',
+                uk: 'Що можна зробити?',
+                pt: 'O que eu posso fazer?',
+                nl: 'Wat kan ik doen?',
+                de: 'Was kann ich machen?',
+                es: '¿Que puedo hacer?',
+                zh: '我能做什么？',
+                id: 'Apa yang bisa saya lakukan?',
+                pl: 'Co mogę zrobić?',
+            },
+            'Please try again in a few minutes': {
+                fr: 'Veuillez réessayer dans quelques minutes',
+                ru: 'Пожалуйста, попробуйте повторить запрос ещё раз чуть позже',
+                uk: 'Будь ласка, спробуйте повторити запит ще раз трохи пізніше',
+                pt: 'Por favor, tente novamente em alguns minutos',
+                nl: 'Probeer het alstublieft opnieuw over een paar minuten',
+                de: 'Bitte versuchen Sie es in ein paar Minuten erneut',
+                es: 'Por favor, intente nuevamente en unos minutos',
+                zh: '请在几分钟后重试',
+                id: 'Silakan coba lagi dalam beberapa menit',
+                pl: 'Spróbuj ponownie za kilka minut',
+            },
+            'Working': {
+                fr: 'Opérationnel',
+                ru: 'Работает',
+                uk: 'Працює',
+                pt: 'Funcionando',
+                nl: 'Functioneel',
+                de: 'Funktioniert',
+                es: 'Funcionando',
+                zh: '正常运行',
+                id: 'Fungsi',
+                pl: 'Działa',
+            },
+            'Unknown': {
+                fr: 'Inconnu',
+                ru: 'Неизвестно',
+                uk: 'Невідомо',
+                pt: 'Desconhecido',
+                nl: 'Onbekend',
+                de: 'Unbekannt',
+                es: 'Desconocido',
+                zh: '未知',
+                id: 'Tidak diketahui',
+                pl: 'Nieznany',
+            },
+            'Please try to change the request method, headers, payload, or URL': {
+                fr: 'Veuillez essayer de changer la méthode de requête, les en-têtes, le contenu ou l’URL',
+                ru: 'Пожалуйста, попробуйте изменить метод запроса, заголовки, его содержимое или URL',
+                uk: 'Будь ласка, спробуйте змінити метод запиту, заголовки, його вміст або URL-адресу',
+                pt: 'Tente alterar o método de solicitação, cabeçalhos, payload ou URL',
+                nl: 'Probeer het opnieuw met een andere methode, headers, payload of URL',
+                de: 'Bitte versuchen Sie, die Anfragemethode, Header, Payload oder URL zu ändern',
+                es: 'Por favor intente cambiar el método de la petición, cabeceras, carga o URL',
+                zh: '请尝试更改请求方法、标头、有效负载或URL',
+                id: 'Coba lagi dengan metode, header, muatan, atau URL yang berbeda',
+                pl: 'Spróbuj zmienić metodę żądania, nagłówki, żądanie lub adres URL',
+            },
+            'Please check your authorization data': {
+                fr: 'Veuillez vérifier vos données d’autorisation',
+                ru: 'Пожалуйста, проверьте данные авторизации',
+                uk: 'Будь ласка, перевірте дані авторизації',
+                pt: 'Verifique seus dados de autorização',
+                nl: 'Controleer de authenticatiegegevens',
+                de: 'Bitte überprüfen Sie Ihre Zugangsdaten',
+                es: 'Verifique sus datos de autorización',
+                zh: '请检查您的授权数据',
+                id: 'Memeriksa detail autentikasi',
+                pl: 'Sprawdź swoje dane autoryzacyjne',
+            },
+            'Please double-check the URL and try again': {
+                fr: 'Veuillez vérifier l’URL et réessayer',
+                ru: 'Пожалуйста, дважды проверьте URL и попробуйте снова',
+                uk: 'Будь ласка, двічі перевірте URL-адресу і спробуйте знову',
+                pt: 'Verifique novamente o URL e tente novamente',
+                nl: 'Controleer de URL en probeer het opnieuw',
+                de: 'Bitte überprüfen Sie die URL und versuchen Sie es erneut',
+                es: 'Verifique de nuevo la URL y vuelva a probar',
+                zh: '请再次检查URL并重试',
+                id: 'Periksa URL dan coba lagi',
+                pl: 'Sprawdź adres URL i spróbuj ponownie',
+            },
+        };
+
+        /**
+         * @param {string} token
+         * @return {string}
+         */
+        const serializeToken = function (token) {
+            return token.toLowerCase().replaceAll(/[^a-z0-9]/g, '');
+        };
+
+        // normalize the data keys
+        for (const key in data) {
+            Object.defineProperty(data, serializeToken(key), Object.getOwnPropertyDescriptor(data, key));
+            delete data[key];
+        }
+
+        // detect browser locale (take only 2 first symbols)
+        let activeLocale = navigator.language.substring(0, 2).toLowerCase();
+
+        /**
+         * @param {string} locale
+         */
+        this.setLocale = function (locale) {
+            activeLocale = locale.toLowerCase();
+        }
+
+        /**
+         * @param {string} token
+         * @param {string|undefined?} def
+         */
+        this.translate = function (token, def) {
+            const t = serializeToken(token);
+
+            if (activeLocale === 'en' && Object.prototype.hasOwnProperty.call(data, t)) {
+                return token
+            }
+
+            if (Object.prototype.hasOwnProperty.call(data, t) && Object.prototype.hasOwnProperty.call(data[t], activeLocale)) {
+                return data[t][activeLocale];
+            }
+
+            return def;
+        };
+
+        /**
+         * Localize all elements with HTML attribute `data-l10n`.
+         */
+        this.localizeDocument = function () {
+            const dataAttributeName = 'data-l10n';
+
+            Array.prototype.forEach.call(document.querySelectorAll('[' + dataAttributeName + ']'), ($el) => {
+                const attr = $el.getAttribute(dataAttributeName).trim(),
+                    token = attr.length > 0 ? attr : $el.innerText.trim(),
+                    localized = this.translate(token, undefined);
+
+                if (attr.length === 0) {
+                    $el.setAttribute(dataAttributeName, token);
+                }
+
+                if (localized !== undefined) {
+                    $el.innerText = localized;
+                } else {
+                    console.debug(`Unsupported l10n token detected: "${token}" (locale "${activeLocale}")`, $el);
+                }
+            });
+        };
+    },
+    writable: false,
+    enumerable: false,
+});
+
+window.l10n.localizeDocument();