Update CHANGELOG.md

* german translation

* update readmes and changelog

.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,14 @@
-/out
-/node_modules
-*.log
+.dockerignore
+Dockerfile
+.github
+.git
+.gitignore
+.editorconfig
+.idea
+.vscode
+test
+temp
+tmp
+LICENSE
+Makefile
+error-pages

.editorconfig

@@ -1,3 +1,5 @@
+# EditorConfig docs: <https://editorconfig.org/>
+
 root = true
 
 [*]
@@ -11,5 +13,5 @@ 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,22 @@
+# 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}
+    reviewers: [tarampampam]
+    assignees: [tarampampam]
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule: {interval: monthly}
+    reviewers: [tarampampam]
+    assignees: [tarampampam]
+
+  - package-ecosystem: docker
+    directory: /
+    schedule: {interval: monthly}
+    reviewers: [tarampampam]
+    assignees: [tarampampam]

.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-20.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: peter-evans/dockerhub-description@v3 # 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,112 @@ on:
     types: [published]
 
 jobs:
-  demo:
-    name: Update demonstration, hosted on github pages
-    runs-on: ubuntu-latest
+  purge-cdn-cache:
+    name: Purge jsDelivr CDN cache
+    runs-on: ubuntu-20.04
     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-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [linux, darwin] # linux, freebsd, darwin, windows
+        arch: [amd64]  # amd64, 386
+    steps:
+      - uses: actions/setup-go@v3
+        with: {go-version: 1.18.1}
 
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v3
+
+      - uses: gacts/github-slug@v1
+        id: slug
+
+      - name: Generate builder values
+        id: values
+        run: echo "::set-output name=binary-name::error-pages-${{ matrix.os }}-${{ matrix.arch }}"
+
+      - name: Build application
+        env:
+          GOOS: ${{ matrix.os }}
+          GOARCH: ${{ matrix.arch }}
+          CGO_ENABLED: 0
+          LDFLAGS: -s -w -X github.com/tarampampam/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
+    runs-on: ubuntu-20.04
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+
+      - uses: gacts/github-slug@v1
+        id: slug
+
+      - uses: docker/setup-qemu-action@v2 # Action page: <https://github.com/docker/setup-qemu-action>
+
+      - uses: docker/setup-buildx-action@v2 # Action page: <https://github.com/docker/setup-buildx-action>
+
+      - uses: docker/login-action@v2 # 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@v2 # 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@v3 # Action page: <https://github.com/docker/build-push-action>
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64,linux/arm/v6,linux/arm/v7
+          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-20.04
+    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,262 @@ name: tests
 
 on:
   push:
-    branches:
-      - master
-    tags-ignore:
-      - '**'
+    branches: [master, main]
+    tags-ignore: ['**']
+    paths-ignore: ['**.md']
   pull_request:
+    paths-ignore: ['**.md']
 
 jobs: # Docs: <https://git.io/JvxXE>
-  generate:
-    name: Try to run generator
-    runs-on: ubuntu-latest
+  gitleaks:
+    name: Gitleaks
+    runs-on: ubuntu-20.04
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+        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-20.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-go@v3
+        with: {go-version: 1.17} # On v1.18 I had an error "panic: load embedded ruleguard rules: rules/rules.go:13: can't load fmt"
+
+      - name: Run linter
+        uses: golangci/golangci-lint-action@v3 # Action page: <https://github.com/golangci/golangci-lint-action>
         with:
-          node-version: 12
+          version: v1.44 # without patch version
+          only-new-issues: false # show only new issues if it's a pull request
 
-      - uses: actions/cache@v2
+  validate-config-file:
+    name: Validate config file
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        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-20.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        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-20.04
+    steps:
+      - uses: actions/setup-go@v3
+        with: {go-version: 1.18}
+
+      - uses: actions/checkout@v3
+        with: {fetch-depth: 2} # Fixes codecov error 'Issue detecting commit SHA'
+
+      - name: Go modules Cache # Docs: <https://git.io/JfAKn#go---modules>
+        uses: actions/cache@v3
+        id: go-cache
         with:
-          path: '**/node_modules'
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: ${{ runner.os }}-go-
 
-      - name: Install dependencies
-        run: yarn install
+      - if: steps.go-cache.outputs.cache-hit != 'true'
+        run: go mod download
+
+      - name: Run Unit tests
+        run: go test -race -covermode=atomic -coverprofile /tmp/coverage.txt ./...
+
+      - uses: codecov/codecov-action@v3 # https://github.com/codecov/codecov-action
+        continue-on-error: true
+        with:
+          file: /tmp/coverage.txt
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  build:
+    name: Build for ${{ matrix.os }} (${{ matrix.arch }})
+    runs-on: ubuntu-20.04
+    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/setup-go@v3
+        with: {go-version: 1.18}
+
+      - uses: actions/checkout@v3
+
+      - uses: gacts/github-slug@v1
+        id: slug
+
+      - name: Go modules Cache # Docs: <https://git.io/JfAKn#go---modules>
+        uses: actions/cache@v3
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: ${{ runner.os }}-go-
+
+      - run: go mod download
+
+      - name: Build application
+        env:
+          GOOS: ${{ matrix.os }}
+          GOARCH: ${{ matrix.arch }}
+          CGO_ENABLED: 0
+          LDFLAGS: -s -w -X github.com/tarampampam/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@v3
+        with:
+          name: error-pages-${{ matrix.os }}-${{ matrix.arch }}
+          path: error-pages
+          if-no-files-found: error
+          retention-days: 1
+
+  generate:
+    name: Run templates generator
+    runs-on: ubuntu-20.04
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/download-artifact@v3
+        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 build ./out --verbose --index
 
-      - 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
 
-  docker-build:
+  docker-image:
     name: Build docker image
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
+    needs: [golangci-lint, go-test, validate-config-file]
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - 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@v3 # 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@v3
+        with:
+          name: docker-image
+          path: ./docker-image.tar
+          retention-days: 1
+
+  scan-docker-image:
+    name: Scan the docker image
+    runs-on: ubuntu-20.04
+    needs: [docker-image]
+    steps:
+      - uses: actions/checkout@v3 # is needed for `upload-sarif` action
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: docker-image
+          path: .artifact
+
+      - uses: aquasecurity/trivy-action@0.3.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@v2
+        if: always()
+        continue-on-error: true
+        with: {sarif_file: trivy-results.sarif}
+
+  poke-docker-image:
+    name: Run the docker image
+    runs-on: ubuntu-20.04
+    needs: [docker-image]
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: docker-image
+          path: .artifact
+
+      - working-directory: .artifact
+        run: docker load < docker-image.tar
+
+      - name: Download hurl
+        env:
+          VERSION: 1.5.0
+        run: curl -SL -o hurl.deb https://github.com/Orange-OpenSource/hurl/releases/download/${VERSION}/hurl_${VERSION}_amd64.deb
+
+      - name: Install hurl
+        run: sudo dpkg -i hurl.deb
+
+      - 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 --summary ./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,100 @@
+# 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
+    - bodyclose # Checks whether HTTP response body is closed successfully
+    - contextcheck # check the function whether use a non-inherited context
+    - deadcode # Finds unused code
+    - depguard # Go linter that checks if package imports are in a list of acceptable packages
+    - 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
+    - noctx # finds sending http request without context.Context
+    - nolintlint # Reports ill-formed or insufficient nolint directives
+    - prealloc # Finds slice declarations that could potentially be preallocated
+    - rowserrcheck # Checks whether Err of rows is checked successfully
+    - staticcheck # Staticcheck is a go vet on steroids, applying a ton of static analysis checks
+    - structcheck # Finds unused struct fields
+    - stylecheck # Stylecheck is a replacement for golint
+    - tparallel # detects inappropriate usage of t.Parallel() method in your Go test codes
+    - typecheck # Like the front-end of a Go compiler, parses and type-checks Go code
+    - unconvert # Remove unnecessary type conversions
+    - unparam # Reports unused function parameters
+    - unused # Checks Go code for unused constants, variables, functions and types
+    - varcheck # Finds unused global variables and constants
+    - 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
+        - noctx

CHANGELOG.md

@@ -4,6 +4,347 @@ 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.16.0
+
+### Added
+
+- Error pages now translated in German 🇩🇪 [#115]
+
+[#115]:https://github.com/tarampampam/error-pages/pull/115
+
+## v2.15.0
+
+### Added
+
+- Error pages now translated in Dutch 🇳🇱 [#104]
+
+[#104]:https://github.com/tarampampam/error-pages/pull/104
+
+## v2.14.0
+
+### Added
+
+- Error pages now translated in 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 in 🇫🇷 [#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 in 🇺🇦 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,79 @@
-# Image page: <https://hub.docker.com/_/node>
-FROM node:12.16.2-alpine as builder
+# syntax=docker/dockerfile:1.2
+
+# Image page: <https://hub.docker.com/_/golang>
+FROM golang:1.18.1-alpine as builder
+
+# 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 github.com/tarampampam/error-pages/internal/version.version=$APP_VERSION"
+
 RUN set -x \
-    && yarn install --frozen-lockfile \
-    && ./bin/generator.js -c ./configuration.json -o ./out
+    && go version \
+    && 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 --config-file ./error-pages.yml build ./html --verbose --index \
+    && 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=builder /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"
+
+# Docs: <https://docs.docker.com/engine/reference/builder/#healthcheck>
+HEALTHCHECK --interval=7s --timeout=2s CMD ["/bin/error-pages", "healthcheck", "--log-json"]
+
+ENTRYPOINT ["/bin/error-pages"]
+
+CMD ["serve", "--log-json"]

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 github.com/tarampampam/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 --summary ./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,201 @@
 <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/workflow/status/tarampampam/error-pages/tests?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/workflow/status/tarampampam/error-pages/release?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! ⚡</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
+[![image stats](https://dockeri.co/image/tarampampam/error-pages)][docker-hub-tags]
+
+| 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]               |
 
-[![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
 
-```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,29 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/fatih/color"
+	"github.com/tarampampam/error-pages/internal/cli"
+)
+
+// 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 {
+	cmd := cli.NewCommand(filepath.Base(os.Args[0]))
+
+	if err := cmd.Execute(); 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,41 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Main(t *testing.T) {
+	os.Args = []string{"", "--help"}
+	exitFn = func(code int) { assert.Equal(t, 0, code) }
+
+	output := capturer.CaptureStdout(main)
+
+	assert.Contains(t, output, "Usage:")
+	assert.Contains(t, output, "Available Commands:")
+	assert.Contains(t, output, "Flags:")
+}
+
+func Test_MainWithoutCommands(t *testing.T) {
+	os.Args = []string{""}
+	exitFn = func(code int) { assert.Equal(t, 0, code) }
+
+	output := capturer.CaptureStdout(main)
+
+	assert.Contains(t, output, "Usage:")
+	assert.Contains(t, output, "Available Commands:")
+	assert.Contains(t, output, "Flags:")
+}
+
+func Test_MainUnknownSubcommand(t *testing.T) {
+	os.Args = []string{"", "foobar"}
+	exitFn = func(code int) { assert.Equal(t, 1, code) }
+
+	output := capturer.CaptureStderr(main)
+
+	assert.Contains(t, output, "unknown command")
+	assert.Contains(t, output, "foobar")
+}

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,57 @@
+# Docker-compose file is used only for local development. This is not production-ready example.
+
+version: '3.8'
+
+volumes:
+  tmp-data: {}
+  golint-cache: {}
+
+services:
+  app: &app-service
+    image: golang:1.18.1-buster # Image page: <https://hub.docker.com/_/golang>
+    working_dir: /src
+    environment:
+      HOME: /tmp
+      GOPATH: /tmp
+    volumes:
+      - /etc/passwd:/etc/passwd:ro
+      - /etc/group:/etc/group:ro
+      - .:/src:rw
+      - tmp-data:/tmp:rw
+
+  web:
+    <<: *app-service
+    ports:
+      - "8080:8080/tcp" # Open <http://127.0.0.1:8080>
+    command:
+      - go
+      - run
+      - ./cmd/error-pages
+      - serve
+      - --verbose
+      - --port=8080
+      - --show-details
+      - --proxy-headers=X-Foo,Bar,Baz_blah
+    healthcheck:
+      test: ['CMD', 'wget', '--spider', '-q', 'http://127.0.0.1:8080/healthz']
+      interval: 5s
+      timeout: 2s
+
+  golint:
+    image: golangci/golangci-lint:v1.44-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:
+      - .:/src:ro
+      - golint-cache:/tmp/golint:rw
+    working_dir: /src
+    command: /bin/true
+
+  hurl:
+    image: orangeopensource/hurl:1.5.0
+    volumes:
+      - .:/src:ro
+    working_dir: /src
+    depends_on:
+      web:
+        condition: service_healthy

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,139 @@
+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
+
+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 github.com/tarampampam/error-pages
+
+go 1.18
+
+require (
+	github.com/a8m/envsubst v1.3.0
+	github.com/fasthttp/router v1.4.9
+	github.com/fatih/color v1.13.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.12.2
+	github.com/prometheus/client_model v0.2.0
+	github.com/spf13/cobra v1.4.0
+	github.com/spf13/pflag v1.0.5
+	github.com/stretchr/testify v1.7.1
+	github.com/valyala/fasthttp v1.37.0
+	go.uber.org/zap v1.21.0
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+)
+
+require (
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/klauspost/compress v1.15.0 // indirect
+	github.com/mattn/go-colorable v0.1.12 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/savsgio/gotils v0.0.0-20220401102855-e56b59f40436 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	go.uber.org/atomic v1.7.0 // indirect
+	go.uber.org/multierr v1.6.0 // indirect
+	golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9 // indirect
+	google.golang.org/protobuf v1.27.1 // indirect
+)

go.sum

@@ -0,0 +1,541 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/a8m/envsubst v1.3.0 h1:GmXKmVssap0YtlU3E230W98RWtWCyIZzjtf1apWWyAg=
+github.com/a8m/envsubst v1.3.0/go.mod h1:MVUTQNGQ3tsjOOtKCNd+fl8RzhsXcDvvAEzkhGtlsbY=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
+github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+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/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fasthttp/router v1.4.9 h1:8s1HEqP+GvsC2B8vPdLAPHJegs4s28z7UsraPuHM1K8=
+github.com/fasthttp/router v1.4.9/go.mod h1:oWPrQCi9QOrzxKC+rZuliS1+JhYj2bpR01J6T8vUDUQ=
+github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
+github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+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/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.15.0 h1:xqfchp4whNFxn5A4XFyyYtitiWI8Hy5EW59jEwcyL6U=
+github.com/klauspost/compress v1.15.0/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
+github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
+github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/savsgio/gotils v0.0.0-20220401102855-e56b59f40436 h1:sfTahD3f2BSjx9U3R4K09PkNuZZWthT7g6vzTIXNWkM=
+github.com/savsgio/gotils v0.0.0-20220401102855-e56b59f40436/go.mod h1:Gy+0tqhJvgGlqnTF8CVGP0AaGRjwBtXs/a5PA0Y3+A4=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/spf13/cobra v1.4.0 h1:y+wJpx64xcgO1V+RcnwW0LEHxTKRi2ZDPSBjWnrg88Q=
+github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.36.0/go.mod h1:t/G+3rLek+CyY9bnIE+YlMRddxVAAGjhxndDB4i4C0I=
+github.com/valyala/fasthttp v1.37.0 h1:7WHCyI7EAkQMVmrfBhWTCOaeROb1aCBiTopx63LkMbE=
+github.com/valyala/fasthttp v1.37.0/go.mod h1:t/G+3rLek+CyY9bnIE+YlMRddxVAAGjhxndDB4i4C0I=
+github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=
+go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
+go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9 h1:nhht2DYV/Sn3qOayu8lM+cU1ii9sTLUeBQwQQfUHtrs=
+golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

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,56 @@
+package breaker_test
+
+import (
+	"context"
+	"os"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,48 @@
+package checkers_test
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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:       ioutil.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:       ioutil.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,12 @@
+package checkers_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/checkers"
+)
+
+func TestLiveChecker_Check(t *testing.T) {
+	assert.NoError(t, checkers.NewLiveChecker().Check())
+}

internal/cli/build/command.go

@@ -0,0 +1,156 @@
+package build
+
+import (
+	"os"
+	"path"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/tarampampam/error-pages/internal/config"
+	"github.com/tarampampam/error-pages/internal/tpl"
+	"go.uber.org/zap"
+)
+
+// NewCommand creates `build` command.
+func NewCommand(log *zap.Logger, configFile *string) *cobra.Command {
+	var (
+		generateIndex bool
+		disableL10n   bool
+		cfg           *config.Config
+	)
+
+	cmd := &cobra.Command{
+		Use:     "build <output-directory>",
+		Aliases: []string{"b"},
+		Short:   "Build the error pages",
+		Args:    cobra.ExactArgs(1),
+		PreRunE: func(*cobra.Command, []string) (err error) {
+			if configFile == nil {
+				return errors.New("path to the config file is required for this command")
+			}
+
+			if cfg, err = config.FromYamlFile(*configFile); err != nil {
+				return err
+			}
+
+			return
+		},
+		RunE: func(_ *cobra.Command, args []string) error {
+			if len(args) != 1 {
+				return errors.New("wrong arguments count")
+			}
+
+			return run(log, cfg, args[0], generateIndex, disableL10n)
+		},
+	}
+
+	cmd.Flags().BoolVarP(
+		&generateIndex,
+		"index", "i",
+		false,
+		"generate index page",
+	)
+
+	cmd.Flags().BoolVarP(
+		&disableL10n,
+		"disable-l10n", "",
+		false,
+		"disable error pages localization",
+	)
+
+	return cmd
+}
+
+const (
+	outHTMLFileExt   = ".html"
+	outIndexFileName = "index"
+	outFilePerm      = os.FileMode(0664)
+	outDirPerm       = os.FileMode(0775)
+)
+
+func 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 := 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 := 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 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,7 @@
+package build_test
+
+import "testing"
+
+func TestNothing(t *testing.T) {
+	t.Skip("tests for this package have not been implemented yet")
+}

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://github.com/tarampampam/error-pages">project repository</a>.
+    </div>
+</footer>
+</body>
+</html>

internal/cli/healthcheck/command.go

@@ -0,0 +1,57 @@
+// Package healthcheck contains CLI `healthcheck` command implementation.
+package healthcheck
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/tarampampam/error-pages/internal/env"
+)
+
+type checker interface {
+	Check(port uint16) error
+}
+
+const portFlagName = "port"
+
+// NewCommand creates `healthcheck` command.
+func NewCommand(checker checker) *cobra.Command {
+	var port uint16
+
+	cmd := &cobra.Command{
+		Use:     "healthcheck",
+		Aliases: []string{"chk", "health", "check"},
+		Short:   "Health checker for the HTTP server. Use case - docker healthcheck",
+		PreRunE: func(c *cobra.Command, _ []string) (lastErr error) {
+			c.Flags().VisitAll(func(flag *pflag.Flag) {
+				// flag was NOT defined using CLI (flags should have maximal priority)
+				if !flag.Changed && flag.Name == portFlagName {
+					if envPort, exists := env.ListenPort.Lookup(); exists && envPort != "" {
+						if p, err := strconv.ParseUint(envPort, 10, 16); err == nil { //nolint:gomnd
+							port = uint16(p)
+						} else {
+							lastErr = fmt.Errorf("wrong TCP port environment variable [%s] value", envPort)
+						}
+					}
+				}
+			})
+
+			return lastErr
+		},
+		RunE: func(*cobra.Command, []string) error {
+			return checker.Check(port)
+		},
+	}
+
+	cmd.Flags().Uint16VarP(
+		&port,
+		portFlagName,
+		"p",
+		8080, //nolint:gomnd // must be same as default serve `--port` flag value
+		fmt.Sprintf("TCP port number [$%s]", env.ListenPort),
+	)
+
+	return cmd
+}

internal/cli/healthcheck/command_test.go

@@ -0,0 +1,94 @@
+package healthcheck_test
+
+import (
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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.Use)
+	assert.ElementsMatch(t, []string{"chk", "health", "check"}, cmd.Aliases)
+	assert.NotNil(t, cmd.RunE)
+}
+
+func TestCommandRun(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+	cmd.SetArgs([]string{})
+
+	output := capturer.CaptureOutput(func() {
+		assert.NoError(t, cmd.Execute())
+	})
+
+	assert.Empty(t, output)
+}
+
+func TestCommandRunFailed(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: errors.New("foo err")})
+	cmd.SetArgs([]string{})
+
+	output := capturer.CaptureStderr(func() {
+		assert.Error(t, cmd.Execute())
+	})
+
+	assert.Contains(t, output, "foo err")
+}
+
+func TestPortFlagWrongArgument(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+	cmd.SetArgs([]string{"-p", "65536"}) // 65535 is max
+
+	var executed bool
+
+	cmd.RunE = func(*cobra.Command, []string) error {
+		executed = true
+
+		return nil
+	}
+
+	output := capturer.CaptureStderr(func() {
+		assert.Error(t, cmd.Execute())
+	})
+
+	assert.Contains(t, output, "invalid argument")
+	assert.Contains(t, output, "65536")
+	assert.Contains(t, output, "value out of range")
+	assert.False(t, executed)
+}
+
+func TestPortFlagWrongEnvValue(t *testing.T) {
+	cmd := healthcheck.NewCommand(&fakeChecker{err: nil})
+	cmd.SetArgs([]string{})
+
+	assert.NoError(t, os.Setenv("LISTEN_PORT", "65536")) // 65535 is max
+
+	defer func() { assert.NoError(t, os.Unsetenv("LISTEN_PORT")) }()
+
+	var executed bool
+
+	cmd.RunE = func(*cobra.Command, []string) error {
+		executed = true
+
+		return nil
+	}
+
+	output := capturer.CaptureStderr(func() {
+		assert.Error(t, cmd.Execute())
+	})
+
+	assert.Contains(t, output, "wrong TCP port")
+	assert.Contains(t, output, "environment variable")
+	assert.Contains(t, output, "65536")
+	assert.False(t, executed)
+}

internal/cli/root.go

@@ -0,0 +1,93 @@
+// Package cli contains CLI command handlers.
+package cli
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/tarampampam/error-pages/internal/checkers"
+	buildCmd "github.com/tarampampam/error-pages/internal/cli/build"
+	healthcheckCmd "github.com/tarampampam/error-pages/internal/cli/healthcheck"
+	serveCmd "github.com/tarampampam/error-pages/internal/cli/serve"
+	versionCmd "github.com/tarampampam/error-pages/internal/cli/version"
+	"github.com/tarampampam/error-pages/internal/env"
+	"github.com/tarampampam/error-pages/internal/logger"
+	"github.com/tarampampam/error-pages/internal/version"
+)
+
+const configFileFlagName = "config-file"
+
+// NewCommand creates root command.
+func NewCommand(appName string) *cobra.Command { //nolint:funlen
+	var (
+		configFile string
+		verbose    bool
+		debug      bool
+		logJSON    bool
+	)
+
+	ctx := context.Background() // main CLI context
+
+	// create "default" logger (will be overwritten later with customized)
+	log, err := logger.New(false, false, false)
+	if err != nil {
+		panic(err)
+	}
+
+	cmd := &cobra.Command{
+		Use: appName,
+		PersistentPreRunE: func(c *cobra.Command, _ []string) error {
+			_ = log.Sync() // sync previous logger instance
+
+			customizedLog, e := logger.New(verbose, debug, logJSON)
+			if e != nil {
+				return e
+			}
+
+			*log = *customizedLog // override "default" logger with customized
+
+			c.Flags().VisitAll(func(flag *pflag.Flag) {
+				// flag was NOT defined using CLI (flags should have maximal priority)
+				if !flag.Changed && flag.Name == configFileFlagName {
+					if envConfigFile, exists := env.ConfigFilePath.Lookup(); exists && envConfigFile != "" {
+						configFile = envConfigFile
+					}
+				}
+			})
+
+			return nil
+		},
+		PersistentPostRun: func(*cobra.Command, []string) {
+			// error ignoring reasons:
+			// - <https://github.com/uber-go/zap/issues/772>
+			// - <https://github.com/uber-go/zap/issues/328>
+			_ = log.Sync()
+		},
+		SilenceErrors: true,
+		SilenceUsage:  true,
+		CompletionOptions: cobra.CompletionOptions{
+			DisableDefaultCmd: true,
+		},
+	}
+
+	cmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose output")
+	cmd.PersistentFlags().BoolVarP(&debug, "debug", "", false, "debug output")
+	cmd.PersistentFlags().BoolVarP(&logJSON, "log-json", "", false, "logs in JSON format")
+	cmd.PersistentFlags().StringVarP(
+		&configFile,
+		configFileFlagName, "c",
+		"./error-pages.yml",
+		fmt.Sprintf("path to the config file [$%s]", env.ConfigFilePath),
+	)
+
+	cmd.AddCommand(
+		versionCmd.NewCommand(version.Version()),
+		healthcheckCmd.NewCommand(checkers.NewHealthChecker(ctx)),
+		buildCmd.NewCommand(log, &configFile),
+		serveCmd.NewCommand(ctx, log, &configFile),
+	)
+
+	return cmd
+}

internal/cli/root_test.go

@@ -0,0 +1,84 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/cli"
+)
+
+func TestSubcommands(t *testing.T) {
+	cmd := cli.NewCommand("unit test")
+
+	cases := []struct {
+		giveName string
+	}{
+		{giveName: "build"},
+		{giveName: "version"},
+		{giveName: "healthcheck"},
+		{giveName: "serve"},
+	}
+
+	// get all existing subcommands and put into the map
+	subcommands := make(map[string]*cobra.Command)
+	for _, sub := range cmd.Commands() {
+		subcommands[sub.Name()] = sub
+	}
+
+	for _, tt := range cases {
+		tt := tt
+		t.Run(tt.giveName, func(t *testing.T) {
+			if _, exists := subcommands[tt.giveName]; !exists {
+				assert.Failf(t, "command not found", "command [%s] was not found", tt.giveName)
+			}
+		})
+	}
+}
+
+func TestFlags(t *testing.T) {
+	cmd := cli.NewCommand("unit test")
+
+	cases := []struct {
+		giveName      string
+		wantShorthand string
+		wantDefault   string
+	}{
+		{giveName: "verbose", wantShorthand: "v", wantDefault: "false"},
+		{giveName: "debug", wantShorthand: "", wantDefault: "false"},
+		{giveName: "log-json", wantShorthand: "", wantDefault: "false"},
+		{giveName: "config-file", wantShorthand: "c", wantDefault: "./error-pages.yml"},
+	}
+
+	for _, tt := range cases {
+		tt := tt
+		t.Run(tt.giveName, func(t *testing.T) {
+			flag := cmd.Flag(tt.giveName)
+
+			if flag == nil {
+				assert.Failf(t, "flag not found", "flag [%s] was not found", tt.giveName)
+
+				return
+			}
+
+			assert.Equal(t, tt.wantShorthand, flag.Shorthand)
+			assert.Equal(t, tt.wantDefault, flag.DefValue)
+		})
+	}
+}
+
+func TestExecuting(t *testing.T) {
+	cmd := cli.NewCommand("unit test")
+	cmd.SetArgs([]string{})
+
+	var executed bool
+
+	if cmd.Run == nil { // override "Run" property for test (if it was not set)
+		cmd.Run = func(cmd *cobra.Command, args []string) {
+			executed = true
+		}
+	}
+
+	assert.NoError(t, cmd.Execute())
+	assert.True(t, executed)
+}

internal/cli/serve/command.go

@@ -0,0 +1,162 @@
+package serve
+
+import (
+	"context"
+	"errors"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/tarampampam/error-pages/internal/breaker"
+	"github.com/tarampampam/error-pages/internal/config"
+	appHttp "github.com/tarampampam/error-pages/internal/http"
+	"github.com/tarampampam/error-pages/internal/pick"
+	"go.uber.org/zap"
+)
+
+// NewCommand creates `serve` command.
+func NewCommand(ctx context.Context, log *zap.Logger, configFile *string) *cobra.Command {
+	var (
+		f   flags
+		cfg *config.Config
+	)
+
+	cmd := &cobra.Command{
+		Use:     "serve",
+		Aliases: []string{"s", "server"},
+		Short:   "Start HTTP server",
+		PreRunE: func(cmd *cobra.Command, _ []string) (err error) {
+			if configFile == nil {
+				return errors.New("path to the config file is required for this command")
+			}
+
+			if err = f.OverrideUsingEnv(cmd.Flags()); err != nil {
+				return err
+			}
+
+			if cfg, err = config.FromYamlFile(*configFile); err != nil {
+				return err
+			}
+
+			return f.Validate()
+		},
+		RunE: func(*cobra.Command, []string) error { return run(ctx, log, cfg, f) },
+	}
+
+	f.Init(cmd.Flags())
+
+	return cmd
+}
+
+// run current command.
+func run(parentCtx context.Context, log *zap.Logger, cfg *config.Config, f flags) error { //nolint:funlen
+	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 }
+
+		opt = f.ToOptions()
+	)
+
+	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)
+
+	// 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)
+
+		log.Info("Server starting",
+			zap.String("addr", f.Listen.IP),
+			zap.Uint16("port", f.Listen.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),
+		)
+
+		if err := server.Start(f.Listen.IP, f.Listen.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/serve/flags.go

@@ -0,0 +1,235 @@
+package serve
+
+import (
+	"fmt"
+	"net"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/pflag"
+	"github.com/tarampampam/error-pages/internal/env"
+	"github.com/tarampampam/error-pages/internal/options"
+)
+
+type flags struct {
+	Listen struct {
+		IP   string
+		Port uint16
+	}
+	template struct {
+		name string
+	}
+	l10n struct {
+		disabled bool
+	}
+	defaultErrorPage string
+	defaultHTTPCode  uint16
+	showDetails      bool
+	proxyHTTPHeaders string // comma-separated
+}
+
+const (
+	listenFlagName           = "listen"
+	portFlagName             = "port"
+	templateNameFlagName     = "template-name"
+	defaultErrorPageFlagName = "default-error-page"
+	defaultHTTPCodeFlagName  = "default-http-code"
+	showDetailsFlagName      = "show-details"
+	proxyHTTPHeadersFlagName = "proxy-headers"
+	disableL10nFlagName      = "disable-l10n"
+)
+
+const (
+	useRandomTemplate              = "random"
+	useRandomTemplateOnEachRequest = "i-said-random"
+	useRandomTemplateDaily         = "random-daily"
+	useRandomTemplateHourly        = "random-hourly"
+)
+
+func (f *flags) Init(flagSet *pflag.FlagSet) {
+	flagSet.StringVarP(
+		&f.Listen.IP,
+		listenFlagName, "l",
+		"0.0.0.0",
+		fmt.Sprintf("IP address to Listen on [$%s]", env.ListenAddr),
+	)
+	flagSet.Uint16VarP(
+		&f.Listen.Port,
+		portFlagName, "p",
+		8080, //nolint:gomnd // must be same as default healthcheck `--port` flag value
+		fmt.Sprintf("TCP prt number [$%s]", env.ListenPort),
+	)
+	flagSet.StringVarP(
+		&f.template.name,
+		templateNameFlagName, "t",
+		"",
+		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) [$%s]",
+			useRandomTemplate,
+			useRandomTemplateOnEachRequest,
+			useRandomTemplateDaily,
+			useRandomTemplateHourly,
+			env.TemplateName,
+		),
+	)
+	flagSet.StringVarP(
+		&f.defaultErrorPage,
+		defaultErrorPageFlagName, "",
+		"404",
+		fmt.Sprintf("default error page [$%s]", env.DefaultErrorPage),
+	)
+	flagSet.Uint16VarP(
+		&f.defaultHTTPCode,
+		defaultHTTPCodeFlagName, "",
+		404, //nolint:gomnd
+		fmt.Sprintf("default HTTP response code [$%s]", env.DefaultHTTPCode),
+	)
+	flagSet.BoolVarP(
+		&f.showDetails,
+		showDetailsFlagName, "",
+		false,
+		fmt.Sprintf("show request details in response [$%s]", env.ShowDetails),
+	)
+	flagSet.StringVarP(
+		&f.proxyHTTPHeaders,
+		proxyHTTPHeadersFlagName, "",
+		"",
+		fmt.Sprintf("proxy HTTP request headers list (comma-separated) [$%s]", env.ProxyHTTPHeaders),
+	)
+	flagSet.BoolVarP(
+		&f.l10n.disabled,
+		disableL10nFlagName, "",
+		false,
+		fmt.Sprintf("disable error pages localization [$%s]", env.DisableL10n),
+	)
+}
+
+func (f *flags) OverrideUsingEnv(flagSet *pflag.FlagSet) (lastErr error) { //nolint:gocognit,gocyclo
+	flagSet.VisitAll(func(flag *pflag.Flag) {
+		// flag was NOT defined using CLI (flags should have maximal priority)
+		if !flag.Changed { //nolint:nestif
+			switch flag.Name {
+			case listenFlagName:
+				if envVar, exists := env.ListenAddr.Lookup(); exists {
+					f.Listen.IP = strings.TrimSpace(envVar)
+				}
+
+			case portFlagName:
+				if envVar, exists := env.ListenPort.Lookup(); exists {
+					if p, err := strconv.ParseUint(envVar, 10, 16); err == nil { //nolint:gomnd
+						f.Listen.Port = uint16(p)
+					} else {
+						lastErr = fmt.Errorf("wrong TCP port environment variable [%s] value", envVar)
+					}
+				}
+
+			case templateNameFlagName:
+				if envVar, exists := env.TemplateName.Lookup(); exists {
+					f.template.name = strings.TrimSpace(envVar)
+				}
+
+			case defaultErrorPageFlagName:
+				if envVar, exists := env.DefaultErrorPage.Lookup(); exists {
+					f.defaultErrorPage = strings.TrimSpace(envVar)
+				}
+
+			case defaultHTTPCodeFlagName:
+				if envVar, exists := env.DefaultHTTPCode.Lookup(); exists {
+					if code, err := strconv.ParseUint(envVar, 10, 16); err == nil { //nolint:gomnd
+						f.defaultHTTPCode = uint16(code)
+					} else {
+						lastErr = fmt.Errorf("wrong default HTTP response code environment variable [%s] value", envVar)
+					}
+				}
+
+			case showDetailsFlagName:
+				if envVar, exists := env.ShowDetails.Lookup(); exists {
+					if b, err := strconv.ParseBool(envVar); err == nil {
+						f.showDetails = b
+					}
+				}
+
+			case proxyHTTPHeadersFlagName:
+				if envVar, exists := env.ProxyHTTPHeaders.Lookup(); exists {
+					f.proxyHTTPHeaders = strings.TrimSpace(envVar)
+				}
+
+			case disableL10nFlagName:
+				if envVar, exists := env.DisableL10n.Lookup(); exists {
+					if b, err := strconv.ParseBool(envVar); err == nil {
+						f.l10n.disabled = b
+					}
+				}
+			}
+		}
+	})
+
+	return lastErr
+}
+
+func (f *flags) Validate() error {
+	if net.ParseIP(f.Listen.IP) == nil {
+		return fmt.Errorf("wrong IP address [%s] for listening", f.Listen.IP)
+	}
+
+	if f.defaultHTTPCode > 599 { //nolint:gomnd
+		return fmt.Errorf("wrong default HTTP response code [%d]", f.defaultHTTPCode)
+	}
+
+	if strings.ContainsRune(f.proxyHTTPHeaders, ' ') {
+		return fmt.Errorf("whitespaces in the HTTP headers for proxying [%s] are not allowed", f.proxyHTTPHeaders)
+	}
+
+	return nil
+}
+
+// headersToProxy converts a comma-separated string with headers list into strings slice (with a sorting and without
+// duplicates).
+func (f *flags) headersToProxy() []string {
+	var raw = strings.Split(f.proxyHTTPHeaders, ",")
+
+	if len(raw) == 0 {
+		return []string{}
+	} else if len(raw) == 1 {
+		if h := strings.TrimSpace(raw[0]); h != "" {
+			return []string{h}
+		} else {
+			return []string{}
+		}
+	}
+
+	var m = make(map[string]struct{}, len(raw))
+
+	// make unique and ignore empty strings
+	for _, h := range raw {
+		if h = strings.TrimSpace(h); h != "" {
+			if _, ok := m[h]; !ok {
+				m[h] = struct{}{}
+			}
+		}
+	}
+
+	// convert map into slice
+	var headers = make([]string, 0, len(m))
+	for h := range m {
+		headers = append(headers, h)
+	}
+
+	// make sort
+	sort.Strings(headers)
+
+	return headers
+}
+
+func (f *flags) ToOptions() (o options.ErrorPage) {
+	o.Default.PageCode = f.defaultErrorPage
+	o.Default.HTTPCode = f.defaultHTTPCode
+	o.L10n.Disabled = f.l10n.disabled
+	o.Template.Name = f.template.name
+	o.ShowDetails = f.showDetails
+	o.ProxyHTTPHeaders = f.headersToProxy()
+
+	return o
+}

internal/cli/version/command.go

@@ -0,0 +1,24 @@
+// Package version contains CLI `version` command implementation.
+package version
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/spf13/cobra"
+)
+
+// NewCommand creates `version` command.
+func NewCommand(ver string) *cobra.Command {
+	return &cobra.Command{
+		Use:     "version",
+		Aliases: []string{"v", "ver"},
+		Short:   "Display application version",
+		RunE: func(*cobra.Command, []string) (err error) {
+			_, err = fmt.Fprintf(os.Stdout, "app version:\t%s (%s)\n", ver, runtime.Version())
+
+			return
+		},
+	}
+}

internal/cli/version/command_test.go

@@ -0,0 +1,30 @@
+package version_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/cli/version"
+)
+
+func TestProperties(t *testing.T) {
+	cmd := version.NewCommand("")
+
+	assert.Equal(t, "version", cmd.Use)
+	assert.ElementsMatch(t, []string{"v", "ver"}, cmd.Aliases)
+	assert.NotNil(t, cmd.RunE)
+}
+
+func TestCommandRun(t *testing.T) {
+	cmd := version.NewCommand("1.2.3@foobar")
+	cmd.SetArgs([]string{})
+
+	output := capturer.CaptureStdout(func() {
+		assert.NoError(t, cmd.Execute())
+	})
+
+	assert.Contains(t, output, "1.2.3@foobar")
+	assert.Contains(t, output, runtime.Version())
+}

internal/config/config.go

@@ -0,0 +1,256 @@
+package config
+
+import (
+	"io/ioutil"
+	"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 = ioutil.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 := ioutil.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,195 @@
+package config_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,26 @@
+// Package env contains all about environment variables, that can be used by current application.
+package env
+
+import "os"
+
+type envVariable string
+
+const (
+	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
+)
+
+// 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,55 @@
+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))
+}
+
+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},
+	}
+
+	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,126 @@
+package core
+
+import (
+	"strconv"
+
+	"github.com/tarampampam/error-pages/internal/config"
+	"github.com/tarampampam/error-pages/internal/options"
+	"github.com/tarampampam/error-pages/internal/tpl"
+	"github.com/valyala/fasthttp"
+)
+
+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 { //nolint:gomnd
+						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,117 @@
+package core_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/http/core"
+	"github.com/valyala/fasthttp"
+)
+
+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,34 @@
+package errorpage
+
+import (
+	"github.com/tarampampam/error-pages/internal/config"
+	"github.com/tarampampam/error-pages/internal/http/core"
+	"github.com/tarampampam/error-pages/internal/options"
+	"github.com/tarampampam/error-pages/internal/tpl"
+	"github.com/valyala/fasthttp"
+)
+
+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,49 @@
+package index
+
+import (
+	"strconv"
+
+	"github.com/tarampampam/error-pages/internal/config"
+	"github.com/tarampampam/error-pages/internal/http/core"
+	"github.com/tarampampam/error-pages/internal/options"
+	"github.com/tarampampam/error-pages/internal/tpl"
+	"github.com/valyala/fasthttp"
+)
+
+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,14 @@
+package notfound
+
+import (
+	"github.com/valyala/fasthttp"
+)
+
+// NewHandler creates handler missing requests handling.
+func NewHandler() fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		ctx.SetContentType("text/plain; charset=utf-8")
+		ctx.SetStatusCode(fasthttp.StatusNotFound)
+		_, _ = ctx.WriteString("Wrong request URL. Error pages are available at the following URLs: /{code}.html")
+	}
+}

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,104 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/fasthttp/router"
+	"github.com/tarampampam/error-pages/internal/checkers"
+	"github.com/tarampampam/error-pages/internal/config"
+	"github.com/tarampampam/error-pages/internal/http/common"
+	errorpageHandler "github.com/tarampampam/error-pages/internal/http/handlers/errorpage"
+	healthzHandler "github.com/tarampampam/error-pages/internal/http/handlers/healthz"
+	indexHandler "github.com/tarampampam/error-pages/internal/http/handlers/index"
+	metricsHandler "github.com/tarampampam/error-pages/internal/http/handlers/metrics"
+	notfoundHandler "github.com/tarampampam/error-pages/internal/http/handlers/notfound"
+	versionHandler "github.com/tarampampam/error-pages/internal/http/handlers/version"
+	"github.com/tarampampam/error-pages/internal/metrics"
+	"github.com/tarampampam/error-pages/internal/options"
+	"github.com/tarampampam/error-pages/internal/tpl"
+	"github.com/tarampampam/error-pages/internal/version"
+	"github.com/valyala/fasthttp"
+	"go.uber.org/zap"
+)
+
+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) Server {
+	rdr := tpl.NewTemplateRenderer()
+
+	return Server{
+		// fasthttp docs: <https://github.com/valyala/fasthttp>
+		fast: &fasthttp.Server{
+			WriteTimeout:          defaultWriteTimeout,
+			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) error {
+	return s.fast.ListenAndServe(ip + ":" + strconv.Itoa(int(port)))
+}
+
+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))
+
+	s.router.NotFound = notfoundHandler.NewHandler()
+
+	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/logger.go

@@ -0,0 +1,38 @@
+// Package logger contains functions for a working with application logging.
+package logger
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// New creates new "zap" logger with little customization.
+func New(verbose, debug, logJSON bool) (*zap.Logger, error) {
+	var config zap.Config
+
+	if logJSON {
+		config = zap.NewProductionConfig()
+	} else {
+		config = zap.NewDevelopmentConfig()
+		config.EncoderConfig.EncodeLevel = zapcore.LowercaseColorLevelEncoder
+		config.EncoderConfig.EncodeTime = zapcore.TimeEncoderOfLayout("15:04:05")
+	}
+
+	// default configuration for all encoders
+	config.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
+	config.Development = false
+	config.DisableStacktrace = true
+	config.DisableCaller = true
+
+	if debug {
+		config.Development = true
+		config.DisableStacktrace = false
+		config.DisableCaller = false
+	}
+
+	if verbose || debug {
+		config.Level = zap.NewAtomicLevelAt(zap.DebugLevel)
+	}
+
+	return config.Build()
+}

internal/logger/logger_test.go

@@ -0,0 +1,80 @@
+package logger_test
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/logger"
+)
+
+func TestNewNotVerboseDebugJSON(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(false, false, false)
+		assert.NoError(t, err)
+
+		log.Info("inf msg")
+		log.Debug("dbg msg")
+		log.Error("err msg")
+	})
+
+	assert.Contains(t, output, time.Now().Format("15:04:05"))
+	assert.Regexp(t, `\t.+info.+\tinf msg`, output)
+	assert.NotContains(t, output, "dbg msg")
+	assert.Contains(t, output, "err msg")
+}
+
+func TestNewVerboseNotDebugJSON(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(true, false, false)
+		assert.NoError(t, err)
+
+		log.Info("inf msg")
+		log.Debug("dbg msg")
+		log.Error("err msg")
+	})
+
+	assert.Contains(t, output, time.Now().Format("15:04:05"))
+	assert.Regexp(t, `\t.+info.+\tinf msg`, output)
+	assert.Contains(t, output, "dbg msg")
+	assert.Contains(t, output, "err msg")
+}
+
+func TestNewVerboseDebugNotJSON(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(true, true, false)
+		assert.NoError(t, err)
+
+		log.Info("inf msg")
+		log.Debug("dbg msg")
+		log.Error("err msg")
+	})
+
+	assert.Contains(t, output, time.Now().Format("15:04:05"))
+	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 TestNewNotVerboseDebugButJSON(t *testing.T) {
+	output := capturer.CaptureStderr(func() {
+		log, err := logger.New(false, false, true)
+		assert.NoError(t, err)
+
+		log.Info("inf msg")
+		log.Debug("dbg 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":"info","ts":0.1,"msg":"inf msg"}`, lines[0])
+	assert.JSONEq(t, `{"level":"error","ts":0.1,"msg":"err msg"}`, lines[1])
+}

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,70 @@
+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"
+	"github.com/tarampampam/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,18 @@
+package metrics_test
+
+import (
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,16 @@
+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
+}

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,57 @@
+package pick_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,130 @@
+package pick_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,35 @@
+package tpl_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,66 @@
+package tpl_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/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,218 @@
+package tpl
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"strconv"
+	"sync"
+	"text/template"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/tarampampam/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
+	},
+}
+
+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++ {
+		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,130 @@
+package tpl_test
+
+import (
+	"math/rand"
+	"strconv"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tarampampam/error-pages/internal/tpl"
+)
+
+func Test_Render(t *testing.T) {
+	renderer := tpl.NewTemplateRenderer()
+	defer func() { _ = renderer.Close() }()
+
+	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",
+		},
+	} {
+		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,655 @@
+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',
+            },
+            'Good luck': {
+                fr: 'Bonne chance',
+                ru: 'Удачи',
+                uk: 'Успіхів',
+                pt: 'Boa sorte',
+                nl: 'Veel succes',
+                de: 'Viel Glück',
+            },
+            'UH OH': {
+                fr: 'Oups',
+                ru: 'Ох',
+                uk: 'Ох',
+                pt: 'Ops',
+                nl: 'Oeps',
+                de: 'Hoppla',
+            },
+            'Request details': {
+                fr: 'Détails de la requête',
+                ru: 'Детали запроса',
+                uk: 'Деталі запиту',
+                pt: 'Detalhes da solicitação',
+                nl: 'Details van verzoek',
+                de: 'Details der Anfrage',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            'Bad Request': {
+                fr: 'Mauvaise requête',
+                ru: 'Некорректный запрос',
+                uk: 'Неправильний запит',
+                pt: 'Requisição inválida',
+                nl: 'Foutieve anvraag',
+                de: 'Fehlerhafte Anfrage',
+            },
+            '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',
+            },
+            'Unauthorized': {
+                fr: 'Non autorisé',
+                ru: 'Запрос не авторизован',
+                uk: 'Несанкціонований доступ',
+                pt: 'Não autorizado',
+                nl: 'Niet geautoriseerd',
+                de: 'Nicht autorisiert',
+            },
+            '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',
+            },
+            'Forbidden': {
+                fr: 'Interdit',
+                ru: 'Запрещено',
+                uk: 'Заборонено',
+                pt: 'Proibido',
+                nl: 'Verboden',
+                de: 'Verboten',
+            },
+            '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',
+            },
+            'Not Found': {
+                fr: 'Introuvable',
+                ru: 'Страница не найдена',
+                uk: 'Сторінка не знайдена',
+                pt: 'Não encontrado',
+                nl: 'Niet gevonden',
+                de: 'Nicht gefunden',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            'Request Timeout': {
+                fr: 'Requête expiré',
+                ru: 'Истекло время ожидания',
+                uk: 'Час запиту закінчився',
+                pt: 'Tempo limite de solicitação excedido',
+                nl: 'Aanvraagtijd verstreken',
+                de: 'Zeitüberschreitung der Anforderung',
+            },
+            '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',
+            },
+            'Conflict': {
+                fr: 'Conflit',
+                ru: 'Конфликт',
+                uk: 'Конфлікт',
+                pt: 'Conflito',
+                nl: 'Conflict',
+                de: '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',
+            },
+            'Gone': {
+                fr: 'Supprimé',
+                ru: 'Удалено',
+                uk: 'Вилучений',
+                pt: 'Removido',
+                nl: 'Verdwenen',
+                de: 'Verschwunden',
+            },
+            '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',
+            },
+            'Length Required': {
+                fr: 'Longueur requise',
+                ru: 'Необходима длина',
+                uk: 'Потрібно вказати розмір',
+                pt: 'Content-Length necessário',
+                nl: 'Lengte benodigd',
+                de: 'Länge benötigt',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            'Payload Too Large': {
+                fr: 'Charge trop volumineuse',
+                ru: 'Слишком большой запрос',
+                uk: 'Занадто великий запит',
+                pt: 'Payload muito grande',
+                nl: 'Aanvraag te grood',
+                de: 'Anfrage zu groß',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+            'Too Many Requests': {
+                fr: 'Trop de requêtes',
+                ru: 'Слишком много запросов',
+                uk: 'Занадто багато запитів',
+                pt: 'Excesso de solicitações',
+                nl: 'Te veel requests',
+                de: 'Zu viele Anfragen',
+            },
+            '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',
+            },
+            'Internal Server Error': {
+                fr: 'Erreur interne du serveur',
+                ru: 'Внутренняя ошибка сервера',
+                uk: 'Внутрішня помилка сервера',
+                pt: 'Erro do Servidor Interno',
+                nl: 'Interne serverfout',
+                de: 'Interner Server-Fehler',
+            },
+            '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',
+            },
+            'Bad Gateway': {
+                fr: 'Mauvaise passerelle',
+                ru: 'Ошибка шлюза',
+                uk: 'Помилка шлюзу',
+                pt: 'Gateway inválido',
+                nl: 'Ongeldige Gateway',
+                de: 'Fehlerhafter Gateway',
+            },
+            '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: 'Сервер отримав неправильну відповідь з сервера Upstream',
+                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',
+            },
+            'Service Unavailable': {
+                fr: 'Service indisponible',
+                ru: 'Сервис недоступен',
+                uk: 'Сервіс недоступний',
+                pt: 'Serviço não disponível',
+                nl: 'Dienst niet beschikbaar',
+                de: 'Dienst nicht verfügbar',
+            },
+            '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',
+            },
+            'Gateway Timeout': {
+                fr: 'Expiration Passerelle',
+                ru: 'Шлюз не отвечает',
+                uk: 'Шлюз не відповідає',
+                pt: 'Tempo limite do gateway excedido',
+                nl: 'Gateway Verlopen',
+                de: 'Gateway Zeitüberschreitung',
+            },
+            'The gateway has timed out': {
+                fr: 'Le temps d’attente de la passerelle est dépassé',
+                ru: 'Сервер не дождался ответа от вышестоящего сервера',
+                uk: 'Сервер не чекав відповіді від сервера Upstream',
+                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',
+            },
+            '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',
+            },
+            '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',
+            },
+
+            'Host': {
+                fr: 'Hôte',
+                ru: 'Хост',
+                uk: 'Хост',
+                pt: 'Hospedeiro',
+                nl: 'Host',
+                de: 'Host',
+            },
+            'Original URI': {
+                fr: 'URI d’origine',
+                ru: 'Исходный URI',
+                uk: 'Вихідний URI',
+                pt: 'URI original',
+                nl: 'Originele URI',
+                de: 'Originale URI',
+            },
+            'Forwarded for': {
+                fr: 'Transmis pour',
+                ru: 'Перенаправлен',
+                uk: 'Перенаправлений',
+                pt: 'Encaminhado para',
+                nl: 'Doorgestuurd voor',
+                de: 'Weitergeleitet für',
+            },
+            'Namespace': {
+                fr: 'Espace de noms',
+                ru: 'Пространство имён',
+                uk: 'Простір імен',
+                pt: 'Namespace',
+                nl: 'Elementnaam',
+                de: 'Namensraum',
+            },
+            'Ingress name': {
+                fr: 'Nom ingress',
+                ru: 'Имя Ingress',
+                uk: 'Ім\'я Ingress',
+                pt: 'Nome Ingress',
+                nl: 'Ingress naam',
+                de: 'Ingress Name',
+            },
+            'Service name': {
+                fr: 'Nom du service',
+                ru: 'Имя сервиса',
+                uk: 'Ім\'я сервісу',
+                pt: 'Nome do Serviço',
+                nl: 'Service naam',
+                de: 'Service Name',
+            },
+            'Service port': {
+                fr: 'Port du service',
+                ru: 'Порт сервиса',
+                uk: 'Порт сервісу',
+                pt: 'Porta do serviço',
+                nl: 'Service poort',
+                de: 'Service Port',
+            },
+            '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',
+            },
+            'Timestamp': {
+                fr: 'Horodatage',
+                ru: 'Временная метка',
+                uk: 'Тимчасова мітка',
+                pt: 'Timestamp',
+                nl: 'Tijdstempel',
+                de: 'Zeitstempel',
+            },
+
+            'client-side error': {
+                fr: 'Erreur Client',
+                ru: 'ошибка на стороне клиента',
+                uk: 'помилка на стороні клієнта',
+                pt: 'erro do lado do cliente',
+                nl: 'fout aan de gebruikerskant',
+                de: 'Clientseitiger Fehler',
+            },
+            'server-side error': {
+                fr: 'Erreur Serveur',
+                ru: 'ошибка на стороне сервера',
+                uk: 'помилка на стороні сервера',
+                pt: 'erro do lado do servidor',
+                nl: 'fout aan de serverkant',
+                de: 'Serverseitiger Fehler',
+            },
+
+            'Your Client': {
+                fr: 'Votre Client',
+                ru: 'Ваш Браузер',
+                uk: 'Ваш Браузер',
+                pt: 'Seu Cliente',
+                nl: 'Jouw Client',
+                de: 'Ihr Client',
+            },
+            'Network': {
+                fr: 'Réseau',
+                ru: 'Сеть',
+                uk: 'Сіть',
+                pt: 'Rede',
+                nl: 'Netwerk',
+                de: 'Netzwerk',
+            },
+            'Web Server': {
+                fr: 'Serveur Web',
+                ru: 'Web Сервер',
+                uk: 'Web Сервер',
+                pt: 'Servidor web',
+                nl: 'Web Server',
+                de: 'Webserver',
+            },
+            'What happened?': {
+                fr: 'Que s’est-il passé ?',
+                ru: 'Что произошло?',
+                uk: 'Що сталося?',
+                pt: 'O que aconteceu?',
+                nl: 'Wat is er gebeurd?',
+                de: 'Was ist passiert?',
+            },
+            '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?',
+            },
+            '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',
+            },
+            'Working': {
+                fr: 'Opérationnel',
+                ru: 'Работает',
+                uk: 'Працює',
+                pt: 'Funcionando',
+                nl: 'Functioneel',
+                de: 'Funktioniert',
+            },
+            'Unknown': {
+                fr: 'Inconnu',
+                ru: 'Неизвестно',
+                uk: 'Невідомо',
+                pt: 'Desconhecido',
+                nl: 'Onbekend',
+                de: 'Unbekannt',
+            },
+            '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',
+            },
+            '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',
+            },
+            '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',
+            },
+        };
+
+        /**
+         * @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();

l10n/readme.md

@@ -0,0 +1,19 @@
+# 🔤 Localization
+
+[![jsDelivr hits](https://img.shields.io/jsdelivr/gh/hm/tarampampam/error-pages)](https://www.jsdelivr.com/package/gh/tarampampam/error-pages)
+
+This directory contains file [l10n.js](l10n.js) for the error pages localization. The working logic is very simple - pages load this script using [jsdelivr.com](https://www.jsdelivr.com/) as a CDN for [versioned content from the GitHub repository](https://www.jsdelivr.com/features#gh), and it translates tag content with the special HTML attribute `data-l10n`.
+
+By default, pages markup contains strings in English (`en` locale). If you want to localize the error pages on the different locales, you should:
+
+- Find your locale name on [this page](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (column `639-1`)
+- Make a fork of this repository
+- Edit file [l10n.js](l10n.js) in `data` section (append new localized strings) using locale name from the step 1
+- Make a PR with your changes
+
+## 👍 Translators
+
+- 🇫🇷 French by [@jvin042](https://github.com/jvin042)
+- 🇵🇹 Portuguese by [@fabtrompet](https://github.com/fabtrompet)
+- 🇳🇱 Dutch by [@SchoNie](https://github.com/SchoNie)
+- 🇩🇪 German by [@mschoeffmann](https://github.com/mschoeffmann)

package.json

@@ -1,10 +0,0 @@
-{
-    "name": "error-pages",
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/tarampampam/error-pages-docker.git"
-    },
-    "dependencies": {
-        "yargs": "15.3"
-    }
-}

schemas/config/1.0.schema.json

@@ -0,0 +1,108 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Error-Pages config file schema",
+    "description": "Error-Pages config file schema.",
+    "type": "object",
+    "properties": {
+        "templates": {
+            "type": "array",
+            "description": "Templates list",
+            "items": {
+                "type": "object",
+                "description": "Template properties",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the template file",
+                        "examples": [
+                            "./templates/ghost.html",
+                            "/opt/tpl/ghost.htm"
+                        ]
+                    },
+                    "name": {
+                        "type": "string",
+                        "description": "Template name (optional, if path is defined)",
+                        "examples": [
+                            "ghost"
+                        ]
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Template content, if path is not defined",
+                        "examples": [
+                            "<html><body>{{ code }}: {{ message }}</body></html>"
+                        ]
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
+        "formats": {
+            "type": "object",
+            "description": "Responses, based on requested content-type format",
+            "properties": {
+                "json": {
+                    "type": "object",
+                    "description": "JSON format",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "JSON response body (template tags are allowed here)",
+                            "examples": [
+                                "{\"error\": true, \"code\": {{ code | json }}, \"message\": {{ message | json }}}"
+                            ]
+                        }
+                    },
+                    "additionalProperties": false
+                },
+                "xml": {
+                    "type": "object",
+                    "description": "XML format",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "XML response body (template tags are allowed here)",
+                            "examples": [
+                                "<?xml version=\"1.0\" encoding=\"utf-8\"?><error><code>{{ code }}</code><message>{{ message }}</message></error>"
+                            ]
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            },
+            "additionalProperties": false
+        },
+        "pages": {
+            "type": "object",
+            "description": "Error pages (codes)",
+            "patternProperties": {
+                "^[a-zA-Z0-9_-]+$": {
+                    "type": "object",
+                    "description": "Error page (code)",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "description": "Error page message (title)",
+                            "examples": [
+                                "Bad Request"
+                            ]
+                        },
+                        "description": {
+                            "type": "string",
+                            "description": "Error page description",
+                            "examples": [
+                                "The server did not understand the request"
+                            ]
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            },
+            "additionalProperties": false
+        }
+    },
+    "additionalProperties": false,
+    "required": [
+        "templates"
+    ]
+}

schemas/config/readme.md

@@ -0,0 +1,13 @@
+# Config file schemas
+
+These schemas describe Error Pages configuration file and used by:
+
+- <https://github.com/SchemaStore/schemastore>
+
+Schemas naming agreement: `<version_major>.<version_minor>.schema.json`.
+
+## Contributing guide
+
+If you want to modify the existing schema - your changes **MUST** be backward compatible. If your changes break backward compatibility - you **MUST** create a new schema file with a fresh version and "register" it in a [schemas catalog][schemas_catalog].
+
+[schemas_catalog]:https://github.com/SchemaStore/schemastore/blob/master/src/api/json/catalog.json