fix(tls): Pass certificate and private key files to listener method (#531)

Fixes #530

.dockerignore

@@ -4,4 +4,5 @@ Dockerfile
 .idea
 .git
 web/app
-*.db
+*.db
+testdata

.examples/docker-compose-multiple-config-files/config/backend.yaml

@@ -0,0 +1,21 @@
+endpoints:
+  - name: check-if-api-is-healthy
+    group: backend
+    url: "https://twin.sh/health"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 1000"
+
+  - name: check-if-website-is-pingable
+    url: "icmp://example.org"
+    interval: 1m
+    conditions:
+      - "[CONNECTED] == true"
+
+  - name: check-domain-expiration
+    url: "https://example.org"
+    interval: 6h
+    conditions:
+      - "[DOMAIN_EXPIRATION] > 720h"

.examples/docker-compose-multiple-config-files/config/frontend.yaml

@@ -0,0 +1,8 @@
+endpoints:
+  - name: make-sure-html-rendering-works
+    group: frontend
+    url: "https://example.org"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY] == pat(*<h1>Example Domain</h1>*)" # Check for header in HTML page

.examples/docker-compose-multiple-config-files/config/global.yaml

@@ -0,0 +1,8 @@
+metrics: true
+debug: false
+ui:
+  header: Example Company
+  link: https://example.org
+  buttons:
+    - name: "Home"
+      link: "https://example.org"

.examples/docker-compose-multiple-config-files/docker-compose.yml

@@ -0,0 +1,10 @@
+version: "3.8"
+services:
+  gatus:
+    image: twinproduction/gatus:latest
+    ports:
+      - "8080:8080"
+    environment:
+      - GATUS_CONFIG_PATH=/config
+    volumes:
+      - ./config:/config

.github/dependabot.yml

@@ -4,12 +4,10 @@ updates:
     directory: "/"
     labels: ["dependencies"]
     schedule:
-      interval: "weekly"
-      day: "wednesday"
+      interval: "daily"
   - package-ecosystem: "gomod"
     directory: "/"
     open-pull-requests-limit: 1
     labels: ["dependencies"]
     schedule:
-      interval: "weekly"
-      day: "wednesday"
+      interval: "daily"

.github/workflows/benchmark.yml

@@ -1,5 +1,9 @@
 name: benchmark
 on:
+  workflow_run:
+    workflows: [publish-latest]
+    branches: [master]
+    types: [completed]
   workflow_dispatch:
     inputs:
       repository:
@@ -16,11 +20,11 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v4
         with:
           go-version: 1.19
-          repository: "${{ github.event.inputs.repository }}"
-          ref: "${{ github.event.inputs.ref }}"
+          repository: "${{ github.event.inputs.repository || 'TwiN/gatus' }}"
+          ref: "${{ github.event.inputs.ref || 'master' }}"
       - uses: actions/checkout@v3
       - name: Benchmark
         run: go test -bench=. ./storage/store

.github/workflows/publish-experimental.yml

@@ -18,7 +18,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Build and push Docker image
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v4
         with:
           platforms: linux/amd64
           pull: true

.github/workflows/publish-latest-to-ghcr.yml

@@ -30,7 +30,7 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push Docker image
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v4
         with:
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true

.github/workflows/publish-latest.yml

@@ -26,7 +26,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Build and push Docker image
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v4
         with:
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true

.github/workflows/publish-release-to-ghcr.yml

@@ -26,7 +26,7 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push Docker image
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v4
         with:
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true

.github/workflows/publish-release.yml

@@ -23,7 +23,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Build and push Docker image
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v4
         with:
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true

.github/workflows/test.yml

@@ -3,18 +3,20 @@ on:
   pull_request:
     paths-ignore:
       - '*.md'
+      - '.examples/**'
   push:
     branches:
       - master
     paths-ignore:
       - '*.md'
-      - '.github/*'
+      - '.github/**'
+      - '.examples/**'
 jobs:
   test:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v4
         with:
           go-version: 1.19
       - uses: actions/checkout@v3
@@ -26,6 +28,6 @@ jobs:
         # was configured by the "Set up Go" step (otherwise, it'd use sudo's "go" executable)
         run: sudo env "PATH=$PATH" "GOROOT=$GOROOT" go test ./... -race -coverprofile=coverage.txt -covermode=atomic
       - name: Codecov
-        uses: codecov/codecov-action@v3.1.1
+        uses: codecov/codecov-action@v3.1.4
         with:
           files: ./coverage.txt

.gitignore

@@ -1,6 +1,18 @@
+# IDE
+*.iml
 .idea
 .vscode
+
+# OS
 .DS_Store
+
+# JS
+node_modules
+
+# Go
+/vendor
+
+# Misc
 *.db
 *.db-shm
 *.db-wal

Makefile

@@ -7,7 +7,7 @@ install:
 	go build -mod vendor -o $(BINARY) .
 
 run:
-	GATUS_CONFIG_FILE=./config.yaml ./$(BINARY)
+	GATUS_CONFIG_PATH=./config.yaml ./$(BINARY)
 
 clean:
 	rm $(BINARY)

README.md

@@ -1,4 +1,4 @@
-![Gatus](.github/assets/logo-with-dark-text.png)
+[![Gatus](.github/assets/logo-with-dark-text.png)](https://gatus.io)
 
 ![test](https://github.com/TwiN/gatus/workflows/test/badge.svg?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/github.com/TwiN/gatus?)](https://goreportcard.com/report/github.com/TwiN/gatus)
@@ -10,26 +10,32 @@
 Gatus is a developer-oriented health dashboard that gives you the ability to monitor your services using HTTP, ICMP, TCP, and even DNS
 queries as well as evaluate the result of said queries by using a list of conditions on values like the status code,
 the response time, the certificate expiration, the body and many others. The icing on top is that each of these health
-checks can be paired with alerting via Slack, PagerDuty, Discord, Twilio and more.
+checks can be paired with alerting via Slack, Teams, PagerDuty, Discord, Twilio and many more.
 
 I personally deploy it in my Kubernetes cluster and let it monitor the status of my
 core applications: https://status.twin.sh/
 
+_Looking for a managed solution? Check out [Gatus.io](https://gatus.io)._
+
 <details>
   <summary><b>Quick start</b></summary>
 
 ```console
 docker run -p 8080:8080 --name gatus twinproduction/gatus
 ```
+You can also use GitHub Container Registry if you prefer:
+```console
+docker run -p 8080:8080 --name gatus ghcr.io/twin/gatus
+```
 For more details, see [Usage](#usage)
 </details>
 
+> ❤ Like this project? Please consider [sponsoring me](https://github.com/sponsors/TwiN).
+
 ![Gatus dashboard](.github/assets/dashboard-dark.png)
 
 Have any feedback or questions? [Create a discussion](https://github.com/TwiN/gatus/discussions/new).
 
-Like this project? Please consider [sponsoring me](https://github.com/sponsors/TwiN).
-
 
 ## Table of Contents
 - [Why Gatus?](#why-gatus)
@@ -45,6 +51,7 @@ Like this project? Please consider [sponsoring me](https://github.com/sponsors/T
     - [Configuring Discord alerts](#configuring-discord-alerts)
     - [Configuring Email alerts](#configuring-email-alerts)
     - [Configuring GitHub alerts](#configuring-github-alerts)
+    - [Configuring GitLab alerts](#configuring-gitlab-alerts)
     - [Configuring Google Chat alerts](#configuring-google-chat-alerts)
     - [Configuring Matrix alerts](#configuring-matrix-alerts)
     - [Configuring Mattermost alerts](#configuring-mattermost-alerts)
@@ -52,6 +59,7 @@ Like this project? Please consider [sponsoring me](https://github.com/sponsors/T
     - [Configuring Ntfy alerts](#configuring-ntfy-alerts)
     - [Configuring Opsgenie alerts](#configuring-opsgenie-alerts)
     - [Configuring PagerDuty alerts](#configuring-pagerduty-alerts)
+    - [Configuring Pushover alerts](#configuring-pushover-alerts)
     - [Configuring Slack alerts](#configuring-slack-alerts)
     - [Configuring Teams alerts](#configuring-teams-alerts)
     - [Configuring Telegram alerts](#configuring-telegram-alerts)
@@ -60,9 +68,11 @@ Like this project? Please consider [sponsoring me](https://github.com/sponsors/T
     - [Setting a default alert](#setting-a-default-alert)
   - [Maintenance](#maintenance)
   - [Security](#security)
-    - [Basic](#basic)
+    - [Basic Authentication](#basic-authentication)
     - [OIDC](#oidc)
+  - [TLS Encryption](#tls-encryption)
   - [Metrics](#metrics)
+  - [Connectivity](#connectivity)
   - [Remote instances (EXPERIMENTAL)](#remote-instances-experimental)
 - [Deployment](#deployment)
   - [Docker](#docker)
@@ -85,6 +95,7 @@ Like this project? Please consider [sponsoring me](https://github.com/sponsors/T
   - [disable-monitoring-lock](#disable-monitoring-lock)
   - [Reloading configuration on the fly](#reloading-configuration-on-the-fly)
   - [Endpoint groups](#endpoint-groups)
+  - [Exposing Gatus on a custom path](#exposing-gatus-on-a-custom-path)
   - [Exposing Gatus on a custom port](#exposing-gatus-on-a-custom-port)
   - [Keeping your configuration small](#keeping-your-configuration-small)
   - [Badges](#badges)
@@ -129,9 +140,19 @@ The main features of Gatus are:
 
 
 ## Usage
-By default, the configuration file is expected to be at `config/config.yaml`.
 
-You can specify a custom path by setting the `GATUS_CONFIG_FILE` environment variable.
+<details>
+  <summary><b>Quick start</b></summary>
+
+```console
+docker run -p 8080:8080 --name gatus twinproduction/gatus
+```
+You can also use GitHub Container Registry if you prefer:
+```console
+docker run -p 8080:8080 --name gatus ghcr.io/twin/gatus
+```
+If you want to create your own configuration, see [Docker](#docker) for information on how to mount a configuration file.
+</details>
 
 Here's a simple example:
 ```yaml
@@ -156,7 +177,18 @@ This example would look similar to this:
 
 ![Simple example](.github/assets/example.png)
 
-Note that you can also use environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)
+By default, the configuration file is expected to be at `config/config.yaml`.
+
+You can specify a custom path by setting the `GATUS_CONFIG_PATH` environment variable.
+
+If `GATUS_CONFIG_PATH` points to a directory, all `*.yaml` and `*.yml` files inside said directory and its
+subdirectories are merged like so:
+- All maps/objects are deep merged (i.e. you could define `alerting.slack` in one file and `alerting.pagerduty` in another file)
+- All slices/arrays are appended (i.e. you can define `endpoints` in multiple files and each endpoint will be added to the final list of endpoints)
+- Parameters with a primitive value (e.g. `debug`, `metrics`, `alerting.slack.webhook-url`, etc.) may only be defined once to forcefully avoid any ambiguity
+    - To clarify, this also means that you could not define `alerting.slack.webhook-url` in two files with different values. All files are merged into one before they are processed. This is by design.
+
+> 💡 You can also use environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)
 
 If you want to test it locally, see [Docker](#docker).
 
@@ -200,6 +232,8 @@ If you want to test it locally, see [Docker](#docker).
 | `web`                                           | Web configuration.                                                                                                                          | `{}`                       |
 | `web.address`                                   | Address to listen on.                                                                                                                       | `0.0.0.0`                  |
 | `web.port`                                      | Port to listen on.                                                                                                                          | `8080`                     |
+| `web.tls.certificate-file`                      | Optional public certificate file for TLS in PEM format.                                                                                     | ``                         |
+| `web.tls.private-key-file`                      | Optional private key file for TLS in PEM format.                                                                                            | ``                         |
 | `ui`                                            | UI configuration.                                                                                                                           | `{}`                       |
 | `ui.title`                                      | [Title of the document](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title).                                                   | `Health Dashboard ǀ Gatus` |
 | `ui.description`                                | Meta description for the page.                                                                                                              | `Gatus is an advanced...`. |
@@ -211,6 +245,7 @@ If you want to test it locally, see [Docker](#docker).
 | `ui.buttons[].link`                             | Link to open when the button is clicked.                                                                                                    | Required `""`              |
 | `maintenance`                                   | [Maintenance configuration](#maintenance).                                                                                                  | `{}`                       |
 
+
 ### Conditions
 Here are some examples of conditions you can use:
 
@@ -259,7 +294,7 @@ Here are some examples of conditions you can use:
 | `pat`    | Specifies that the string passed as parameter should be evaluated as a pattern. Works only with `==` and `!=`.                                                                                                                      | `[IP] == pat(192.168.*)`           |
 | `any`    | Specifies that any one of the values passed as parameters is a valid value. Works only with `==` and `!=`.                                                                                                                          | `[BODY].ip == any(127.0.0.1, ::1)` |
 
-**NOTE**: Use `pat` only when you need to. `[STATUS] == pat(2*)` is a lot more expensive than `[STATUS] < 300`.
+> 💡 Use `pat` only when you need to. `[STATUS] == pat(2*)` is a lot more expensive than `[STATUS] < 300`.
 
 
 ### Storage
@@ -270,6 +305,9 @@ Here are some examples of conditions you can use:
 | `storage.type`    | Type of storage. Valid types: `memory`, `sqlite`, `postgres`.                                                                                      | `"memory"` |
 | `storage.caching` | Whether to use write-through caching. Improves loading time for large dashboards. <br />Only supported if `storage.type` is `sqlite` or `postgres` | `false`    |
 
+The results for each endpoint health check as well as the data for uptime and the past events must be persisted
+so that they can be displayed on the dashboard. These parameters allow you to configure the storage in question.
+
 - If `storage.type` is `memory` (default):
 ```yaml
 # Note that this is the default value, and you can omit the storage configuration altogether to achieve the same result.
@@ -310,7 +348,7 @@ the client used to send the request.
 | `client.oauth2.client-secret` | The client secret which should be used for the `Client credentials flow`   | required `""`   |
 | `client.oauth2.scopes[]`      | A list of `scopes` which should be used for the `Client credentials flow`. | required `[""]` |
 
-Note that some of these parameters are ignored based on the type of endpoint. For instance, there's no certificate involved
+> 📝 Some of these parameters are ignored based on the type of endpoint. For instance, there's no certificate involved
 in ICMP requests (ping), therefore, setting `client.insecure` to `true` for an endpoint of that type will not do anything.
 
 This default configuration is as follows:
@@ -366,7 +404,7 @@ endpoints:
 Gatus supports multiple alerting providers, such as Slack and PagerDuty, and supports different alerts for each
 individual endpoints with configurable descriptions and thresholds.
 
-Note that if an alerting provider is not properly configured, all alerts configured with the provider's type will be
+> 📝 If an alerting provider is not properly configured, all alerts configured with the provider's type will be
 ignored.
 
 | Parameter              | Description                                                                                                                  | Default |
@@ -375,6 +413,7 @@ ignored.
 | `alerting.discord`     | Configuration for alerts of type `discord`. <br />See [Configuring Discord alerts](#configuring-discord-alerts).             | `{}`    |
 | `alerting.email`       | Configuration for alerts of type `email`. <br />See [Configuring Email alerts](#configuring-email-alerts).                   | `{}`    |
 | `alerting.github`      | Configuration for alerts of type `github`. <br />See [Configuring GitHub alerts](#configuring-github-alerts).                | `{}`    |
+| `alerting.gitlab`      | Configuration for alerts of type `gitlab`. <br />See [Configuring GitLab alerts](#configuring-gitlab-alerts).                | `{}`    |
 | `alerting.googlechat`  | Configuration for alerts of type `googlechat`. <br />See [Configuring Google Chat alerts](#configuring-google-chat-alerts).  | `{}`    |
 | `alerting.matrix`      | Configuration for alerts of type `matrix`. <br />See [Configuring Matrix alerts](#configuring-matrix-alerts).                | `{}`    |
 | `alerting.mattermost`  | Configuration for alerts of type `mattermost`. <br />See [Configuring Mattermost alerts](#configuring-mattermost-alerts).    | `{}`    |
@@ -382,6 +421,7 @@ ignored.
 | `alerting.ntfy`        | Configuration for alerts of type `ntfy`. <br />See [Configuring Ntfy alerts](#configuring-ntfy-alerts).                      | `{}`    |
 | `alerting.opsgenie`    | Configuration for alerts of type `opsgenie`. <br />See [Configuring Opsgenie alerts](#configuring-opsgenie-alerts).          | `{}`    |
 | `alerting.pagerduty`   | Configuration for alerts of type `pagerduty`. <br />See [Configuring PagerDuty alerts](#configuring-pagerduty-alerts).       | `{}`    |
+| `alerting.pushover`    | Configuration for alerts of type `pushover`. <br />See [Configuring Pushover alerts](#configuring-pushover-alerts).          | `{}`    |
 | `alerting.slack`       | Configuration for alerts of type `slack`. <br />See [Configuring Slack alerts](#configuring-slack-alerts).                   | `{}`    |
 | `alerting.teams`       | Configuration for alerts of type `teams`. <br />See [Configuring Teams alerts](#configuring-teams-alerts).                   | `{}`    |
 | `alerting.telegram`    | Configuration for alerts of type `telegram`. <br />See [Configuring Telegram alerts](#configuring-telegram-alerts).          | `{}`    |
@@ -474,7 +514,7 @@ endpoints:
         send-on-resolved: true
 ```
 
-**NOTE:** Some mail servers are painfully slow.
+> ⚠ Some mail servers are painfully slow.
 
 
 #### Configuring GitHub alerts
@@ -513,6 +553,47 @@ endpoints:
 
 ![GitHub alert](.github/assets/github-alerts.png)
 
+#### Configuring GitLab alerts
+| Parameter                           | Description                                                                                                | Default       |
+|:------------------------------------|:----------------------------------------------------------------------------------------------------------------|:--------------|
+| `alerting.gitlab`                   | Configuration for alerts of type `gitlab`                                                                       | `{}`          |
+| `alerting.gitlab.webhook-url`       | GitLab alert webhook URL (e.g. `https://gitlab.com/hlidotbe/example/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json`) | Required `""` |
+| `alerting.gitlab.authorization-key` | Personal access token to use for authentication. <br />Must have at least RW on issues and RO on metadata.      | Required `""` |
+| `alerting.gitlab.severity`          | Override default severity (critical), can be one of `critical, high, medium, low, info, unknown`                | `""`          |
+| `alerting.gitlab.monitoring-tool`   | Override the monitoring tool name (gatus)                                                                       | `"gatus"`     |
+| `alerting.gitlab.environment-name`  | Set gitlab environment's name. Required to display alerts on a dashboard.                                       | `""`          |
+| `alerting.gitlab.service`           | Override endpoint displayname                                                                                   | `""` |
+| `alerting.gitlab.default-alert`     | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert).                     | N/A           |
+
+The GitLab alerting provider creates an alert prefixed with `alert(gatus):` and suffixed with the endpoint's display
+name for each alert. If `send-on-resolved` is set to `true` on the endpoint alert, the alert will be automatically
+closed when the alert is resolved. See
+https://docs.gitlab.com/ee/operations/incident_management/integrations.html#configuration to configure the endpoint.
+
+```yaml
+alerting:
+  gitlab:
+    webhook-url: "https://gitlab.com/hlidotbe/example/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json"
+    authorization-key: "12345"
+
+endpoints:
+  - name: example
+    url: "https://twin.sh/health"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 75"
+    alerts:
+      - type: gitlab
+        failure-threshold: 2
+        success-threshold: 3
+        send-on-resolved: true
+        description: "Everything's burning AAAAAHHHHHHHHHHHHHHH"
+```
+
+![GitLab alert](.github/assets/gitlab-alerts.png)
+
 
 #### Configuring Google Chat alerts
 | Parameter                                     | Description                                                                                 | Default       |
@@ -652,6 +733,7 @@ endpoints:
 | `alerting.ntfy`               | Configuration for alerts of type `ntfy`                                                    | `{}`              |
 | `alerting.ntfy.topic`         | Topic at which the alert will be sent                                                      | Required `""`     |
 | `alerting.ntfy.url`           | The URL of the target server                                                               | `https://ntfy.sh` |
+| `alerting.ntfy.token`         | [Access token](https://docs.ntfy.sh/publish/#access-tokens) for restricted topics          | `""`              |
 | `alerting.ntfy.priority`      | The priority of the alert                                                                  | `3`               |
 | `alerting.ntfy.default-alert` | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert) | N/A               |
 
@@ -664,6 +746,7 @@ alerting:
   ntfy:
     topic: "gatus-test-topic"
     priority: 2
+    token: faketoken
     default-alert:
       failure-threshold: 3
       send-on-resolved: true
@@ -762,6 +845,39 @@ endpoints:
 ```
 
 
+#### Configuring Pushover alerts
+| Parameter                              | Description                                                                                     | Default                      |
+|:---------------------------------------|:------------------------------------------------------------------------------------------------|:-----------------------------|
+| `alerting.pushover`                    | Configuration for alerts of type `pushover`                                                     | `{}`                         |
+| `alerting.pushover.application-token`  | Pushover application token                                                                      | `""`                         |
+| `alerting.pushover.user-key`           | User or group key                                                                               | `""`                         |
+| `alerting.pushover.title`              | Fixed title for all messages sent via Pushover                                                  | Name of your App in Pushover |
+| `alerting.pushover.priority`           | Priority of all messages, ranging from -2 (very low) to 2 (emergency)                           | `0`                          |
+| `alerting.pushover.sound`              | Sound of all messages<br />See [sounds](https://pushover.net/api#sounds) for all valid choices. | `""`                         |
+| `alerting.pushover.default-alert`      | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert)      | N/A                          |
+
+```yaml
+alerting:
+  pushover:
+    application-token: "******************************"
+    user-key: "******************************"
+
+endpoints:
+  - name: website
+    url: "https://twin.sh/health"
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: pushover
+        failure-threshold: 3
+        success-threshold: 5
+        send-on-resolved: true
+        description: "healthcheck failed"
+```
+
 #### Configuring Slack alerts
 | Parameter                                 | Description                                                                                | Default       |
 |:------------------------------------------|:-------------------------------------------------------------------------------------------|:--------------|
@@ -771,6 +887,7 @@ endpoints:
 | `alerting.slack.overrides`                | List of overrides that may be prioritized over the default configuration                   | `[]`          |
 | `alerting.slack.overrides[].group`        | Endpoint group for which the configuration will be overridden by this configuration        | `""`          |
 | `alerting.slack.overrides[].webhook-url`  | Slack Webhook URL                                                                          | `""`          |
+
 ```yaml
 alerting:
   slack:
@@ -800,7 +917,6 @@ Here's an example of what the notifications look like:
 
 
 #### Configuring Teams alerts
-
 | Parameter                                | Description                                                                                | Default       |
 |:-----------------------------------------|:-------------------------------------------------------------------------------------------|:--------------|
 | `alerting.teams`                         | Configuration for alerts of type `teams`                                                   | `{}`          |
@@ -987,13 +1103,13 @@ As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of
 
 
 #### Setting a default alert
-| Parameter                                     | Description                                                                   | Default |
-|:----------------------------------------------|:------------------------------------------------------------------------------|:--------|
-| `alerting.*.default-alert.enabled`            | Whether to enable the alert                                                   | N/A     |
-| `alerting.*.default-alert.failure-threshold`  | Number of failures in a row needed before triggering the alert                | N/A     |
-| `alerting.*.default-alert.success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | N/A     |
-| `alerting.*.default-alert.send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | N/A     |
-| `alerting.*.default-alert.description`        | Description of the alert. Will be included in the alert sent                  | N/A     |
+| Parameter                                    | Description                                                                   | Default |
+|:---------------------------------------------|:------------------------------------------------------------------------------|:--------|
+| `alerting.*.default-alert.enabled`           | Whether to enable the alert                                                   | N/A     |
+| `alerting.*.default-alert.failure-threshold` | Number of failures in a row needed before triggering the alert                | N/A     |
+| `alerting.*.default-alert.success-threshold` | Number of successes in a row before an ongoing incident is marked as resolved | N/A     |
+| `alerting.*.default-alert.send-on-resolved`  | Whether to send a notification once a triggered alert is marked as resolved   | N/A     |
+| `alerting.*.default-alert.description`       | Description of the alert. Will be included in the alert sent                  | N/A     |
 
 > ⚠ You must still specify the `type` of the alert in the endpoint configuration even if you set the default alert of a provider.
 
@@ -1088,7 +1204,7 @@ To do that, you'll have to use the maintenance configuration:
 | `maintenance.duration` | Duration of the maintenance window (e.g. `1h`, `30m`)                                                                                  | Required `""` |
 | `maintenance.every`    | Days on which the maintenance period applies (e.g. `[Monday, Thursday]`).<br />If left empty, the maintenance window applies every day | `[]`          |
 
-**Note that the maintenance configuration uses UTC.**
+> 📝 The maintenance configuration uses UTC
 
 Here's an example:
 ```yaml
@@ -1109,14 +1225,14 @@ maintenance:
 
 
 ### Security
-| Parameter                        | Description                  | Default       |
-|:---------------------------------|:-----------------------------|:--------------|
-| `security`                       | Security configuration       | `{}`          |
-| `security.basic`                 | HTTP Basic configuration     | `{}`          |
-| `security.oidc`                  | OpenID Connect configuration | `{}`          |
+| Parameter        | Description                  | Default |
+|:-----------------|:-----------------------------|:--------|
+| `security`       | Security configuration       | `{}`    |
+| `security.basic` | HTTP Basic configuration     | `{}`    |
+| `security.oidc`  | OpenID Connect configuration | `{}`    |
 
 
-#### Basic
+#### Basic Authentication
 | Parameter                               | Description                                                                        | Default       |
 |:----------------------------------------|:-----------------------------------------------------------------------------------|:--------------|
 | `security.basic`                        | HTTP Basic configuration                                                           | `{}`          |
@@ -1131,8 +1247,8 @@ security:
     password-bcrypt-base64: "JDJhJDEwJHRiMnRFakxWazZLdXBzRERQazB1TE8vckRLY05Yb1hSdnoxWU0yQ1FaYXZRSW1McmladDYu"
 ```
 
-**WARNING:** Make sure to carefully select to cost of the bcrypt hash. The higher the cost, the longer it takes to compute the hash,
-and basic auth verifies the password against the hash on every request. As of 2022-01-08, I suggest a cost of 8.
+> ⚠ Make sure to carefully select to cost of the bcrypt hash. The higher the cost, the longer it takes to compute the hash,
+and basic auth verifies the password against the hash on every request. As of 2023-01-06, I suggest a cost of 9.
 
 
 #### OIDC
@@ -1160,6 +1276,17 @@ security:
 
 Confused? Read [Securing Gatus with OIDC using Auth0](https://twin.sh/articles/56/securing-gatus-with-oidc-using-auth0).
 
+### TLS Encryption
+Gatus supports basic encryption with TLS. To enable this, certificate files in PEM format have to be provided.
+
+The example below shows an example configuration which makes gatus respond on port 4443 to HTTPS requests:
+```yaml
+web:
+  port: 4443
+  tls:
+    certificate-file: "certificate.crt"
+    private-key-file: "private.key"
+```
 
 ### Metrics
 To enable metrics, you must set `metrics` to `true`. Doing so will expose Prometheus-friendly metrics at the `/metrics`
@@ -1176,6 +1303,28 @@ endpoint on the same port your application is configured to run on (`web.port`).
 See [examples/docker-compose-grafana-prometheus](.examples/docker-compose-grafana-prometheus) for further documentation as well as an example.
 
 
+### Connectivity
+| Parameter                       | Description                                | Default       |
+|:--------------------------------|:-------------------------------------------|:--------------|
+| `connectivity`                  | Connectivity configuration                 | `{}`          |
+| `connectivity.checker`          | Connectivity checker configuration         | Required `{}` |
+| `connectivity.checker.target`   | Host to use for validating connectivity    | Required `""` |
+| `connectivity.checker.interval` | Interval at which to validate connectivity | `1m`          |
+
+While Gatus is used to monitor other services, it is possible for Gatus itself to lose connectivity to the internet.
+In order to prevent Gatus from reporting endpoints as unhealthy when Gatus itself is unhealthy, you may configure 
+Gatus to periodically check for internet connectivity.
+
+All endpoint executions are skipped while the connectivity checker deems connectivity to be down.
+
+```yaml
+connectivity:
+  checker:
+    target: 1.1.1.1:53
+    interval: 60s
+```
+
+
 ### Remote instances (EXPERIMENTAL)
 This feature allows you to retrieve endpoint statuses from a remote Gatus instance.
 
@@ -1187,12 +1336,12 @@ This is an experimental feature. It may be removed or updated in a breaking mann
 there are known issues with this feature. If you'd like to provide some feedback, please write a comment in [#64](https://github.com/TwiN/gatus/issues/64).
 Use at your own risk.
 
-| Parameter                          | Description                                  | Default        |
-|:-----------------------------------|:---------------------------------------------|:---------------|
-| `remote`                           | Remote configuration                         | `{}`           |
-| `remote.instances`                 | List of remote instances                     | Required `[]`  |
-| `remote.instances.endpoint-prefix` | String to prefix all endpoint names with     | `""`           |
-| `remote.instances.url`             | URL from which to retrieve endpoint statuses | Required `""`  |
+| Parameter                          | Description                                  | Default       |
+|:-----------------------------------|:---------------------------------------------|:--------------|
+| `remote`                           | Remote configuration                         | `{}`          |
+| `remote.instances`                 | List of remote instances                     | Required `[]` |
+| `remote.instances.endpoint-prefix` | String to prefix all endpoint names with     | `""`          |
+| `remote.instances.url`             | URL from which to retrieve endpoint statuses | Required `""` |
 
 ```yaml
 remote:
@@ -1237,11 +1386,11 @@ Please refer to Helm's [documentation](https://helm.sh/docs/) to get started.
 Once Helm is set up properly, add the repository as follows:
 
 ```console
-helm repo add gatus https://avakarev.github.io/gatus-chart
+helm repo add minicloudlabs https://minicloudlabs.github.io/helm-charts
 ```
 
-To get more details, please check chart's [configuration](https://github.com/avakarev/gatus-chart#configuration)
-and [helmfile example](https://github.com/avakarev/gatus-chart#helmfileyaml-example)
+To get more details, please check [chart's configuration](https://github.com/minicloudlabs/helm-charts/tree/main/charts/gatus#configuration)
+and [helmfile example](https://github.com/minicloudlabs/helm-charts/tree/main/charts/gatus#helmfileyaml-example)
 
 
 ### Terraform
@@ -1290,7 +1439,7 @@ will send a `POST` request to `http://localhost:8080/playground` with the follow
 
 
 ### Recommended interval
-> **NOTE**: This does not apply if `disable-monitoring-lock` is set to `true`, as the monitoring lock is what
+> 📝 This does not apply if `disable-monitoring-lock` is set to `true`, as the monitoring lock is what
 > tells Gatus to only evaluate one endpoint at a time.
 
 To ensure that Gatus provides reliable and accurate results (i.e. response time), Gatus only evaluates one endpoint at a time
@@ -1320,11 +1469,11 @@ simple health checks used for alerting (PagerDuty/Twilio) to `30s`.
 
 
 ### Default timeouts
-| Endpoint type  | Timeout |
-|:---------------|:--------|
-| HTTP           | 10s     |
-| TCP            | 10s     |
-| ICMP           | 10s     |
+| Endpoint type | Timeout |
+|:--------------|:--------|
+| HTTP          | 10s     |
+| TCP           | 10s     |
+| ICMP          | 10s     |
 
 To modify the timeout, see [Client configuration](#client-configuration).
 
@@ -1346,7 +1495,7 @@ Placeholders `[STATUS]` and `[BODY]` as well as the fields `endpoints[].body`, `
 
 This works for applications such as databases (Postgres, MySQL, etc.) and caches (Redis, Memcached, etc.).
 
-**NOTE**: `[CONNECTED] == true` does not guarantee that the endpoint itself is healthy - it only guarantees that there's
+> 📝 `[CONNECTED] == true` does not guarantee that the endpoint itself is healthy - it only guarantees that there's
 something at the given address listening to the given port, and that a connection to that address was successfully
 established.
 
@@ -1397,6 +1546,8 @@ endpoints:
 Only the placeholders `[CONNECTED]`, `[IP]` and `[RESPONSE_TIME]` are supported for endpoints of type ICMP.
 You can specify a domain prefixed by `icmp://`, or an IP address prefixed by `icmp://`.
 
+If you run Gatus on Linux, please read the Linux section on https://github.com/prometheus-community/pro-bing#linux
+if you encounter any problems.
 
 ### Monitoring an endpoint using DNS queries
 Defining a `dns` configuration in an endpoint will automatically mark said endpoint as an endpoint of type DNS:
@@ -1462,7 +1613,7 @@ endpoints:
       - "[CERTIFICATE_EXPIRATION] > 240h"
 ```
 
-**NOTE**: The usage of the `[DOMAIN_EXPIRATION]` placeholder requires Gatus to send a request to the official IANA WHOIS service [through a library](https://github.com/TwiN/whois)
+> ⚠ The usage of the `[DOMAIN_EXPIRATION]` placeholder requires Gatus to send a request to the official IANA WHOIS service [through a library](https://github.com/TwiN/whois)
 and in some cases, a secondary request to a TLD-specific WHOIS server (e.g. `whois.nic.sh`). 
 To prevent the WHOIS service from throttling your IP address if you send too many requests, Gatus will prevent you from
 using the `[DOMAIN_EXPIRATION]` placeholder on an endpoint with an interval of less than `5m`.
@@ -1503,7 +1654,7 @@ to make.
 **If you are not using a file storage**, updating the configuration while Gatus is running is effectively
 the same as restarting the application.
 
-**NOTE:** Updates may not be detected if the config file is bound instead of the config folder. See [#151](https://github.com/TwiN/gatus/issues/151).
+> 📝 Updates may not be detected if the config file is bound instead of the config folder. See [#151](https://github.com/TwiN/gatus/issues/151).
 
 
 ### Endpoint groups
@@ -1551,6 +1702,12 @@ The configuration above will result in a dashboard that looks like this:
 ![Gatus Endpoint Groups](.github/assets/endpoint-groups.png)
 
 
+### Exposing Gatus on a custom path
+Currently, you can expose the Gatus UI using a fully qualified domain name (FQDN) such as `status.example.org`. However, it does not support path-based routing, which means you cannot expose it through a URL like `example.org/status/`.
+
+For more information, see https://github.com/TwiN/gatus/issues/88.
+
+
 ### Exposing Gatus on a custom port
 By default, Gatus is exposed on port `8080`, but you may specify a different port by setting the `web.port` parameter:
 ```yaml
@@ -1716,5 +1873,8 @@ No such header is required to query the API.
 ## Sponsors
 You can find the full list of sponsors [here](https://github.com/sponsors/TwiN).
 
-[<img src="https://github.com/math280h.png" width="50" />](https://github.com/math280h)
-[<img src="https://github.com/pyroscope-io.png" width="50" />](https://github.com/pyroscope-io)
+<!-- _There is currently no sponsors_ -->
+
+[<img src="https://github.com/8ball030.png" width="50" />](https://github.com/8ball030)
+
+<!-- [<img src="https://github.com/$user.png" width="50" />](https://github.com/$user) -->

alerting/alert/type.go

@@ -17,6 +17,9 @@ const (
 	// TypeGitHub is the Type for the github alerting provider
 	TypeGitHub Type = "github"
 
+	// TypeGitLab is the Type for the gitlab alerting provider
+	TypeGitLab Type = "gitlab"
+
 	// TypeGoogleChat is the Type for the googlechat alerting provider
 	TypeGoogleChat Type = "googlechat"
 
@@ -38,6 +41,9 @@ const (
 	// TypePagerDuty is the Type for the pagerduty alerting provider
 	TypePagerDuty Type = "pagerduty"
 
+	// TypePushover is the Type for the pushover alerting provider
+	TypePushover Type = "pushover"
+
 	// TypeSlack is the Type for the slack alerting provider
 	TypeSlack Type = "slack"
 

alerting/config.go

@@ -11,6 +11,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/discord"
 	"github.com/TwiN/gatus/v5/alerting/provider/email"
 	"github.com/TwiN/gatus/v5/alerting/provider/github"
+	"github.com/TwiN/gatus/v5/alerting/provider/gitlab"
 	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
 	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
@@ -18,6 +19,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
 	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
 	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
 	"github.com/TwiN/gatus/v5/alerting/provider/slack"
 	"github.com/TwiN/gatus/v5/alerting/provider/teams"
 	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
@@ -38,6 +40,9 @@ type Config struct {
 	// GitHub is the configuration for the github alerting provider
 	GitHub *github.AlertProvider `yaml:"github,omitempty"`
 
+	// GitLab is the configuration for the gitlab alerting provider
+	GitLab *gitlab.AlertProvider `yaml:"gitlab,omitempty"`
+
 	// GoogleChat is the configuration for the googlechat alerting provider
 	GoogleChat *googlechat.AlertProvider `yaml:"googlechat,omitempty"`
 
@@ -59,6 +64,9 @@ type Config struct {
 	// PagerDuty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty,omitempty"`
 
+	// Pushover is the configuration for the pushover alerting provider
+	Pushover *pushover.AlertProvider `yaml:"pushover,omitempty"`
+
 	// Slack is the configuration for the slack alerting provider
 	Slack *slack.AlertProvider `yaml:"slack,omitempty"`
 

alerting/provider/email/email.go

@@ -67,12 +67,11 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 
 // buildMessageSubjectAndBody builds the message subject and body
 func (provider *AlertProvider) buildMessageSubjectAndBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) (string, string) {
-	var subject, message, results string
+	var message, results string
+	subject := fmt.Sprintf("[%s] Alert triggered", endpoint.DisplayName())
 	if resolved {
-		subject = fmt.Sprintf("[%s] Alert resolved", endpoint.DisplayName())
 		message = fmt.Sprintf("An alert for %s has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 	} else {
-		subject = fmt.Sprintf("[%s] Alert triggered", endpoint.DisplayName())
 		message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 	}
 	for _, conditionResult := range result.ConditionResults {

alerting/provider/email/email_test.go

@@ -83,7 +83,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			Provider:        AlertProvider{},
 			Alert:           alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:        true,
-			ExpectedSubject: "[endpoint-name] Alert resolved",
+			ExpectedSubject: "[endpoint-name] Alert triggered",
 			ExpectedBody:    "An alert for endpoint-name has been resolved after passing successfully 5 time(s) in a row\n\nAlert description: description-2\n\nCondition results:\n✅ [CONNECTED] == true\n✅ [STATUS] == 200\n",
 		},
 	}

alerting/provider/gitlab/gitlab.go

@@ -0,0 +1,147 @@
+package gitlab
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/google/uuid"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using GitLab
+type AlertProvider struct {
+	WebhookURL       string `yaml:"webhook-url"`       // The webhook url provided by GitLab
+	AuthorizationKey string `yaml:"authorization-key"` // The authorization key provided by GitLab
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Severity can be one of: critical, high, medium, low, info, unknown. Defaults to critical
+	Severity string `yaml:"severity,omitempty"`
+	// MonitoringTool overrides the name sent to gitlab. Defaults to gatus
+	MonitoringTool string `yaml:"monitoring-tool,omitempty"`
+	// EnvironmentName is the name of the associated GitLab environment. Required to display alerts on a dashboard.
+	EnvironmentName string `yaml:"environment-name,omitempty"`
+	// Service affected. Defaults to endpoint display name
+	Service string `yaml:"service,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if len(provider.AuthorizationKey) == 0 || len(provider.WebhookURL) == 0 {
+		return false
+	}
+	// Validate format of the repository URL
+	_, err := url.Parse(provider.WebhookURL)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+// Send creates an issue in the designed RepositoryURL if the resolved parameter passed is false,
+// or closes the relevant issue(s) if the resolved parameter passed is true.
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	if len(alert.ResolveKey) == 0 {
+		alert.ResolveKey = uuid.NewString()
+	}
+
+	buffer := bytes.NewBuffer(provider.buildAlertBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.WebhookURL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", provider.AuthorizationKey))
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type AlertBody struct {
+	Title                 string `json:"title,omitempty"`                   // The title of the alert.
+	Description           string `json:"description,omitempty"`             // A high-level summary of the problem.
+	StartTime             string `json:"start_time,omitempty"`              // The time of the alert. If none is provided, a current time is used.
+	EndTime               string `json:"end_time,omitempty"`                // The resolution time of the alert. If provided, the alert is resolved.
+	Service               string `json:"service,omitempty"`                 // The affected service.
+	MonitoringTool        string `json:"monitoring_tool,omitempty"`         // The name of the associated monitoring tool.
+	Hosts                 string `json:"hosts,omitempty"`                   // One or more hosts, as to where this incident occurred.
+	Severity              string `json:"severity,omitempty"`                // The severity of the alert. Case-insensitive. Can be one of: critical, high, medium, low, info, unknown. Defaults to critical if missing or value is not in this list.
+	Fingerprint           string `json:"fingerprint,omitempty"`             // The unique identifier of the alert. This can be used to group occurrences of the same alert.
+	GitlabEnvironmentName string `json:"gitlab_environment_name,omitempty"` // The name of the associated GitLab environment. Required to display alerts on a dashboard.
+}
+
+func (provider *AlertProvider) monitoringTool() string {
+	if len(provider.MonitoringTool) > 0 {
+		return provider.MonitoringTool
+	}
+	return "gatus"
+}
+
+func (provider *AlertProvider) service(endpoint *core.Endpoint) string {
+	if len(provider.Service) > 0 {
+		return provider.Service
+	}
+	return endpoint.DisplayName()
+}
+
+// buildAlertBody builds the body of the alert
+func (provider *AlertProvider) buildAlertBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	body := AlertBody{
+		Title:                 fmt.Sprintf("alert(%s): %s", provider.monitoringTool(), provider.service(endpoint)),
+		StartTime:             result.Timestamp.Format(time.RFC3339),
+		Service:               provider.service(endpoint),
+		MonitoringTool:        provider.monitoringTool(),
+		Hosts:                 endpoint.URL,
+		GitlabEnvironmentName: provider.EnvironmentName,
+		Severity:              provider.Severity,
+		Fingerprint:           alert.ResolveKey,
+	}
+	if resolved {
+		body.EndTime = result.Timestamp.Format(time.RFC3339)
+	}
+
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = ":white_check_mark:"
+		} else {
+			prefix = ":x:"
+		}
+		results += fmt.Sprintf("- %s - `%s`\n", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\n> " + alertDescription
+	}
+	var message string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	body.Description = message + description + "\n\n## Condition results\n" + results
+
+	json, _ := json.Marshal(body)
+	return json
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/gitlab/gitlab_test.go

@@ -0,0 +1,158 @@
+package gitlab
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
+)
+
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
+	scenarios := []struct {
+		Name     string
+		Provider AlertProvider
+		Expected bool
+	}{
+		{
+			Name:     "invalid",
+			Provider: AlertProvider{WebhookURL: "", AuthorizationKey: ""},
+			Expected: false,
+		},
+		{
+			Name:     "missing-webhook-url",
+			Provider: AlertProvider{WebhookURL: "", AuthorizationKey: "12345"},
+			Expected: false,
+		},
+		{
+			Name:     "missing-authorization-key",
+			Provider: AlertProvider{WebhookURL: "https://gitlab.com/hlidotbe/text/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json", AuthorizationKey: ""},
+			Expected: false,
+		},
+		{
+			Name:     "invalid-url",
+			Provider: AlertProvider{WebhookURL: " http://foo.com", AuthorizationKey: "12345"},
+			Expected: false,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			if scenario.Provider.IsValid() != scenario.Expected {
+				t.Errorf("expected %t, got %t", scenario.Expected, scenario.Provider.IsValid())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:          "triggered-error",
+			Provider:      AlertProvider{WebhookURL: "https://gitlab.com/hlidotbe/text/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json", AuthorizationKey: "12345"},
+			Alert:         alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      false,
+			ExpectedError: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+		},
+		{
+			Name:          "resolved-error",
+			Provider:      AlertProvider{WebhookURL: "https://gitlab.com/hlidotbe/text/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json", AuthorizationKey: "12345"},
+			Alert:         alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      true,
+			ExpectedError: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name", Group: "endpoint-group"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildAlertBody(t *testing.T) {
+	firstDescription := "description-1"
+	scenarios := []struct {
+		Name         string
+		Endpoint     core.Endpoint
+		Provider     AlertProvider
+		Alert        alert.Alert
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, FailureThreshold: 3},
+			ExpectedBody: "{\"title\":\"alert(gatus): endpoint-name\",\"description\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\\n\\n## Condition results\\n- :white_check_mark: - `[CONNECTED] == true`\\n- :x: - `[STATUS] == 200`\\n\",\"start_time\":\"0001-01-01T00:00:00Z\",\"service\":\"endpoint-name\",\"monitoring_tool\":\"gatus\",\"hosts\":\"https://example.org\"}",
+		},
+		{
+			Name:         "no-description",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{FailureThreshold: 10},
+			ExpectedBody: "{\"title\":\"alert(gatus): endpoint-name\",\"description\":\"An alert for *endpoint-name* has been triggered due to having failed 10 time(s) in a row\\n\\n## Condition results\\n- :white_check_mark: - `[CONNECTED] == true`\\n- :x: - `[STATUS] == 200`\\n\",\"start_time\":\"0001-01-01T00:00:00Z\",\"service\":\"endpoint-name\",\"monitoring_tool\":\"gatus\",\"hosts\":\"https://example.org\"}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildAlertBody(
+				&scenario.Endpoint,
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: true},
+						{Condition: "[STATUS] == 200", Success: false},
+					},
+				},
+				false,
+			)
+			if strings.TrimSpace(string(body)) != strings.TrimSpace(scenario.ExpectedBody) {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}

alerting/provider/ntfy/ntfy.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 
 	"github.com/TwiN/gatus/v5/alerting/alert"
 	"github.com/TwiN/gatus/v5/client"
@@ -23,6 +24,7 @@ type AlertProvider struct {
 	Topic    string `yaml:"topic"`
 	URL      string `yaml:"url,omitempty"`      // Defaults to DefaultURL
 	Priority int    `yaml:"priority,omitempty"` // Defaults to DefaultPriority
+	Token    string `yaml:"token,omitempty"`    // Defaults to ""
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
 	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
@@ -36,7 +38,11 @@ func (provider *AlertProvider) IsValid() bool {
 	if provider.Priority == 0 {
 		provider.Priority = DefaultPriority
 	}
-	return len(provider.URL) > 0 && len(provider.Topic) > 0 && provider.Priority > 0 && provider.Priority < 6
+	isTokenValid := true
+	if len(provider.Token) > 0 {
+		isTokenValid = strings.HasPrefix(provider.Token, "tk_")
+	}
+	return len(provider.URL) > 0 && len(provider.Topic) > 0 && provider.Priority > 0 && provider.Priority < 6 && isTokenValid
 }
 
 // Send an alert using the provider
@@ -47,6 +53,9 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 		return err
 	}
 	request.Header.Set("Content-Type", "application/json")
+	if len(provider.Token) > 0 {
+		request.Header.Set("Authorization", "Bearer "+provider.Token)
+	}
 	response, err := client.GetHTTPClient(nil).Do(request)
 	if err != nil {
 		return err

alerting/provider/ntfy/ntfy_test.go

@@ -24,6 +24,16 @@ func TestAlertDefaultProvider_IsValid(t *testing.T) {
 			provider: AlertProvider{Topic: "example", Priority: 1},
 			expected: true,
 		},
+		{
+			name:     "valid-with-token",
+			provider: AlertProvider{Topic: "example", Priority: 1, Token: "tk_faketoken"},
+			expected: true,
+		},
+		{
+			name:     "invalid-token",
+			provider: AlertProvider{Topic: "example", Priority: 1, Token: "xx_faketoken"},
+			expected: false,
+		},
 		{
 			name:     "invalid-topic",
 			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "", Priority: 1},

alerting/provider/provider.go

@@ -6,6 +6,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/discord"
 	"github.com/TwiN/gatus/v5/alerting/provider/email"
 	"github.com/TwiN/gatus/v5/alerting/provider/github"
+	"github.com/TwiN/gatus/v5/alerting/provider/gitlab"
 	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
 	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
@@ -13,6 +14,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
 	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
 	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
 	"github.com/TwiN/gatus/v5/alerting/provider/slack"
 	"github.com/TwiN/gatus/v5/alerting/provider/teams"
 	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
@@ -60,6 +62,7 @@ var (
 	_ AlertProvider = (*discord.AlertProvider)(nil)
 	_ AlertProvider = (*email.AlertProvider)(nil)
 	_ AlertProvider = (*github.AlertProvider)(nil)
+	_ AlertProvider = (*gitlab.AlertProvider)(nil)
 	_ AlertProvider = (*googlechat.AlertProvider)(nil)
 	_ AlertProvider = (*matrix.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
@@ -67,6 +70,7 @@ var (
 	_ AlertProvider = (*ntfy.AlertProvider)(nil)
 	_ AlertProvider = (*opsgenie.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+	_ AlertProvider = (*pushover.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
 	_ AlertProvider = (*teams.AlertProvider)(nil)
 	_ AlertProvider = (*telegram.AlertProvider)(nil)

alerting/provider/pushover/pushover.go

@@ -0,0 +1,112 @@
+package pushover
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+)
+
+const (
+	restAPIURL      = "https://api.pushover.net/1/messages.json"
+	defaultPriority = 0
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Pushover
+type AlertProvider struct {
+	// Key used to authenticate the application sending
+	// See "Your Applications" on the dashboard, or add a new one: https://pushover.net/apps/build
+	ApplicationToken string `yaml:"application-token"`
+
+	// Key of the user or group the messages should be sent to
+	UserKey string `yaml:"user-key"`
+
+	// The title of your message, likely the application name
+	// default: the name of your application in Pushover
+	Title string `yaml:"title,omitempty"`
+
+	// Priority of all messages, ranging from -2 (very low) to 2 (Emergency)
+	// default: 0
+	Priority int `yaml:"priority,omitempty"`
+
+	// Sound of the messages (see: https://pushover.net/api#sounds)
+	// default: "" (pushover)
+	Sound string `yaml:"sound,omitempty"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if provider.Priority == 0 {
+		provider.Priority = defaultPriority
+	}
+	return len(provider.ApplicationToken) == 30 && len(provider.UserKey) == 30 && provider.Priority >= -2 && provider.Priority <= 2
+}
+
+// Send an alert using the provider
+// Reference doc for pushover: https://pushover.net/api
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Token    string `json:"token"`
+	User     string `json:"user"`
+	Title    string `json:"title,omitempty"`
+	Message  string `json:"message"`
+	Priority int    `json:"priority"`
+	Sound    string `json:"sound,omitempty"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
+	}
+	body, _ := json.Marshal(Body{
+		Token:    provider.ApplicationToken,
+		User:     provider.UserKey,
+		Title:    provider.Title,
+		Message:  message,
+		Priority: provider.priority(),
+		Sound:    provider.Sound,
+	})
+	return body
+}
+
+func (provider *AlertProvider) priority() int {
+	if provider.Priority == 0 {
+		return defaultPriority
+	}
+	return provider.Priority
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/pushover/pushover_test.go

@@ -0,0 +1,181 @@
+package pushover
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
+)
+
+func TestPushoverAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		ApplicationToken: "aTokenWithLengthOf30characters",
+		UserKey:          "aTokenWithLengthOf30characters",
+		Title:            "Gatus Notification",
+		Priority:         1,
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestPushoverAlertProvider_IsInvalid(t *testing.T) {
+	invalidProvider := AlertProvider{
+		ApplicationToken: "aTokenWithLengthOfMoreThan30characters",
+		UserKey:          "aTokenWithLengthOfMoreThan30characters",
+		Priority:         5,
+	}
+	if invalidProvider.IsValid() {
+		t.Error("provider should've been invalid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters1", UserKey: "TokenWithLengthOf30Characters4"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters1\",\"user\":\"TokenWithLengthOf30Characters4\",\"message\":\"TRIGGERED: endpoint-name - description-1\",\"priority\":0}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters2", UserKey: "TokenWithLengthOf30Characters5", Title: "Gatus Notifications", Priority: 2},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters2\",\"user\":\"TokenWithLengthOf30Characters5\",\"title\":\"Gatus Notifications\",\"message\":\"RESOLVED: endpoint-name - description-2\",\"priority\":2}",
+		},
+		{
+			Name:         "with-sound",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters2", UserKey: "TokenWithLengthOf30Characters5", Title: "Gatus Notifications", Priority: 2, Sound: "falling"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters2\",\"user\":\"TokenWithLengthOf30Characters5\",\"title\":\"Gatus Notifications\",\"message\":\"RESOLVED: endpoint-name - description-2\",\"priority\":2,\"sound\":\"falling\"}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}

api/api.go

@@ -0,0 +1,112 @@
+package api
+
+import (
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/TwiN/gatus/v5/config"
+	static "github.com/TwiN/gatus/v5/web"
+	"github.com/TwiN/health"
+	fiber "github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/adaptor"
+	"github.com/gofiber/fiber/v2/middleware/compress"
+	"github.com/gofiber/fiber/v2/middleware/cors"
+	fiberfs "github.com/gofiber/fiber/v2/middleware/filesystem"
+	"github.com/gofiber/fiber/v2/middleware/recover"
+	"github.com/gofiber/fiber/v2/middleware/redirect"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+type API struct {
+	router *fiber.App
+}
+
+func New(cfg *config.Config) *API {
+	api := &API{}
+	api.router = api.createRouter(cfg)
+	return api
+}
+
+func (a *API) Router() *fiber.App {
+	return a.router
+}
+
+func (a *API) createRouter(cfg *config.Config) *fiber.App {
+	app := fiber.New(fiber.Config{
+		ErrorHandler: func(c *fiber.Ctx, err error) error {
+			log.Printf("[api.ErrorHandler] %s", err.Error())
+			return fiber.DefaultErrorHandler(c, err)
+		},
+	})
+	if os.Getenv("ENVIRONMENT") == "dev" {
+		app.Use(cors.New(cors.Config{
+			AllowOrigins:     "http://localhost:8081",
+			AllowCredentials: true,
+		}))
+	}
+	// Middlewares
+	app.Use(recover.New())
+	app.Use(compress.New())
+	// Define metrics handler, if necessary
+	if cfg.Metrics {
+		metricsHandler := promhttp.InstrumentMetricHandler(prometheus.DefaultRegisterer, promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{
+			DisableCompression: true,
+		}))
+		app.Get("/metrics", adaptor.HTTPHandler(metricsHandler))
+	}
+	// Define main router
+	apiRouter := app.Group("/api")
+	////////////////////////
+	// UNPROTECTED ROUTES //
+	////////////////////////
+	unprotectedAPIRouter := apiRouter.Group("/")
+	unprotectedAPIRouter.Get("/v1/config", ConfigHandler{securityConfig: cfg.Security}.GetConfig)
+	unprotectedAPIRouter.Get("/v1/endpoints/:key/health/badge.svg", HealthBadge)
+	unprotectedAPIRouter.Get("/v1/endpoints/:key/uptimes/:duration/badge.svg", UptimeBadge)
+	unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration/badge.svg", ResponseTimeBadge(cfg))
+	unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration/chart.svg", ResponseTimeChart)
+	// SPA
+	app.Get("/", SinglePageApplication(cfg.UI))
+	app.Get("/endpoints/:name", SinglePageApplication(cfg.UI))
+	// Health endpoint
+	healthHandler := health.Handler().WithJSON(true)
+	app.Get("/health", func(c *fiber.Ctx) error {
+		statusCode, body := healthHandler.GetResponseStatusCodeAndBody()
+		return c.Status(statusCode).Send(body)
+	})
+	// Everything else falls back on static content
+	app.Use(redirect.New(redirect.Config{
+		Rules: map[string]string{
+			"/index.html": "/",
+		},
+		StatusCode: 301,
+	}))
+	staticFileSystem, err := fs.Sub(static.FileSystem, static.RootPath)
+	if err != nil {
+		panic(err)
+	}
+	app.Use("/", fiberfs.New(fiberfs.Config{
+		Root:   http.FS(staticFileSystem),
+		Index:  "index.html",
+		Browse: true,
+	}))
+	//////////////////////
+	// PROTECTED ROUTES //
+	//////////////////////
+	// ORDER IS IMPORTANT: all routes applied AFTER the security middleware will require authn
+	protectedAPIRouter := apiRouter.Group("/")
+	if cfg.Security != nil {
+		if err := cfg.Security.RegisterHandlers(app); err != nil {
+			panic(err)
+		}
+		if err := cfg.Security.ApplySecurityMiddleware(protectedAPIRouter); err != nil {
+			panic(err)
+		}
+	}
+	protectedAPIRouter.Get("/v1/endpoints/statuses", EndpointStatuses(cfg))
+	protectedAPIRouter.Get("/v1/endpoints/:key/statuses", EndpointStatus)
+	return app
+}

api/api_test.go

@@ -0,0 +1,121 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/TwiN/gatus/v5/config"
+	"github.com/TwiN/gatus/v5/config/ui"
+	"github.com/TwiN/gatus/v5/security"
+	"github.com/gofiber/fiber/v2"
+)
+
+func TestNew(t *testing.T) {
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+		WithSecurity bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "health",
+			Path:         "/health",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "metrics",
+			Path:         "/metrics",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "favicon.ico",
+			Path:         "/favicon.ico",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "app.js",
+			Path:         "/js/app.js",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "app.js-gzipped",
+			Path:         "/js/app.js",
+			ExpectedCode: fiber.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "chunk-vendors.js",
+			Path:         "/js/chunk-vendors.js",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "chunk-vendors.js-gzipped",
+			Path:         "/js/chunk-vendors.js",
+			ExpectedCode: fiber.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "index",
+			Path:         "/",
+			ExpectedCode: fiber.StatusOK,
+		},
+		{
+			Name:         "index-html-redirect",
+			Path:         "/index.html",
+			ExpectedCode: fiber.StatusMovedPermanently,
+		},
+		{
+			Name:         "index-should-return-200-even-if-not-authenticated",
+			Path:         "/",
+			ExpectedCode: fiber.StatusOK,
+			WithSecurity: true,
+		},
+		{
+			Name:         "endpoints-should-return-401-if-not-authenticated",
+			Path:         "/api/v1/endpoints/statuses",
+			ExpectedCode: fiber.StatusUnauthorized,
+			WithSecurity: true,
+		},
+		{
+			Name:         "config-should-return-200-even-if-not-authenticated",
+			Path:         "/api/v1/config",
+			ExpectedCode: fiber.StatusOK,
+			WithSecurity: true,
+		},
+		{
+			Name:         "config-should-always-return-200",
+			Path:         "/api/v1/config",
+			ExpectedCode: fiber.StatusOK,
+			WithSecurity: false,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			cfg := &config.Config{Metrics: true, UI: &ui.Config{}}
+			if scenario.WithSecurity {
+				cfg.Security = &security.Config{
+					Basic: &security.BasicConfig{
+						Username:                        "john.doe",
+						PasswordBcryptHashBase64Encoded: "JDJhJDA4JDFoRnpPY1hnaFl1OC9ISlFsa21VS09wOGlPU1ZOTDlHZG1qeTFvb3dIckRBUnlHUmNIRWlT",
+					},
+				}
+			}
+			api := New(cfg)
+			router := api.Router()
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			response, err := router.Test(request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
+			}
+		})
+	}
+}

api/badge.go

@@ -1,8 +1,7 @@
-package handler
+package api
 
 import (
 	"fmt"
-	"net/http"
 	"strconv"
 	"strings"
 	"time"
@@ -11,7 +10,7 @@ import (
 	"github.com/TwiN/gatus/v5/storage/store"
 	"github.com/TwiN/gatus/v5/storage/store/common"
 	"github.com/TwiN/gatus/v5/storage/store/common/paging"
-	"github.com/gorilla/mux"
+	"github.com/gofiber/fiber/v2"
 )
 
 const (
@@ -35,10 +34,9 @@ var (
 
 // UptimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
-// Valid values for {duration}: 7d, 24h, 1h
-func UptimeBadge(writer http.ResponseWriter, request *http.Request) {
-	variables := mux.Vars(request)
-	duration := variables["duration"]
+// Valid values for :duration -> 7d, 24h, 1h
+func UptimeBadge(c *fiber.Ctx) error {
+	duration := c.Params("duration")
 	var from time.Time
 	switch duration {
 	case "7d":
@@ -48,35 +46,30 @@ func UptimeBadge(writer http.ResponseWriter, request *http.Request) {
 	case "1h":
 		from = time.Now().Add(-2 * time.Hour) // Because uptime metrics are stored by hour, we have to cheat a little
 	default:
-		http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
-		return
+		return c.Status(400).SendString("Durations supported: 7d, 24h, 1h")
 	}
-	key := variables["key"]
+	key := c.Params("key")
 	uptime, err := store.Get().GetUptimeByKey(key, from, time.Now())
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			http.Error(writer, err.Error(), http.StatusNotFound)
+			return c.Status(404).SendString(err.Error())
 		} else if err == common.ErrInvalidTimeRange {
-			http.Error(writer, err.Error(), http.StatusBadRequest)
-		} else {
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
+			return c.Status(400).SendString(err.Error())
 		}
-		return
+		return c.Status(500).SendString(err.Error())
 	}
-	writer.Header().Set("Content-Type", "image/svg+xml")
-	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	writer.Header().Set("Expires", "0")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(generateUptimeBadgeSVG(duration, uptime))
+	c.Set("Content-Type", "image/svg+xml")
+	c.Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	c.Set("Expires", "0")
+	return c.Status(200).Send(generateUptimeBadgeSVG(duration, uptime))
 }
 
 // ResponseTimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
-// Valid values for {duration}: 7d, 24h, 1h
-func ResponseTimeBadge(config *config.Config) http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		variables := mux.Vars(request)
-		duration := variables["duration"]
+// Valid values for :duration -> 7d, 24h, 1h
+func ResponseTimeBadge(config *config.Config) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		duration := c.Params("duration")
 		var from time.Time
 		switch duration {
 		case "7d":
@@ -86,44 +79,37 @@ func ResponseTimeBadge(config *config.Config) http.HandlerFunc {
 		case "1h":
 			from = time.Now().Add(-2 * time.Hour) // Because response time metrics are stored by hour, we have to cheat a little
 		default:
-			http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
-			return
+			return c.Status(400).SendString("Durations supported: 7d, 24h, 1h")
 		}
-		key := variables["key"]
+		key := c.Params("key")
 		averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now())
 		if err != nil {
 			if err == common.ErrEndpointNotFound {
-				http.Error(writer, err.Error(), http.StatusNotFound)
+				return c.Status(404).SendString(err.Error())
 			} else if err == common.ErrInvalidTimeRange {
-				http.Error(writer, err.Error(), http.StatusBadRequest)
-			} else {
-				http.Error(writer, err.Error(), http.StatusInternalServerError)
+				return c.Status(400).SendString(err.Error())
 			}
-			return
+			return c.Status(500).SendString(err.Error())
 		}
-		writer.Header().Set("Content-Type", "image/svg+xml")
-		writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-		writer.Header().Set("Expires", "0")
-		writer.WriteHeader(http.StatusOK)
-		_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime, key, config))
+		c.Set("Content-Type", "image/svg+xml")
+		c.Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		c.Set("Expires", "0")
+		return c.Status(200).Send(generateResponseTimeBadgeSVG(duration, averageResponseTime, key, config))
 	}
 }
 
 // HealthBadge handles the automatic generation of badge based on the group name and endpoint name passed.
-func HealthBadge(writer http.ResponseWriter, request *http.Request) {
-	variables := mux.Vars(request)
-	key := variables["key"]
+func HealthBadge(c *fiber.Ctx) error {
+	key := c.Params("key")
 	pagingConfig := paging.NewEndpointStatusParams()
 	status, err := store.Get().GetEndpointStatusByKey(key, pagingConfig.WithResults(1, 1))
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			http.Error(writer, err.Error(), http.StatusNotFound)
+			return c.Status(404).SendString(err.Error())
 		} else if err == common.ErrInvalidTimeRange {
-			http.Error(writer, err.Error(), http.StatusBadRequest)
-		} else {
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
+			return c.Status(400).SendString(err.Error())
 		}
-		return
+		return c.Status(500).SendString(err.Error())
 	}
 	healthStatus := HealthStatusUnknown
 	if len(status.Results) > 0 {
@@ -133,11 +119,10 @@ func HealthBadge(writer http.ResponseWriter, request *http.Request) {
 			healthStatus = HealthStatusDown
 		}
 	}
-	writer.Header().Set("Content-Type", "image/svg+xml")
-	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	writer.Header().Set("Expires", "0")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(generateHealthBadgeSVG(healthStatus))
+	c.Set("Content-Type", "image/svg+xml")
+	c.Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	c.Set("Expires", "0")
+	return c.Status(200).Send(generateHealthBadgeSVG(healthStatus))
 }
 
 func generateUptimeBadgeSVG(duration string, uptime float64) []byte {

api/badge_test.go

@@ -1,4 +1,4 @@
-package handler
+package api
 
 import (
 	"net/http"
@@ -31,38 +31,13 @@ func TestBadge(t *testing.T) {
 		},
 	}
 
-	testSuccessfulResult = core.Result{
-		Hostname:              "example.org",
-		IP:                    "127.0.0.1",
-		HTTPStatus:            200,
-		Errors:                nil,
-		Connected:             true,
-		Success:               true,
-		Timestamp:             timestamp,
-		Duration:              150 * time.Millisecond,
-		CertificateExpiration: 10 * time.Hour,
-		ConditionResults: []*core.ConditionResult{
-			{
-				Condition: "[STATUS] == 200",
-				Success:   true,
-			},
-			{
-				Condition: "[RESPONSE_TIME] < 500",
-				Success:   true,
-			},
-			{
-				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
-				Success:   true,
-			},
-		},
-	}
-
 	cfg.Endpoints[0].UIConfig = ui.GetDefaultConfig()
 	cfg.Endpoints[1].UIConfig = ui.GetDefaultConfig()
 
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Connected: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Connected: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter(cfg)
+	api := New(cfg)
+	router := api.Router()
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -153,14 +128,16 @@ func TestBadge(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			response, err := router.Test(request)
+			if err != nil {
+				return
+			}
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
 			}
 		})
 	}
@@ -266,6 +243,32 @@ func TestGetBadgeColorFromResponseTime(t *testing.T) {
 		Endpoints: []*core.Endpoint{&firstTestEndpoint, &secondTestEndpoint},
 	}
 
+	testSuccessfulResult := core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                nil,
+		Connected:             true,
+		Success:               true,
+		Timestamp:             time.Now(),
+		Duration:              150 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+
 	store.Get().Insert(&firstTestEndpoint, &testSuccessfulResult)
 	store.Get().Insert(&secondTestEndpoint, &testSuccessfulResult)
 

api/cache.go

@@ -0,0 +1,15 @@
+package api
+
+import (
+	"time"
+
+	"github.com/TwiN/gocache/v2"
+)
+
+const (
+	cacheTTL = 10 * time.Second
+)
+
+var (
+	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.FirstInFirstOut)
+)

api/chart.go

@@ -1,4 +1,4 @@
-package handler
+package api
 
 import (
 	"log"
@@ -9,7 +9,7 @@ import (
 
 	"github.com/TwiN/gatus/v5/storage/store"
 	"github.com/TwiN/gatus/v5/storage/store/common"
-	"github.com/gorilla/mux"
+	"github.com/gofiber/fiber/v2"
 	"github.com/wcharczuk/go-chart/v2"
 	"github.com/wcharczuk/go-chart/v2/drawing"
 )
@@ -29,9 +29,8 @@ var (
 	}
 )
 
-func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	duration := vars["duration"]
+func ResponseTimeChart(c *fiber.Ctx) error {
+	duration := c.Params("duration")
 	var from time.Time
 	switch duration {
 	case "7d":
@@ -39,23 +38,19 @@ func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
 	case "24h":
 		from = time.Now().Truncate(time.Hour).Add(-24 * time.Hour)
 	default:
-		http.Error(writer, "Durations supported: 7d, 24h", http.StatusBadRequest)
-		return
+		return c.Status(400).SendString("Durations supported: 7d, 24h")
 	}
-	hourlyAverageResponseTime, err := store.Get().GetHourlyAverageResponseTimeByKey(vars["key"], from, time.Now())
+	hourlyAverageResponseTime, err := store.Get().GetHourlyAverageResponseTimeByKey(c.Params("key"), from, time.Now())
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			http.Error(writer, err.Error(), http.StatusNotFound)
+			return c.Status(404).SendString(err.Error())
 		} else if err == common.ErrInvalidTimeRange {
-			http.Error(writer, err.Error(), http.StatusBadRequest)
-		} else {
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
+			return c.Status(400).SendString(err.Error())
 		}
-		return
+		return c.Status(500).SendString(err.Error())
 	}
 	if len(hourlyAverageResponseTime) == 0 {
-		http.Error(writer, "", http.StatusNoContent)
-		return
+		return c.Status(204).SendString("")
 	}
 	series := chart.TimeSeries{
 		Name: "Average response time per hour",
@@ -111,12 +106,13 @@ func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
 		},
 		Series: []chart.Series{series},
 	}
-	writer.Header().Set("Content-Type", "image/svg+xml")
-	writer.Header().Set("Cache-Control", "no-cache, no-store")
-	writer.Header().Set("Expires", "0")
-	writer.WriteHeader(http.StatusOK)
-	if err := graph.Render(chart.SVG, writer); err != nil {
-		log.Println("[handler][ResponseTimeChart] Failed to render response time chart:", err.Error())
-		return
+	c.Set("Content-Type", "image/svg+xml")
+	c.Set("Cache-Control", "no-cache, no-store")
+	c.Set("Expires", "0")
+	c.Status(http.StatusOK)
+	if err := graph.Render(chart.SVG, c); err != nil {
+		log.Println("[api][ResponseTimeChart] Failed to render response time chart:", err.Error())
+		return c.Status(500).SendString(err.Error())
 	}
+	return nil
 }

api/chart_test.go

@@ -1,4 +1,4 @@
-package handler
+package api
 
 import (
 	"net/http"
@@ -30,7 +30,8 @@ func TestResponseTimeChart(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter(cfg)
+	api := New(cfg)
+	router := api.Router()
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -61,14 +62,16 @@ func TestResponseTimeChart(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			response, err := router.Test(request)
+			if err != nil {
+				return
+			}
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
 			}
 		})
 	}

api/config.go

@@ -0,0 +1,25 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/TwiN/gatus/v5/security"
+	"github.com/gofiber/fiber/v2"
+)
+
+type ConfigHandler struct {
+	securityConfig *security.Config
+}
+
+func (handler ConfigHandler) GetConfig(c *fiber.Ctx) error {
+	hasOIDC := false
+	isAuthenticated := true // Default to true if no security config is set
+	if handler.securityConfig != nil {
+		hasOIDC = handler.securityConfig.OIDC != nil
+		isAuthenticated = handler.securityConfig.IsAuthenticated(c)
+	}
+	// Return the config
+	c.Set("Content-Type", "application/json")
+	return c.Status(200).
+		SendString(fmt.Sprintf(`{"oidc":%v,"authenticated":%v}`, hasOIDC, isAuthenticated))
+}

api/config_test.go

@@ -1,12 +1,12 @@
-package handler
+package api
 
 import (
+	"io"
 	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"github.com/TwiN/gatus/v5/security"
-	"github.com/gorilla/mux"
+	"github.com/gofiber/fiber/v2"
 )
 
 func TestConfigHandler_ServeHTTP(t *testing.T) {
@@ -20,15 +20,27 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 	}
 	handler := ConfigHandler{securityConfig: securityConfig}
 	// Create a fake router. We're doing this because I need the gate to be initialized.
-	securityConfig.ApplySecurityMiddleware(mux.NewRouter())
+	app := fiber.New()
+	app.Get("/api/v1/config", handler.GetConfig)
+	err := securityConfig.ApplySecurityMiddleware(app)
+	if err != nil {
+		t.Error("expected err to be nil, but was", err)
+	}
 	// Test the config handler
 	request, _ := http.NewRequest("GET", "/api/v1/config", http.NoBody)
-	responseRecorder := httptest.NewRecorder()
-	handler.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusOK {
-		t.Error("expected code to be 200, but was", responseRecorder.Code)
+	response, err := app.Test(request)
+	if err != nil {
+		t.Error("expected err to be nil, but was", err)
 	}
-	if responseRecorder.Body.String() != `{"oidc":true,"authenticated":false}` {
-		t.Error("expected body to be `{\"oidc\":true,\"authenticated\":false}`, but was", responseRecorder.Body.String())
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		t.Error("expected code to be 200, but was", response.StatusCode)
+	}
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		t.Error("expected err to be nil, but was", err)
+	}
+	if string(body) != `{"oidc":true,"authenticated":false}` {
+		t.Error("expected body to be `{\"oidc\":true,\"authenticated\":false}`, but was", string(body))
 	}
 }

api/endpoint_status.go

@@ -1,15 +1,10 @@
-package handler
+package api
 
 import (
-	"bytes"
-	"compress/gzip"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
-	"net/http"
-	"strings"
-	"time"
 
 	"github.com/TwiN/gatus/v5/client"
 	"github.com/TwiN/gatus/v5/config"
@@ -18,43 +13,21 @@ import (
 	"github.com/TwiN/gatus/v5/storage/store"
 	"github.com/TwiN/gatus/v5/storage/store/common"
 	"github.com/TwiN/gatus/v5/storage/store/common/paging"
-	"github.com/TwiN/gocache/v2"
-	"github.com/gorilla/mux"
-)
-
-const (
-	cacheTTL = 10 * time.Second
-)
-
-var (
-	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.FirstInFirstOut)
+	"github.com/gofiber/fiber/v2"
 )
 
 // EndpointStatuses handles requests to retrieve all EndpointStatus
-// Due to the size of the response, this function leverages a cache.
-// Must not be wrapped by GzipHandler
-func EndpointStatuses(cfg *config.Config) http.HandlerFunc {
-	return func(writer http.ResponseWriter, r *http.Request) {
-		page, pageSize := extractPageAndPageSizeFromRequest(r)
-		gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
-		var exists bool
-		var value interface{}
-		if gzipped {
-			writer.Header().Set("Content-Encoding", "gzip")
-			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize))
-		} else {
-			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
-		}
+// Due to how intensive this operation can be on the storage, this function leverages a cache.
+func EndpointStatuses(cfg *config.Config) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		page, pageSize := extractPageAndPageSizeFromRequest(c)
+		value, exists := cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
 		var data []byte
 		if !exists {
-			var err error
-			buffer := &bytes.Buffer{}
-			gzipWriter := gzip.NewWriter(buffer)
 			endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize))
 			if err != nil {
-				log.Printf("[handler][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
-				http.Error(writer, err.Error(), http.StatusInternalServerError)
-				return
+				log.Printf("[api][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
+				return c.Status(500).SendString(err.Error())
 			}
 			// ALPHA: Retrieve endpoint statuses from remote instances
 			if endpointStatusesFromRemote, err := getEndpointStatusesFromRemoteInstances(cfg.Remote); err != nil {
@@ -65,24 +38,15 @@ func EndpointStatuses(cfg *config.Config) http.HandlerFunc {
 			// Marshal endpoint statuses to JSON
 			data, err = json.Marshal(endpointStatuses)
 			if err != nil {
-				log.Printf("[handler][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
-				http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
-				return
+				log.Printf("[api][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
+				return c.Status(500).SendString("unable to marshal object to JSON")
 			}
-			_, _ = gzipWriter.Write(data)
-			_ = gzipWriter.Close()
-			gzippedData := buffer.Bytes()
 			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL)
-			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
-			if gzipped {
-				data = gzippedData
-			}
 		} else {
 			data = value.([]byte)
 		}
-		writer.Header().Add("Content-Type", "application/json")
-		writer.WriteHeader(http.StatusOK)
-		_, _ = writer.Write(data)
+		c.Set("Content-Type", "application/json")
+		return c.Status(200).Send(data)
 	}
 }
 
@@ -119,31 +83,25 @@ func getEndpointStatusesFromRemoteInstances(remoteConfig *remote.Config) ([]*cor
 }
 
 // EndpointStatus retrieves a single core.EndpointStatus by group and endpoint name
-func EndpointStatus(writer http.ResponseWriter, r *http.Request) {
-	page, pageSize := extractPageAndPageSizeFromRequest(r)
-	vars := mux.Vars(r)
-	endpointStatus, err := store.Get().GetEndpointStatusByKey(vars["key"], paging.NewEndpointStatusParams().WithResults(page, pageSize).WithEvents(1, common.MaximumNumberOfEvents))
+func EndpointStatus(c *fiber.Ctx) error {
+	page, pageSize := extractPageAndPageSizeFromRequest(c)
+	endpointStatus, err := store.Get().GetEndpointStatusByKey(c.Params("key"), paging.NewEndpointStatusParams().WithResults(page, pageSize).WithEvents(1, common.MaximumNumberOfEvents))
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			http.Error(writer, err.Error(), http.StatusNotFound)
-			return
+			return c.Status(404).SendString(err.Error())
 		}
-		log.Printf("[handler][EndpointStatus] Failed to retrieve endpoint status: %s", err.Error())
-		http.Error(writer, err.Error(), http.StatusInternalServerError)
-		return
+		log.Printf("[api][EndpointStatus] Failed to retrieve endpoint status: %s", err.Error())
+		return c.Status(500).SendString(err.Error())
 	}
-	if endpointStatus == nil {
-		log.Printf("[handler][EndpointStatus] Endpoint with key=%s not found", vars["key"])
-		http.Error(writer, "not found", http.StatusNotFound)
-		return
+	if endpointStatus == nil { // XXX: is this check necessary?
+		log.Printf("[api][EndpointStatus] Endpoint with key=%s not found", c.Params("key"))
+		return c.Status(404).SendString("not found")
 	}
 	output, err := json.Marshal(endpointStatus)
 	if err != nil {
-		log.Printf("[handler][EndpointStatus] Unable to marshal object to JSON: %s", err.Error())
-		http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
-		return
+		log.Printf("[api][EndpointStatus] Unable to marshal object to JSON: %s", err.Error())
+		return c.Status(500).SendString("unable to marshal object to JSON")
 	}
-	writer.Header().Add("Content-Type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(output)
+	c.Set("Content-Type", "application/json")
+	return c.Status(200).Send(output)
 }

api/endpoint_status_test.go

@@ -1,6 +1,7 @@
-package handler
+package api
 
 import (
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -97,8 +98,8 @@ func TestEndpointStatus(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter(cfg)
-
+	api := New(cfg)
+	router := api.Router()
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -130,14 +131,16 @@ func TestEndpointStatus(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			response, err := router.Test(request)
+			if err != nil {
+				return
+			}
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
 			}
 		})
 	}
@@ -153,8 +156,8 @@ func TestEndpointStatuses(t *testing.T) {
 	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
 	firstResult.Timestamp = time.Time{}
 	secondResult.Timestamp = time.Time{}
-	router := CreateRouter(&config.Config{Metrics: true})
-
+	api := New(&config.Config{Metrics: true})
+	router := api.Router()
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -196,15 +199,21 @@ func TestEndpointStatuses(t *testing.T) {
 
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
+			response, err := router.Test(request)
+			if err != nil {
+				return
 			}
-			output := responseRecorder.Body.String()
-			if output != scenario.ExpectedBody {
-				t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, output)
+			defer response.Body.Close()
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
+			}
+			body, err := io.ReadAll(response.Body)
+			if err != nil {
+				t.Error("expected err to be nil, but was", err)
+			}
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, string(body))
 			}
 		})
 	}

api/spa.go

@@ -0,0 +1,30 @@
+package api
+
+import (
+	_ "embed"
+	"html/template"
+	"log"
+
+	"github.com/TwiN/gatus/v5/config/ui"
+	static "github.com/TwiN/gatus/v5/web"
+	"github.com/gofiber/fiber/v2"
+)
+
+func SinglePageApplication(ui *ui.Config) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		t, err := template.ParseFS(static.FileSystem, static.IndexPath)
+		if err != nil {
+			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
+			log.Println("[api][SinglePageApplication] Failed to parse template. This should never happen, because the template is validated on start. Error:", err.Error())
+			return c.Status(500).SendString("Failed to parse template. This should never happen, because the template is validated on start.")
+		}
+		c.Set("Content-Type", "text/html")
+		err = t.Execute(c, ui)
+		if err != nil {
+			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
+			log.Println("[api][SinglePageApplication] Failed to execute template. This should never happen, because the template is validated on start. Error:", err.Error())
+			return c.Status(500).SendString("Failed to parse template. This should never happen, because the template is validated on start.")
+		}
+		return c.SendStatus(200)
+	}
+}

api/spa_test.go

@@ -1,12 +1,15 @@
-package handler
+package api
 
 import (
+	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/TwiN/gatus/v5/config"
+	"github.com/TwiN/gatus/v5/config/ui"
 	"github.com/TwiN/gatus/v5/core"
 	"github.com/TwiN/gatus/v5/storage/store"
 	"github.com/TwiN/gatus/v5/watchdog"
@@ -27,10 +30,14 @@ func TestSinglePageApplication(t *testing.T) {
 				Group: "core",
 			},
 		},
+		UI: &ui.Config{
+			Title: "example-title",
+		},
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter(cfg)
+	api := New(cfg)
+	router := api.Router()
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -41,24 +48,31 @@ func TestSinglePageApplication(t *testing.T) {
 		{
 			Name:         "frontend-home",
 			Path:         "/",
-			ExpectedCode: http.StatusOK,
+			ExpectedCode: 200,
 		},
 		{
 			Name:         "frontend-endpoint",
 			Path:         "/endpoints/core_frontend",
-			ExpectedCode: http.StatusOK,
+			ExpectedCode: 200,
 		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
+			request := httptest.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			response, err := router.Test(request)
+			if err != nil {
+				return
+			}
+			defer response.Body.Close()
+			if response.StatusCode != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode)
+			}
+			body, _ := io.ReadAll(response.Body)
+			if !strings.Contains(string(body), cfg.UI.Title) {
+				t.Errorf("%s %s should have contained the title", request.Method, request.URL)
 			}
 		})
 	}

api/util.go

@@ -1,10 +1,10 @@
-package handler
+package api
 
 import (
-	"net/http"
 	"strconv"
 
 	"github.com/TwiN/gatus/v5/storage/store/common"
+	"github.com/gofiber/fiber/v2"
 )
 
 const (
@@ -18,9 +18,9 @@ const (
 	MaximumPageSize = common.MaximumNumberOfResults
 )
 
-func extractPageAndPageSizeFromRequest(r *http.Request) (page int, pageSize int) {
+func extractPageAndPageSizeFromRequest(c *fiber.Ctx) (page, pageSize int) {
 	var err error
-	if pageParameter := r.URL.Query().Get("page"); len(pageParameter) == 0 {
+	if pageParameter := c.Query("page"); len(pageParameter) == 0 {
 		page = DefaultPage
 	} else {
 		page, err = strconv.Atoi(pageParameter)
@@ -31,7 +31,7 @@ func extractPageAndPageSizeFromRequest(r *http.Request) (page int, pageSize int)
 			page = DefaultPage
 		}
 	}
-	if pageSizeParameter := r.URL.Query().Get("pageSize"); len(pageSizeParameter) == 0 {
+	if pageSizeParameter := c.Query("pageSize"); len(pageSizeParameter) == 0 {
 		pageSize = DefaultPageSize
 	} else {
 		pageSize, err = strconv.Atoi(pageSizeParameter)

api/util_test.go

@@ -1,9 +1,11 @@
-package handler
+package api
 
 import (
 	"fmt"
-	"net/http"
 	"testing"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/valyala/fasthttp"
 )
 
 func TestExtractPageAndPageSizeFromRequest(t *testing.T) {
@@ -54,8 +56,12 @@ func TestExtractPageAndPageSizeFromRequest(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run("page-"+scenario.Page+"-pageSize-"+scenario.PageSize, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), http.NoBody)
-			actualPage, actualPageSize := extractPageAndPageSizeFromRequest(request)
+			//request := httptest.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), http.NoBody)
+			app := fiber.New()
+			c := app.AcquireCtx(&fasthttp.RequestCtx{})
+			defer app.ReleaseCtx(c)
+			c.Request().SetRequestURI(fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize))
+			actualPage, actualPageSize := extractPageAndPageSizeFromRequest(c)
 			if actualPage != scenario.ExpectedPage {
 				t.Errorf("expected %d, got %d", scenario.ExpectedPage, actualPage)
 			}

client/client.go

@@ -14,8 +14,8 @@ import (
 
 	"github.com/TwiN/gocache/v2"
 	"github.com/TwiN/whois"
-	"github.com/go-ping/ping"
 	"github.com/ishidawataru/sctp"
+	ping "github.com/prometheus-community/pro-bing"
 )
 
 var (
@@ -168,7 +168,7 @@ func Ping(address string, config *Config) (bool, time.Duration) {
 	// See https://github.com/TwiN/gatus/issues/132
 	//
 	// Note that for this to work on Linux, Gatus must run with sudo privileges.
-	// See https://github.com/go-ping/ping#linux
+	// See https://github.com/prometheus-community/pro-bing#linux
 	pinger.SetPrivileged(runtime.GOOS != "darwin")
 	err = pinger.Run()
 	if err != nil {

client/client_test.go

@@ -36,6 +36,7 @@ func TestGetHTTPClient(t *testing.T) {
 }
 
 func TestGetDomainExpiration(t *testing.T) {
+	t.Parallel()
 	if domainExpiration, err := GetDomainExpiration("example.com"); err != nil {
 		t.Fatalf("expected error to be nil, but got: `%s`", err)
 	} else if domainExpiration <= 0 {
@@ -63,6 +64,7 @@ func TestGetDomainExpiration(t *testing.T) {
 }
 
 func TestPing(t *testing.T) {
+	t.Parallel()
 	if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond}); !success {
 		t.Error("expected true")
 		if rtt == 0 {
@@ -121,6 +123,7 @@ func TestCanPerformStartTLS(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
 			connected, _, err := CanPerformStartTLS(tt.args.address, &Config{Insecure: tt.args.insecure, Timeout: 5 * time.Second})
 			if (err != nil) != tt.wantErr {
 				t.Errorf("CanPerformStartTLS() err=%v, wantErr=%v", err, tt.wantErr)
@@ -171,6 +174,7 @@ func TestCanPerformTLS(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
 			connected, _, err := CanPerformTLS(tt.args.address, &Config{Insecure: tt.args.insecure, Timeout: 5 * time.Second})
 			if (err != nil) != tt.wantErr {
 				t.Errorf("CanPerformTLS() err=%v, wantErr=%v", err, tt.wantErr)
@@ -187,6 +191,9 @@ func TestCanCreateTCPConnection(t *testing.T) {
 	if CanCreateTCPConnection("127.0.0.1", &Config{Timeout: 5 * time.Second}) {
 		t.Error("should've failed, because there's no port in the address")
 	}
+	if !CanCreateTCPConnection("1.1.1.1:53", &Config{Timeout: 5 * time.Second}) {
+		t.Error("should've succeeded, because that IP should always™ be up")
+	}
 }
 
 // This test checks if a HTTP client configured with `configureOAuth2()` automatically

config/config.go

@@ -3,13 +3,18 @@ package config
 import (
 	"errors"
 	"fmt"
+	"io/fs"
 	"log"
 	"os"
+	"path/filepath"
+	"strings"
 	"time"
 
+	"github.com/TwiN/deepmerge"
 	"github.com/TwiN/gatus/v5/alerting"
 	"github.com/TwiN/gatus/v5/alerting/alert"
 	"github.com/TwiN/gatus/v5/alerting/provider"
+	"github.com/TwiN/gatus/v5/config/connectivity"
 	"github.com/TwiN/gatus/v5/config/maintenance"
 	"github.com/TwiN/gatus/v5/config/remote"
 	"github.com/TwiN/gatus/v5/config/ui"
@@ -18,12 +23,12 @@ import (
 	"github.com/TwiN/gatus/v5/security"
 	"github.com/TwiN/gatus/v5/storage"
 	"github.com/TwiN/gatus/v5/util"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 const (
 	// DefaultConfigurationFilePath is the default path that will be used to search for the configuration file
-	// if a custom path isn't configured through the GATUS_CONFIG_FILE environment variable
+	// if a custom path isn't configured through the GATUS_CONFIG_PATH environment variable
 	DefaultConfigurationFilePath = "config/config.yaml"
 
 	// DefaultFallbackConfigurationFilePath is the default fallback path that will be used to search for the
@@ -32,14 +37,17 @@ const (
 )
 
 var (
-	// ErrNoEndpointInConfig is an error returned when a configuration file has no endpoints configured
-	ErrNoEndpointInConfig = errors.New("configuration file should contain at least 1 endpoint")
+	// ErrNoEndpointInConfig is an error returned when a configuration file or directory has no endpoints configured
+	ErrNoEndpointInConfig = errors.New("configuration should contain at least 1 endpoint")
 
-	// ErrConfigFileNotFound is an error returned when the configuration file could not be found
+	// ErrConfigFileNotFound is an error returned when a configuration file could not be found
 	ErrConfigFileNotFound = errors.New("configuration file not found")
 
 	// ErrInvalidSecurityConfig is an error returned when the security configuration is invalid
 	ErrInvalidSecurityConfig = errors.New("invalid security configuration")
+
+	// errEarlyReturn is returned to break out of a loop from a callback early
+	errEarlyReturn = errors.New("early escape")
 )
 
 // Config is the main configuration structure
@@ -84,11 +92,15 @@ type Config struct {
 	// WARNING: This is in ALPHA and may change or be completely removed in the future
 	Remote *remote.Config `yaml:"remote,omitempty"`
 
-	filePath        string    // path to the file from which config was loaded from
+	// Connectivity is the configuration for connectivity
+	Connectivity *connectivity.Config `yaml:"connectivity,omitempty"`
+
+	configPath      string    // path to the file or directory from which config was loaded
 	lastFileModTime time.Time // last modification time
 }
 
 func (config *Config) GetEndpointByKey(key string) *core.Endpoint {
+	// TODO: Should probably add a mutex here to prevent concurrent access
 	for i := 0; i < len(config.Endpoints); i++ {
 		ep := config.Endpoints[i]
 		if util.ConvertGroupAndEndpointNameToKey(ep.Group, ep.Name) == key {
@@ -98,69 +110,122 @@ func (config *Config) GetEndpointByKey(key string) *core.Endpoint {
 	return nil
 }
 
-// HasLoadedConfigurationFileBeenModified returns whether the file that the
+// HasLoadedConfigurationBeenModified returns whether one of the file that the
 // configuration has been loaded from has been modified since it was last read
-func (config Config) HasLoadedConfigurationFileBeenModified() bool {
-	if fileInfo, err := os.Stat(config.filePath); err == nil {
-		if !fileInfo.ModTime().IsZero() {
-			return config.lastFileModTime.Unix() != fileInfo.ModTime().Unix()
-		}
+func (config Config) HasLoadedConfigurationBeenModified() bool {
+	lastMod := config.lastFileModTime.Unix()
+	fileInfo, err := os.Stat(config.configPath)
+	if err != nil {
+		return false
 	}
-	return false
+	if fileInfo.IsDir() {
+		err = walkConfigDir(config.configPath, func(path string, d fs.DirEntry, err error) error {
+			if info, err := d.Info(); err == nil && lastMod < info.ModTime().Unix() {
+				return errEarlyReturn
+			}
+			return nil
+		})
+		return err == errEarlyReturn
+	}
+	return !fileInfo.ModTime().IsZero() && config.lastFileModTime.Unix() < fileInfo.ModTime().Unix()
 }
 
 // UpdateLastFileModTime refreshes Config.lastFileModTime
 func (config *Config) UpdateLastFileModTime() {
-	if fileInfo, err := os.Stat(config.filePath); err == nil {
-		if !fileInfo.ModTime().IsZero() {
-			config.lastFileModTime = fileInfo.ModTime()
+	config.lastFileModTime = time.Now()
+}
+
+// LoadConfiguration loads the full configuration composed from the main configuration file
+// and all composed configuration files
+func LoadConfiguration(configPath string) (*Config, error) {
+	var configBytes []byte
+	var fileInfo os.FileInfo
+	var usedConfigPath string
+	// Figure out what config path we'll use (either configPath or the default config path)
+	for _, configurationPath := range []string{configPath, DefaultConfigurationFilePath, DefaultFallbackConfigurationFilePath} {
+		if len(configurationPath) == 0 {
+			continue
+		}
+		var err error
+		fileInfo, err = os.Stat(configurationPath)
+		if err != nil {
+			continue
+		}
+		usedConfigPath = configurationPath
+		break
+	}
+	if len(usedConfigPath) == 0 {
+		return nil, ErrConfigFileNotFound
+	}
+	var config *Config
+	if fileInfo.IsDir() {
+		err := walkConfigDir(configPath, func(path string, d fs.DirEntry, err error) error {
+			if err != nil {
+				log.Printf("[config][LoadConfiguration] Error walking path=%s: %s", path, err)
+				return err
+			}
+			log.Printf("[config][LoadConfiguration] Reading configuration from %s", path)
+			data, err := os.ReadFile(path)
+			if err != nil {
+				log.Printf("[config][LoadConfiguration] Error reading configuration from %s: %s", path, err)
+				return fmt.Errorf("error reading configuration from file %s: %w", path, err)
+			}
+			configBytes, err = deepmerge.YAML(configBytes, data)
+			return err
+		})
+		if err != nil {
+			return nil, fmt.Errorf("error reading configuration from directory %s: %w", usedConfigPath, err)
 		}
 	} else {
-		log.Println("[config][UpdateLastFileModTime] Ran into error updating lastFileModTime:", err.Error())
-	}
-}
-
-// Load loads a custom configuration file
-// Note that the misconfiguration of some fields may lead to panics. This is on purpose.
-func Load(configFile string) (*Config, error) {
-	log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
-	cfg, err := readConfigurationFile(configFile)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, ErrConfigFileNotFound
+		log.Printf("[config][LoadConfiguration] Reading configuration from configFile=%s", configPath)
+		if data, err := os.ReadFile(usedConfigPath); err != nil {
+			return nil, err
+		} else {
+			configBytes = data
 		}
+	}
+	if len(configBytes) == 0 {
+		return nil, ErrConfigFileNotFound
+	}
+	config, err := parseAndValidateConfigBytes(configBytes)
+	if err != nil {
 		return nil, err
 	}
-	cfg.filePath = configFile
-	cfg.UpdateLastFileModTime()
-	return cfg, nil
+	config.configPath = usedConfigPath
+	config.UpdateLastFileModTime()
+	return config, err
 }
 
-// LoadDefaultConfiguration loads the default configuration file
-func LoadDefaultConfiguration() (*Config, error) {
-	cfg, err := Load(DefaultConfigurationFilePath)
-	if err != nil {
-		if err == ErrConfigFileNotFound {
-			return Load(DefaultFallbackConfigurationFilePath)
+// walkConfigDir is a wrapper for filepath.WalkDir that strips directories and non-config files
+func walkConfigDir(path string, fn fs.WalkDirFunc) error {
+	if len(path) == 0 {
+		// If the user didn't provide a directory, we'll just use the default config file, so we can return nil now.
+		return nil
+	}
+	return filepath.WalkDir(path, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
 		}
-		return nil, err
-	}
-	return cfg, nil
-}
-
-func readConfigurationFile(fileName string) (config *Config, err error) {
-	var bytes []byte
-	if bytes, err = os.ReadFile(fileName); err == nil {
-		// file exists, so we'll parse it and return it
-		return parseAndValidateConfigBytes(bytes)
-	}
-	return
+		if d == nil || d.IsDir() {
+			return nil
+		}
+		ext := filepath.Ext(path)
+		if ext != ".yml" && ext != ".yaml" {
+			return nil
+		}
+		return fn(path, d, err)
+	})
 }
 
 // parseAndValidateConfigBytes parses a Gatus configuration file into a Config struct and validates its parameters
 func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
+	// Replace $$ with __GATUS_LITERAL_DOLLAR_SIGN__ to prevent os.ExpandEnv from treating "$$" as if it was an
+	// environment variable. This allows Gatus to support literal "$" in the configuration file.
+	yamlBytes = []byte(strings.ReplaceAll(string(yamlBytes), "$$", "__GATUS_LITERAL_DOLLAR_SIGN__"))
 	// Expand environment variables
 	yamlBytes = []byte(os.ExpandEnv(string(yamlBytes)))
+	// Replace __GATUS_LITERAL_DOLLAR_SIGN__ with "$" to restore the literal "$" in the configuration file
+	yamlBytes = []byte(strings.ReplaceAll(string(yamlBytes), "__GATUS_LITERAL_DOLLAR_SIGN__", "$"))
 	// Parse configuration file
 	if err = yaml.Unmarshal(yamlBytes, &config); err != nil {
 		return
@@ -191,10 +256,20 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		if err := validateRemoteConfig(config); err != nil {
 			return nil, err
 		}
+		if err := validateConnectivityConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }
 
+func validateConnectivityConfig(config *Config) error {
+	if config.Connectivity != nil {
+		return config.Connectivity.ValidateAndSetDefaults()
+	}
+	return nil
+}
+
 func validateRemoteConfig(config *Config) error {
 	if config.Remote != nil {
 		if err := config.Remote.ValidateAndSetDefaults(); err != nil {
@@ -289,6 +364,7 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 		alert.TypeCustom,
 		alert.TypeDiscord,
 		alert.TypeGitHub,
+		alert.TypeGitLab,
 		alert.TypeGoogleChat,
 		alert.TypeEmail,
 		alert.TypeMatrix,
@@ -297,6 +373,7 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 		alert.TypeNtfy,
 		alert.TypeOpsgenie,
 		alert.TypePagerDuty,
+		alert.TypePushover,
 		alert.TypeSlack,
 		alert.TypeTeams,
 		alert.TypeTelegram,

config/config_test.go

@@ -1,7 +1,10 @@
 package config
 
 import (
+	"errors"
 	"fmt"
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
@@ -11,6 +14,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/custom"
 	"github.com/TwiN/gatus/v5/alerting/provider/discord"
 	"github.com/TwiN/gatus/v5/alerting/provider/email"
+	"github.com/TwiN/gatus/v5/alerting/provider/github"
 	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
 	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
@@ -18,6 +22,7 @@ import (
 	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
 	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
 	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
 	"github.com/TwiN/gatus/v5/alerting/provider/slack"
 	"github.com/TwiN/gatus/v5/alerting/provider/teams"
 	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
@@ -26,20 +31,270 @@ import (
 	"github.com/TwiN/gatus/v5/config/web"
 	"github.com/TwiN/gatus/v5/core"
 	"github.com/TwiN/gatus/v5/storage"
+	"gopkg.in/yaml.v3"
 )
 
-func TestLoadFileThatDoesNotExist(t *testing.T) {
-	_, err := Load("file-that-does-not-exist.yaml")
-	if err == nil {
-		t.Error("Should've returned an error, because the file specified doesn't exist")
+func TestLoadConfiguration(t *testing.T) {
+	dir := t.TempDir()
+	scenarios := []struct {
+		name           string
+		configPath     string            // value to pass as the configPath parameter in LoadConfiguration
+		pathAndFiles   map[string]string // files to create in dir
+		expectedConfig *Config
+		expectedError  error
+	}{
+		{
+			name:       "empty-config-file",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": "",
+			},
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:          "config-file-that-does-not-exist",
+			configPath:    filepath.Join(dir, "config.yaml"),
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:       "config-file-with-endpoint-that-has-no-url",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website`,
+			},
+			expectedError: core.ErrEndpointWithNoURL,
+		},
+		{
+			name:       "config-file-with-endpoint-that-has-no-conditions",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website
+    url: https://twin.sh/health`,
+			},
+			expectedError: core.ErrEndpointWithNoCondition,
+		},
+		{
+			name:       "config-file",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"`,
+			},
+			expectedConfig: &Config{
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "website",
+						URL:        "https://twin.sh/health",
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+				},
+			},
+		},
+		{
+			name:          "empty-dir",
+			configPath:    dir,
+			pathAndFiles:  map[string]string{},
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:       "dir-with-empty-config-file",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"config.yaml": "",
+			},
+			expectedError: ErrNoEndpointInConfig,
+		},
+		{
+			name:       "dir-with-two-config-files",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"config.yaml": `endpoints: 
+  - name: one
+    url: https://example.com
+    conditions:
+      - "[CONNECTED] == true"
+      - "[STATUS] == 200"
+
+  - name: two
+    url: https://example.org
+    conditions:
+      - "len([BODY]) > 0"`,
+				"config.yml": `endpoints: 
+  - name: three
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"`,
+			},
+			expectedConfig: &Config{
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "one",
+						URL:        "https://example.com",
+						Conditions: []core.Condition{"[CONNECTED] == true", "[STATUS] == 200"},
+					},
+					{
+						Name:       "two",
+						URL:        "https://example.org",
+						Conditions: []core.Condition{"len([BODY]) > 0"},
+					},
+					{
+						Name:       "three",
+						URL:        "https://twin.sh/health",
+						Conditions: []core.Condition{"[STATUS] == 200", "[BODY].status == UP"},
+					},
+				},
+			},
+		},
+		{
+			name:       "dir-with-2-config-files-deep-merge-with-map-slice-and-primitive",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"a.yaml": `
+metrics: true
+
+alerting:
+  slack:
+    webhook-url: https://hooks.slack.com/services/xxx/yyy/zzz
+
+endpoints:
+  - name: example
+    url: https://example.org
+    interval: 5s
+    conditions:
+      - "[STATUS] == 200"`,
+				"b.yaml": `
+debug: true
+
+alerting:
+  discord:
+    webhook-url: https://discord.com/api/webhooks/xxx/yyy
+
+endpoints:
+  - name: frontend
+    url: https://example.com
+    conditions:
+      - "[STATUS] == 200"`,
+			},
+			expectedConfig: &Config{
+				Debug:   true,
+				Metrics: true,
+				Alerting: &alerting.Config{
+					Discord: &discord.AlertProvider{WebhookURL: "https://discord.com/api/webhooks/xxx/yyy"},
+					Slack:   &slack.AlertProvider{WebhookURL: "https://hooks.slack.com/services/xxx/yyy/zzz"},
+				},
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "example",
+						URL:        "https://example.org",
+						Interval:   5 * time.Second,
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+					{
+						Name:       "frontend",
+						URL:        "https://example.com",
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+				},
+			},
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			for path, content := range scenario.pathAndFiles {
+				if err := os.WriteFile(filepath.Join(dir, path), []byte(content), 0644); err != nil {
+					t.Fatalf("[%s] failed to write file: %v", scenario.name, err)
+				}
+			}
+			defer func(pathAndFiles map[string]string) {
+				for path := range pathAndFiles {
+					_ = os.Remove(filepath.Join(dir, path))
+				}
+			}(scenario.pathAndFiles)
+			config, err := LoadConfiguration(scenario.configPath)
+			if !errors.Is(err, scenario.expectedError) {
+				t.Errorf("[%s] expected error %v, got %v", scenario.name, scenario.expectedError, err)
+				return
+			} else if err != nil && errors.Is(err, scenario.expectedError) {
+				return
+			}
+			// parse the expected output so that expectations are closer to reality (under the right circumstances, even I can be poetic)
+			expectedConfigAsYAML, _ := yaml.Marshal(scenario.expectedConfig)
+			expectedConfigAfterBeingParsedAndValidated, err := parseAndValidateConfigBytes(expectedConfigAsYAML)
+			if err != nil {
+				t.Fatalf("[%s] failed to parse expected config: %v", scenario.name, err)
+			}
+			// Marshal em' before comparing em' so that we don't have to deal with formatting and ordering
+			actualConfigAsYAML, err := yaml.Marshal(config)
+			if err != nil {
+				t.Fatalf("[%s] failed to marshal actual config: %v", scenario.name, err)
+			}
+			expectedConfigAfterBeingParsedAndValidatedAsYAML, _ := yaml.Marshal(expectedConfigAfterBeingParsedAndValidated)
+			if string(actualConfigAsYAML) != string(expectedConfigAfterBeingParsedAndValidatedAsYAML) {
+				t.Errorf("[%s] expected config %s, got %s", scenario.name, string(expectedConfigAfterBeingParsedAndValidatedAsYAML), string(actualConfigAsYAML))
+			}
+		})
 	}
 }
 
-func TestLoadDefaultConfigurationFile(t *testing.T) {
-	_, err := LoadDefaultConfiguration()
-	if err == nil {
-		t.Error("Should've returned an error, because there's no configuration files at the default path nor the default fallback path")
-	}
+func TestConfig_HasLoadedConfigurationBeenModified(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+
+	configFilePath := filepath.Join(dir, "config.yaml")
+	_ = os.WriteFile(configFilePath, []byte(`endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"
+`), 0644)
+
+	t.Run("config-file-as-config-path", func(t *testing.T) {
+		config, err := LoadConfiguration(configFilePath)
+		if err != nil {
+			t.Fatalf("failed to load configuration: %v", err)
+		}
+		if config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return false because nothing has happened since it was created")
+		}
+		time.Sleep(time.Second) // Because the file mod time only has second precision, we have to wait for a second
+		// Update the config file
+		if err = os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(`endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"`), 0644); err != nil {
+			t.Fatalf("failed to overwrite config file: %v", err)
+		}
+		if !config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return true because a new file has been added in the directory")
+		}
+	})
+	t.Run("config-directory-as-config-path", func(t *testing.T) {
+		config, err := LoadConfiguration(dir)
+		if err != nil {
+			t.Fatalf("failed to load configuration: %v", err)
+		}
+		if config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return false because nothing has happened since it was created")
+		}
+		time.Sleep(time.Second) // Because the file mod time only has second precision, we have to wait for a second
+		// Update the config file
+		if err = os.WriteFile(filepath.Join(dir, "metrics.yaml"), []byte(`metrics: true`), 0644); err != nil {
+			t.Fatalf("failed to overwrite config file: %v", err)
+		}
+		if !config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return true because a new file has been added in the directory")
+		}
+	})
 }
 
 func TestParseAndValidateConfigBytes(t *testing.T) {
@@ -430,6 +685,9 @@ alerting:
     webhook-url: "http://example.org"
   pagerduty:
     integration-key: "00000000000000000000000000000000"
+  pushover:
+    application-token: "000000000000000000000000000000"
+    user-key: "000000000000000000000000000000"
   mattermost:
     webhook-url: "http://example.com"
     client:
@@ -469,6 +727,7 @@ endpoints:
         failure-threshold: 12
         success-threshold: 15
       - type: teams
+      - type: pushover
     conditions:
       - "[STATUS] == 200"
 `))
@@ -495,8 +754,8 @@ endpoints:
 	if config.Endpoints[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Endpoints[0].Alerts) != 8 {
-		t.Fatal("There should've been 8 alerts configured")
+	if len(config.Endpoints[0].Alerts) != 9 {
+		t.Fatal("There should've been 9 alerts configured")
 	}
 
 	if config.Endpoints[0].Alerts[0].Type != alert.TypeSlack {
@@ -596,6 +855,13 @@ endpoints:
 	if config.Endpoints[0].Alerts[7].SuccessThreshold != 2 {
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[7].SuccessThreshold)
 	}
+
+	if config.Endpoints[0].Alerts[8].Type != alert.TypePushover {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePushover, config.Endpoints[0].Alerts[8].Type)
+	}
+	if !config.Endpoints[0].Alerts[8].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlert(t *testing.T) {
@@ -620,6 +886,14 @@ alerting:
       description: default description
       failure-threshold: 7
       success-threshold: 5
+  pushover:
+    application-token: "000000000000000000000000000000"
+    user-key: "000000000000000000000000000000"
+    default-alert:
+      enabled: true
+      description: default description
+      failure-threshold: 5
+      success-threshold: 3
   mattermost:
     webhook-url: "http://example.com"
     default-alert:
@@ -663,6 +937,7 @@ endpoints:
      - type: telegram
      - type: twilio
      - type: teams
+     - type: pushover
    conditions:
      - "[STATUS] == 200"
 `))
@@ -699,6 +974,19 @@ endpoints:
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
 
+	if config.Alerting.Pushover == nil || !config.Alerting.Pushover.IsValid() {
+		t.Fatal("Pushover alerting config should've been valid")
+	}
+	if config.Alerting.Pushover.GetDefaultAlert() == nil {
+		t.Fatal("Pushover.GetDefaultAlert() shouldn't have returned nil")
+	}
+	if config.Alerting.Pushover.ApplicationToken != "000000000000000000000000000000" {
+		t.Errorf("Pushover application token should've been %s, but was %s", "000000000000000000000000000000", config.Alerting.Pushover.ApplicationToken)
+	}
+	if config.Alerting.Pushover.UserKey != "000000000000000000000000000000" {
+		t.Errorf("Pushover user key should've been %s, but was %s", "000000000000000000000000000000", config.Alerting.Pushover.UserKey)
+	}
+
 	if config.Alerting.Mattermost == nil || !config.Alerting.Mattermost.IsValid() {
 		t.Fatal("Mattermost alerting config should've been valid")
 	}
@@ -772,8 +1060,8 @@ endpoints:
 	if config.Endpoints[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Endpoints[0].Alerts) != 8 {
-		t.Fatal("There should've been 8 alerts configured")
+	if len(config.Endpoints[0].Alerts) != 9 {
+		t.Fatal("There should've been 9 alerts configured")
 	}
 
 	if config.Endpoints[0].Alerts[0].Type != alert.TypeSlack {
@@ -877,6 +1165,19 @@ endpoints:
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[7].SuccessThreshold)
 	}
 
+	if config.Endpoints[0].Alerts[8].Type != alert.TypePushover {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePushover, config.Endpoints[0].Alerts[8].Type)
+	}
+	if !config.Endpoints[0].Alerts[8].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Endpoints[0].Alerts[8].FailureThreshold != 5 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Endpoints[0].Alerts[8].FailureThreshold)
+	}
+	if config.Endpoints[0].Alerts[8].SuccessThreshold != 3 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[8].SuccessThreshold)
+	}
+
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlertAndMultipleAlertsOfSameTypeWithOverriddenParameters(t *testing.T) {
@@ -984,6 +1285,32 @@ endpoints:
 		t.Fatal("PagerDuty alerting config should've been set to nil, because its IsValid() method returned false and therefore alerting.Config.SetAlertingProviderToNil() should've been called")
 	}
 }
+func TestParseAndValidateConfigBytesWithInvalidPushoverAlertingConfig(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  pushover:
+    application-token: "INVALID_TOKEN"
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    alerts:
+      - type: pushover
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Pushover != nil {
+		t.Fatal("Pushover alerting config should've been set to nil, because its IsValid() method returned false and therefore alerting.Config.SetAlertingProviderToNil() should've been called")
+	}
+}
 
 func TestParseAndValidateConfigBytesWithCustomAlertingConfig(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
@@ -1012,7 +1339,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1057,7 +1384,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1097,7 +1424,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1207,7 +1534,34 @@ endpoints:
 	}
 }
 
-func TestParseAndValidateConfigBytesWithNoEndpointsOrAutoDiscovery(t *testing.T) {
+func TestParseAndValidateConfigBytesWithLiteralDollarSign(t *testing.T) {
+	os.Setenv("GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign", "whatever")
+	config, err := parseAndValidateConfigBytes([]byte(`
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[BODY] == $$GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign"
+      - "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Endpoints[0].URL != "https://twin.sh/health" {
+		t.Errorf("URL should have been %s", "https://twin.sh/health")
+	}
+	if config.Endpoints[0].Conditions[0] != "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign" {
+		t.Errorf("Condition should have been %s", "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign")
+	}
+	if config.Endpoints[0].Conditions[1] != "[BODY] == whatever" {
+		t.Errorf("Condition should have been %s", "[BODY] == whatever")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithNoEndpoints(t *testing.T) {
 	_, err := parseAndValidateConfigBytes([]byte(``))
 	if err != ErrNoEndpointInConfig {
 		t.Error("The error returned should have been of type ErrNoEndpointInConfig")
@@ -1219,6 +1573,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 		Custom:      &custom.AlertProvider{},
 		Discord:     &discord.AlertProvider{},
 		Email:       &email.AlertProvider{},
+		GitHub:      &github.AlertProvider{},
 		GoogleChat:  &googlechat.AlertProvider{},
 		Matrix:      &matrix.AlertProvider{},
 		Mattermost:  &mattermost.AlertProvider{},
@@ -1226,6 +1581,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 		Ntfy:        &ntfy.AlertProvider{},
 		Opsgenie:    &opsgenie.AlertProvider{},
 		PagerDuty:   &pagerduty.AlertProvider{},
+		Pushover:    &pushover.AlertProvider{},
 		Slack:       &slack.AlertProvider{},
 		Telegram:    &telegram.AlertProvider{},
 		Twilio:      &twilio.AlertProvider{},
@@ -1238,6 +1594,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 		{alertType: alert.TypeCustom, expected: alertingConfig.Custom},
 		{alertType: alert.TypeDiscord, expected: alertingConfig.Discord},
 		{alertType: alert.TypeEmail, expected: alertingConfig.Email},
+		{alertType: alert.TypeGitHub, expected: alertingConfig.GitHub},
 		{alertType: alert.TypeGoogleChat, expected: alertingConfig.GoogleChat},
 		{alertType: alert.TypeMatrix, expected: alertingConfig.Matrix},
 		{alertType: alert.TypeMattermost, expected: alertingConfig.Mattermost},
@@ -1245,6 +1602,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 		{alertType: alert.TypeNtfy, expected: alertingConfig.Ntfy},
 		{alertType: alert.TypeOpsgenie, expected: alertingConfig.Opsgenie},
 		{alertType: alert.TypePagerDuty, expected: alertingConfig.PagerDuty},
+		{alertType: alert.TypePushover, expected: alertingConfig.Pushover},
 		{alertType: alert.TypeSlack, expected: alertingConfig.Slack},
 		{alertType: alert.TypeTelegram, expected: alertingConfig.Telegram},
 		{alertType: alert.TypeTwilio, expected: alertingConfig.Twilio},

config/connectivity/connectivity.go

@@ -0,0 +1,53 @@
+package connectivity
+
+import (
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/TwiN/gatus/v5/client"
+)
+
+var (
+	ErrInvalidInterval  = errors.New("connectivity.checker.interval must be 5s or higher")
+	ErrInvalidDNSTarget = errors.New("connectivity.checker.target must be suffixed with :53")
+)
+
+// Config is the configuration for the connectivity checker.
+type Config struct {
+	Checker *Checker `yaml:"checker,omitempty"`
+}
+
+func (c *Config) ValidateAndSetDefaults() error {
+	if c.Checker != nil {
+		if c.Checker.Interval == 0 {
+			c.Checker.Interval = 60 * time.Second
+		} else if c.Checker.Interval < 5*time.Second {
+			return ErrInvalidInterval
+		}
+		if !strings.HasSuffix(c.Checker.Target, ":53") {
+			return ErrInvalidDNSTarget
+		}
+	}
+	return nil
+}
+
+// Checker is the configuration for making sure Gatus has access to the internet.
+type Checker struct {
+	Target   string        `yaml:"target"` // e.g. 1.1.1.1:53
+	Interval time.Duration `yaml:"interval,omitempty"`
+
+	isConnected bool
+	lastCheck   time.Time
+}
+
+func (c Checker) Check() bool {
+	return client.CanCreateTCPConnection(c.Target, &client.Config{Timeout: 5 * time.Second})
+}
+
+func (c *Checker) IsConnected() bool {
+	if now := time.Now(); now.After(c.lastCheck.Add(c.Interval)) {
+		c.lastCheck, c.isConnected = now, c.Check()
+	}
+	return c.isConnected
+}

config/connectivity/connectivity_test.go

@@ -0,0 +1,62 @@
+package connectivity
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestConfig(t *testing.T) {
+	scenarios := []struct {
+		name             string
+		cfg              *Config
+		expectedErr      error
+		expectedInterval time.Duration
+	}{
+		{
+			name:             "good-config",
+			cfg:              &Config{Checker: &Checker{Target: "1.1.1.1:53", Interval: 10 * time.Second}},
+			expectedInterval: 10 * time.Second,
+		},
+		{
+			name:             "good-config-with-default-interval",
+			cfg:              &Config{Checker: &Checker{Target: "8.8.8.8:53", Interval: 0}},
+			expectedInterval: 60 * time.Second,
+		},
+		{
+			name:        "config-with-interval-too-low",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1:53", Interval: 4 * time.Second}},
+			expectedErr: ErrInvalidInterval,
+		},
+		{
+			name:        "config-with-invalid-target-due-to-missing-port",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1", Interval: 15 * time.Second}},
+			expectedErr: ErrInvalidDNSTarget,
+		},
+		{
+			name:        "config-with-invalid-target-due-to-invalid-dns-port",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1:52", Interval: 15 * time.Second}},
+			expectedErr: ErrInvalidDNSTarget,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			err := scenario.cfg.ValidateAndSetDefaults()
+			if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", scenario.expectedErr) {
+				t.Errorf("expected error %v, got %v", scenario.expectedErr, err)
+			}
+			if err == nil && scenario.expectedErr == nil {
+				if scenario.cfg.Checker.Interval != scenario.expectedInterval {
+					t.Errorf("expected interval %v, got %v", scenario.expectedInterval, scenario.cfg.Checker.Interval)
+				}
+			}
+		})
+	}
+}
+
+func TestChecker_IsConnected(t *testing.T) {
+	checker := &Checker{Target: "1.1.1.1:53", Interval: 10 * time.Second}
+	if !checker.IsConnected() {
+		t.Error("expected checker.IsConnected() to be true")
+	}
+}

config/endpoints/README.md

@@ -0,0 +1 @@
+TODO: move files from core to here.

config/maintenance/maintenance.go

@@ -82,7 +82,7 @@ func (c *Config) ValidateAndSetDefaults() error {
 	if err != nil {
 		return err
 	}
-	if c.Duration <= 0 || c.Duration >= 24*time.Hour {
+	if c.Duration <= 0 || c.Duration > 24*time.Hour {
 		return errInvalidMaintenanceDuration
 	}
 	return nil

config/maintenance/maintenance_test.go

@@ -211,6 +211,14 @@ func TestConfig_IsUnderMaintenance(t *testing.T) {
 			},
 			expected: true,
 		},
+		{
+			name: "under-maintenance-starting-22h-ago-for-24h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", normalizeHour(now.Hour()-22)),
+				Duration: 24 * time.Hour,
+			},
+			expected: true,
+		},
 		{
 			name: "under-maintenance-starting-4h-ago-for-3h",
 			cfg: &Config{
@@ -236,6 +244,15 @@ func TestConfig_IsUnderMaintenance(t *testing.T) {
 			},
 			expected: false,
 		},
+		{
+			name: "not-under-maintenance-today-with-24h-duration",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 24 * time.Hour,
+				Every:    []string{now.Add(48 * time.Hour).Weekday().String()},
+			},
+			expected: false,
+		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.name, func(t *testing.T) {

config/web/web.go

@@ -1,6 +1,8 @@
 package web
 
 import (
+	"crypto/tls"
+	"errors"
 	"fmt"
 	"math"
 )
@@ -21,6 +23,17 @@ type Config struct {
 
 	// Port to listen on (default to 8080 specified by DefaultPort)
 	Port int `yaml:"port"`
+
+	// TLS configuration (optional)
+	TLS *TLSConfig `yaml:"tls,omitempty"`
+}
+
+type TLSConfig struct {
+	// CertificateFile is the public certificate for TLS in PEM format.
+	CertificateFile string `yaml:"certificate-file,omitempty"`
+
+	// PrivateKeyFile is the private key file for TLS in PEM format.
+	PrivateKeyFile string `yaml:"private-key-file,omitempty"`
 }
 
 // GetDefaultConfig returns a Config struct with the default values
@@ -40,10 +53,31 @@ func (web *Config) ValidateAndSetDefaults() error {
 	} else if web.Port < 0 || web.Port > math.MaxUint16 {
 		return fmt.Errorf("invalid port: value should be between %d and %d", 0, math.MaxUint16)
 	}
+	// Try to load the TLS certificates
+	if web.TLS != nil {
+		if err := web.TLS.isValid(); err != nil {
+			return fmt.Errorf("invalid tls config: %w", err)
+		}
+	}
 	return nil
 }
 
+func (web *Config) HasTLS() bool {
+	return web.TLS != nil && len(web.TLS.CertificateFile) > 0 && len(web.TLS.PrivateKeyFile) > 0
+}
+
 // SocketAddress returns the combination of the Address and the Port
 func (web *Config) SocketAddress() string {
 	return fmt.Sprintf("%s:%d", web.Address, web.Port)
 }
+
+func (t *TLSConfig) isValid() error {
+	if len(t.CertificateFile) > 0 && len(t.PrivateKeyFile) > 0 {
+		_, err := tls.LoadX509KeyPair(t.CertificateFile, t.PrivateKeyFile)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+	return errors.New("certificate-file and private-key-file must be specified")
+}

config/web/web_test.go

@@ -12,6 +12,9 @@ func TestGetDefaultConfig(t *testing.T) {
 	if defaultConfig.Address != DefaultAddress {
 		t.Error("expected default config to have the default address")
 	}
+	if defaultConfig.TLS != nil {
+		t.Error("expected default config to have TLS disabled")
+	}
 }
 
 func TestConfig_ValidateAndSetDefaults(t *testing.T) {
@@ -34,6 +37,27 @@ func TestConfig_ValidateAndSetDefaults(t *testing.T) {
 			cfg:         &Config{Port: 100000000},
 			expectedErr: true,
 		},
+		{
+			name:            "with-good-tls-config",
+			cfg:             &Config{Port: 443, TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedAddress: "0.0.0.0",
+			expectedPort:    443,
+			expectedErr:     false,
+		},
+		{
+			name:            "with-bad-tls-config",
+			cfg:             &Config{Port: 443, TLS: &TLSConfig{CertificateFile: "../../testdata/badcert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedAddress: "0.0.0.0",
+			expectedPort:    443,
+			expectedErr:     true,
+		},
+		{
+			name:            "with-partial-tls-config",
+			cfg:             &Config{Port: 443, TLS: &TLSConfig{CertificateFile: "", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedAddress: "0.0.0.0",
+			expectedPort:    443,
+			expectedErr:     true,
+		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.name, func(t *testing.T) {
@@ -63,3 +87,66 @@ func TestConfig_SocketAddress(t *testing.T) {
 		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
 	}
 }
+
+func TestConfig_isValid(t *testing.T) {
+	scenarios := []struct {
+		name        string
+		cfg         *Config
+		expectedErr bool
+	}{
+		{
+			name:        "good-tls-config",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: false,
+		},
+		{
+			name:        "missing-certificate-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "doesnotexist", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-certificate-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/badcert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "no-certificate-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "missing-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "doesnotexist"}},
+			expectedErr: true,
+		},
+		{
+			name:        "no-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: ""}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "../../testdata/badcert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-certificate-and-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/badcert.pem", PrivateKeyFile: "../../testdata/badcert.key"}},
+			expectedErr: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			err := scenario.cfg.ValidateAndSetDefaults()
+			if (err != nil) != scenario.expectedErr {
+				t.Errorf("expected the existence of an error to be %v, got %v", scenario.expectedErr, err)
+				return
+			}
+			if !scenario.expectedErr {
+				if scenario.cfg.TLS.isValid() != nil {
+					t.Error("cfg.TLS.isValid() returned an error even though no error was expected")
+				}
+			}
+		})
+	}
+}

controller/controller.go

@@ -1,47 +1,49 @@
 package controller
 
 import (
-	"context"
-	"fmt"
 	"log"
-	"net/http"
 	"os"
 	"time"
 
+	"github.com/TwiN/gatus/v5/api"
 	"github.com/TwiN/gatus/v5/config"
-	"github.com/TwiN/gatus/v5/controller/handler"
+	"github.com/gofiber/fiber/v2"
 )
 
 var (
-	// server is the http.Server created by Handle.
-	// The only reason it exists is for testing purposes.
-	server *http.Server
+	app *fiber.App
 )
 
 // Handle creates the router and starts the server
 func Handle(cfg *config.Config) {
-	var router http.Handler = handler.CreateRouter(cfg)
-	if os.Getenv("ENVIRONMENT") == "dev" {
-		router = handler.DevelopmentCORS(router)
-	}
-	server = &http.Server{
-		Addr:         fmt.Sprintf("%s:%d", cfg.Web.Address, cfg.Web.Port),
-		Handler:      router,
-		ReadTimeout:  15 * time.Second,
-		WriteTimeout: 15 * time.Second,
-		IdleTimeout:  15 * time.Second,
-	}
-	log.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
+	api := api.New(cfg)
+	app = api.Router()
+	server := app.Server()
+	server.ReadTimeout = 15 * time.Second
+	server.WriteTimeout = 15 * time.Second
+	server.IdleTimeout = 15 * time.Second
 	if os.Getenv("ROUTER_TEST") == "true" {
 		return
 	}
-	log.Println("[controller][Handle]", server.ListenAndServe())
+	log.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
+	if cfg.Web.HasTLS() {
+		err := app.ListenTLS(cfg.Web.SocketAddress(), cfg.Web.TLS.CertificateFile, cfg.Web.TLS.PrivateKeyFile)
+		if err != nil {
+			log.Fatal("[controller][Handle]", err)
+		}
+	} else {
+		err := app.Listen(cfg.Web.SocketAddress())
+		if err != nil {
+			log.Fatal("[controller][Handle]", err)
+		}
+	}
+	log.Println("[controller][Handle] Server has shut down successfully")
 }
 
 // Shutdown stops the server
 func Shutdown() {
-	if server != nil {
-		_ = server.Shutdown(context.TODO())
-		server = nil
+	if app != nil {
+		_ = app.Shutdown()
+		app = nil
 	}
 }

controller/controller_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/TwiN/gatus/v5/config"
 	"github.com/TwiN/gatus/v5/config/web"
 	"github.com/TwiN/gatus/v5/core"
+	"github.com/gofiber/fiber/v2"
 )
 
 func TestHandle(t *testing.T) {
@@ -34,22 +35,68 @@ func TestHandle(t *testing.T) {
 	defer os.Clearenv()
 	Handle(cfg)
 	defer Shutdown()
-	request, _ := http.NewRequest("GET", "/health", http.NoBody)
-	responseRecorder := httptest.NewRecorder()
-	server.Handler.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusOK {
+	request := httptest.NewRequest("GET", "/health", http.NoBody)
+	response, err := app.Test(request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if response.StatusCode != 200 {
 		t.Error("expected GET /health to return status code 200")
 	}
-	if server == nil {
+	if app == nil {
 		t.Fatal("server should've been set (but because we set ROUTER_TEST, it shouldn't have been started)")
 	}
 }
 
+func TestHandleTLS(t *testing.T) {
+	scenarios := []struct {
+		name               string
+		tls                *web.TLSConfig
+		expectedStatusCode int
+	}{
+		{
+			name:               "good-tls-config",
+			tls:                &web.TLSConfig{CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"},
+			expectedStatusCode: 200,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			cfg := &config.Config{
+				Web: &web.Config{Address: "0.0.0.0", Port: rand.Intn(65534), TLS: scenario.tls},
+				Endpoints: []*core.Endpoint{
+					{Name: "frontend", Group: "core"},
+					{Name: "backend", Group: "core"},
+				},
+			}
+			if err := cfg.Web.ValidateAndSetDefaults(); err != nil {
+				t.Error("expected no error from web (TLS) validation, got", err)
+			}
+			_ = os.Setenv("ROUTER_TEST", "true")
+			_ = os.Setenv("ENVIRONMENT", "dev")
+			defer os.Clearenv()
+			Handle(cfg)
+			defer Shutdown()
+			request := httptest.NewRequest("GET", "/health", http.NoBody)
+			response, err := app.Test(request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if response.StatusCode != scenario.expectedStatusCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.expectedStatusCode, response.StatusCode)
+			}
+			if app == nil {
+				t.Fatal("server should've been set (but because we set ROUTER_TEST, it shouldn't have been started)")
+			}
+		})
+	}
+}
+
 func TestShutdown(t *testing.T) {
 	// Pretend that we called controller.Handle(), which initializes the server variable
-	server = &http.Server{}
+	app = fiber.New()
 	Shutdown()
-	if server != nil {
+	if app != nil {
 		t.Error("server should've been shut down")
 	}
 }

controller/handler/config.go

@@ -1,26 +0,0 @@
-package handler
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/TwiN/gatus/v5/security"
-)
-
-// ConfigHandler is a handler that returns information for the front end of the application.
-type ConfigHandler struct {
-	securityConfig *security.Config
-}
-
-func (handler ConfigHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	hasOIDC := false
-	isAuthenticated := true // Default to true if no security config is set
-	if handler.securityConfig != nil {
-		hasOIDC = handler.securityConfig.OIDC != nil
-		isAuthenticated = handler.securityConfig.IsAuthenticated(r)
-	}
-	// Return the config
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write([]byte(fmt.Sprintf(`{"oidc":%v,"authenticated":%v}`, hasOIDC, isAuthenticated)))
-}

controller/handler/cors.go

@@ -1,14 +0,0 @@
-package handler
-
-import "net/http"
-
-func DevelopmentCORS(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Credentials", "true")
-		w.Header().Set("Access-Control-Allow-Origin", "http://localhost:8081")
-		if r.Method == "OPTIONS" {
-			return
-		}
-		next.ServeHTTP(w, r)
-	})
-}

controller/handler/gzip.go

@@ -1,58 +0,0 @@
-package handler
-
-import (
-	"compress/gzip"
-	"io"
-	"net/http"
-	"strings"
-	"sync"
-)
-
-var gzPool = sync.Pool{
-	New: func() interface{} {
-		return gzip.NewWriter(io.Discard)
-	},
-}
-
-type gzipResponseWriter struct {
-	io.Writer
-	http.ResponseWriter
-}
-
-// WriteHeader sends an HTTP response header with the provided status code.
-// It also deletes the Content-Length header, since the GZIP compression may modify the size of the payload
-func (w *gzipResponseWriter) WriteHeader(status int) {
-	w.Header().Del("Content-Length")
-	w.ResponseWriter.WriteHeader(status)
-}
-
-// Write writes len(b) bytes from b to the underlying data stream.
-func (w *gzipResponseWriter) Write(b []byte) (int, error) {
-	return w.Writer.Write(b)
-}
-
-// GzipHandler compresses the response of a given http.Handler if the request's headers specify that the client
-// supports gzip encoding
-func GzipHandler(next http.Handler) http.Handler {
-	return GzipHandlerFunc(func(writer http.ResponseWriter, r *http.Request) {
-		next.ServeHTTP(writer, r)
-	})
-}
-
-// GzipHandlerFunc compresses the response of a given http.HandlerFunc if the request's headers specify that the client
-// supports gzip encoding
-func GzipHandlerFunc(next http.HandlerFunc) http.HandlerFunc {
-	return func(writer http.ResponseWriter, r *http.Request) {
-		// If the request doesn't specify that it supports gzip, then don't compress it
-		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-			next.ServeHTTP(writer, r)
-			return
-		}
-		writer.Header().Set("Content-Encoding", "gzip")
-		gz := gzPool.Get().(*gzip.Writer)
-		defer gzPool.Put(gz)
-		gz.Reset(writer)
-		defer gz.Close()
-		next.ServeHTTP(&gzipResponseWriter{ResponseWriter: writer, Writer: gz}, r)
-	}
-}

controller/handler/handler.go

@@ -1,50 +0,0 @@
-package handler
-
-import (
-	"io/fs"
-	"net/http"
-
-	"github.com/TwiN/gatus/v5/config"
-	static "github.com/TwiN/gatus/v5/web"
-	"github.com/TwiN/health"
-	"github.com/gorilla/mux"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-)
-
-func CreateRouter(cfg *config.Config) *mux.Router {
-	router := mux.NewRouter()
-	if cfg.Metrics {
-		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
-	}
-	api := router.PathPrefix("/api").Subrouter()
-	protected := api.PathPrefix("/").Subrouter()
-	unprotected := api.PathPrefix("/").Subrouter()
-	if cfg.Security != nil {
-		if err := cfg.Security.RegisterHandlers(router); err != nil {
-			panic(err)
-		}
-		if err := cfg.Security.ApplySecurityMiddleware(protected); err != nil {
-			panic(err)
-		}
-	}
-	// Endpoints
-	unprotected.Handle("/v1/config", ConfigHandler{securityConfig: cfg.Security}).Methods("GET")
-	protected.HandleFunc("/v1/endpoints/statuses", EndpointStatuses(cfg)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
-	protected.HandleFunc("/v1/endpoints/{key}/statuses", GzipHandlerFunc(EndpointStatus)).Methods("GET")
-	unprotected.HandleFunc("/v1/endpoints/{key}/health/badge.svg", HealthBadge).Methods("GET")
-	unprotected.HandleFunc("/v1/endpoints/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
-	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge(cfg)).Methods("GET")
-	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
-	// Misc
-	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
-	// SPA
-	router.HandleFunc("/endpoints/{name}", SinglePageApplication(cfg.UI)).Methods("GET")
-	router.HandleFunc("/", SinglePageApplication(cfg.UI)).Methods("GET")
-	// Everything else falls back on static content
-	staticFileSystem, err := fs.Sub(static.FileSystem, static.RootPath)
-	if err != nil {
-		panic(err)
-	}
-	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.FS(staticFileSystem))))
-	return router
-}

controller/handler/handler_test.go

@@ -1,76 +0,0 @@
-package handler
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/TwiN/gatus/v5/config"
-)
-
-func TestCreateRouter(t *testing.T) {
-	router := CreateRouter(&config.Config{Metrics: true})
-	type Scenario struct {
-		Name         string
-		Path         string
-		ExpectedCode int
-		Gzip         bool
-	}
-	scenarios := []Scenario{
-		{
-			Name:         "health",
-			Path:         "/health",
-			ExpectedCode: http.StatusOK,
-		},
-		{
-			Name:         "metrics",
-			Path:         "/metrics",
-			ExpectedCode: http.StatusOK,
-		},
-		{
-			Name:         "favicon.ico",
-			Path:         "/favicon.ico",
-			ExpectedCode: http.StatusOK,
-		},
-		{
-			Name:         "app.js",
-			Path:         "/js/app.js",
-			ExpectedCode: http.StatusOK,
-		},
-		{
-			Name:         "app.js-gzipped",
-			Path:         "/js/app.js",
-			ExpectedCode: http.StatusOK,
-			Gzip:         true,
-		},
-		{
-			Name:         "chunk-vendors.js",
-			Path:         "/js/chunk-vendors.js",
-			ExpectedCode: http.StatusOK,
-		},
-		{
-			Name:         "chunk-vendors.js-gzipped",
-			Path:         "/js/chunk-vendors.js",
-			ExpectedCode: http.StatusOK,
-			Gzip:         true,
-		},
-		{
-			Name:         "index-redirect",
-			Path:         "/index.html",
-			ExpectedCode: http.StatusMovedPermanently,
-		},
-	}
-	for _, scenario := range scenarios {
-		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
-			if scenario.Gzip {
-				request.Header.Set("Accept-Encoding", "gzip")
-			}
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
-			}
-		})
-	}
-}

controller/handler/spa.go

@@ -1,31 +0,0 @@
-package handler
-
-import (
-	_ "embed"
-	"html/template"
-	"log"
-	"net/http"
-
-	"github.com/TwiN/gatus/v5/config/ui"
-	static "github.com/TwiN/gatus/v5/web"
-)
-
-func SinglePageApplication(ui *ui.Config) http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		t, err := template.ParseFS(static.FileSystem, static.IndexPath)
-		if err != nil {
-			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
-			log.Println("[handler][SinglePageApplication] Failed to parse template. This should never happen, because the template is validated on start. Error:", err.Error())
-			http.Error(writer, "Failed to parse template. This should never happen, because the template is validated on start.", http.StatusInternalServerError)
-			return
-		}
-		writer.Header().Set("Content-Type", "text/html")
-		err = t.Execute(writer, ui)
-		if err != nil {
-			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
-			log.Println("[handler][SinglePageApplication] Failed to execute template. This should never happen, because the template is validated on start. Error:", err.Error())
-			http.Error(writer, "Failed to execute template. This should never happen, because the template is validated on start.", http.StatusInternalServerError)
-			return
-		}
-	}
-}

core/condition.go

@@ -11,6 +11,7 @@ import (
 	"github.com/TwiN/gatus/v5/pattern"
 )
 
+// Placeholders
 const (
 	// StatusPlaceholder is a placeholder for a HTTP status.
 	//
@@ -32,7 +33,7 @@ const (
 	// Values that could replace the placeholder: 1, 500, 1000, ...
 	ResponseTimePlaceholder = "[RESPONSE_TIME]"
 
-	// BodyPlaceholder is a placeholder for the body of the response
+	// BodyPlaceholder is a placeholder for the Body of the response
 	//
 	// Values that could replace the placeholder: {}, {"data":{"name":"john"}}, ...
 	BodyPlaceholder = "[BODY]"
@@ -49,7 +50,10 @@ const (
 
 	// DomainExpirationPlaceholder is a placeholder for the duration before the domain expires, in milliseconds.
 	DomainExpirationPlaceholder = "[DOMAIN_EXPIRATION]"
+)
 
+// Functions
+const (
 	// LengthFunctionPrefix is the prefix for the length function
 	//
 	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
@@ -72,7 +76,10 @@ const (
 
 	// FunctionSuffix is the suffix for all functions
 	FunctionSuffix = ")"
+)
 
+// Other constants
+const (
 	// InvalidConditionElementSuffix is the suffix that will be appended to an invalid condition
 	InvalidConditionElementSuffix = "(INVALID)"
 
@@ -225,7 +232,7 @@ func isEqual(first, second string) bool {
 func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
 	parameters := make([]string, len(elements))
 	resolvedParameters := make([]string, len(elements))
-	body := strings.TrimSpace(string(result.body))
+	body := strings.TrimSpace(string(result.Body))
 	for i, element := range elements {
 		element = strings.TrimSpace(element)
 		parameters[i] = element
@@ -259,7 +266,7 @@ func sanitizeAndResolve(elements []string, result *Result) ([]string, []string)
 					checkingForExistence = true
 					element = strings.TrimSuffix(strings.TrimPrefix(element, HasFunctionPrefix), FunctionSuffix)
 				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(strings.TrimPrefix(element, BodyPlaceholder), "."), result.body)
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(strings.TrimPrefix(element, BodyPlaceholder), "."), result.Body)
 				if checkingForExistence {
 					if err != nil {
 						element = "false"
@@ -295,10 +302,18 @@ func sanitizeAndResolveNumerical(list []string, result *Result) (parameters []st
 	parameters, resolvedParameters := sanitizeAndResolve(list, result)
 	for _, element := range resolvedParameters {
 		if duration, err := time.ParseDuration(element); duration != 0 && err == nil {
+			// If the string is a duration, convert it to milliseconds
 			resolvedNumericalParameters = append(resolvedNumericalParameters, duration.Milliseconds())
 		} else if number, err := strconv.ParseInt(element, 10, 64); err != nil {
-			// Default to 0 if the string couldn't be converted to an integer
-			resolvedNumericalParameters = append(resolvedNumericalParameters, 0)
+			// It's not an int, so we'll check if it's a float
+			if f, err := strconv.ParseFloat(element, 64); err == nil {
+				// It's a float, but we'll convert it to an int. We're losing precision here, but it's better than
+				// just returning 0.
+				resolvedNumericalParameters = append(resolvedNumericalParameters, int64(f))
+			} else {
+				// Default to 0 if the string couldn't be converted to an integer or a float
+				resolvedNumericalParameters = append(resolvedNumericalParameters, 0)
+			}
 		} else {
 			resolvedNumericalParameters = append(resolvedNumericalParameters, number)
 		}

core/condition_bench_test.go

@@ -5,7 +5,7 @@ import "testing"
 func BenchmarkCondition_evaluateWithBodyStringAny(b *testing.B) {
 	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -14,7 +14,7 @@ func BenchmarkCondition_evaluateWithBodyStringAny(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyStringAnyFailure(b *testing.B) {
 	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -23,7 +23,7 @@ func BenchmarkCondition_evaluateWithBodyStringAnyFailure(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyString(b *testing.B) {
 	condition := Condition("[BODY].name == john.doe")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -32,7 +32,7 @@ func BenchmarkCondition_evaluateWithBodyString(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyStringFailure(b *testing.B) {
 	condition := Condition("[BODY].name == john.doe")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -41,7 +41,7 @@ func BenchmarkCondition_evaluateWithBodyStringFailure(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyStringFailureInvalidPath(b *testing.B) {
 	condition := Condition("[BODY].user.name == bob.doe")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -50,7 +50,7 @@ func BenchmarkCondition_evaluateWithBodyStringFailureInvalidPath(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyStringLen(b *testing.B) {
 	condition := Condition("len([BODY].name) == 8")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()
@@ -59,7 +59,7 @@ func BenchmarkCondition_evaluateWithBodyStringLen(b *testing.B) {
 func BenchmarkCondition_evaluateWithBodyStringLenFailure(b *testing.B) {
 	condition := Condition("len([BODY].name) == 8")
 	for n := 0; n < b.N; n++ {
-		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result, false)
 	}
 	b.ReportAllocs()

core/condition_test.go

@@ -178,105 +178,140 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "body",
 			Condition:       Condition("[BODY] == test"),
-			Result:          &Result{body: []byte("test")},
+			Result:          &Result{Body: []byte("test")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY] == test",
 		},
+		{
+			Name:            "body-numerical-equal",
+			Condition:       Condition("[BODY] == 123"),
+			Result:          &Result{Body: []byte("123")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == 123",
+		},
+		{
+			Name:            "body-numerical-less-than",
+			Condition:       Condition("[BODY] < 124"),
+			Result:          &Result{Body: []byte("123")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] < 124",
+		},
+		{
+			Name:            "body-numerical-greater-than",
+			Condition:       Condition("[BODY] > 122"),
+			Result:          &Result{Body: []byte("123")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] > 122",
+		},
+		{
+			Name:            "body-numerical-greater-than-failure",
+			Condition:       Condition("[BODY] > 123"),
+			Result:          &Result{Body: []byte("100")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY] (100) > 123",
+		},
 		{
 			Name:            "body-jsonpath",
 			Condition:       Condition("[BODY].status == UP"),
-			Result:          &Result{body: []byte("{\"status\":\"UP\"}")},
+			Result:          &Result{Body: []byte("{\"status\":\"UP\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].status == UP",
 		},
 		{
 			Name:            "body-jsonpath-complex",
 			Condition:       Condition("[BODY].data.name == john"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data.name == john",
 		},
 		{
 			Name:            "body-jsonpath-complex-invalid",
 			Condition:       Condition("[BODY].data.name == john"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1}}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].data.name (INVALID) == john",
 		},
 		{
 			Name:            "body-jsonpath-complex-len-invalid",
 			Condition:       Condition("len([BODY].data.name) == john"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1}}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "len([BODY].data.name) (INVALID) == john",
 		},
 		{
 			Name:            "body-jsonpath-double-placeholder",
 			Condition:       Condition("[BODY].user.firstName != [BODY].user.lastName"),
-			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			Result:          &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].user.firstName != [BODY].user.lastName",
 		},
 		{
 			Name:            "body-jsonpath-double-placeholder-failure",
 			Condition:       Condition("[BODY].user.firstName == [BODY].user.lastName"),
-			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			Result:          &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].user.firstName (john) == [BODY].user.lastName (doe)",
 		},
 		{
 			Name:            "body-jsonpath-when-body-is-array",
 			Condition:       Condition("[BODY][0].id == 1"),
-			Result:          &Result{body: []byte("[{\"id\": 1}, {\"id\": 2}]")},
+			Result:          &Result{Body: []byte("[{\"id\": 1}, {\"id\": 2}]")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY][0].id == 1",
 		},
 		{
 			Name:            "body-jsonpath-when-body-is-array-but-actual-body-is-not",
 			Condition:       Condition("[BODY][0].name == test"),
-			Result:          &Result{body: []byte("{\"statusCode\": 500, \"message\": \"Internal Server Error\"}")},
+			Result:          &Result{Body: []byte("{\"statusCode\": 500, \"message\": \"Internal Server Error\"}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY][0].name (INVALID) == test",
 		},
 		{
 			Name:            "body-jsonpath-complex-int",
 			Condition:       Condition("[BODY].data.id == 1"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data.id == 1",
 		},
 		{
 			Name:            "body-jsonpath-complex-array-int",
 			Condition:       Condition("[BODY].data[1].id == 2"),
-			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			Result:          &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data[1].id == 2",
 		},
 		{
 			Name:            "body-jsonpath-complex-int-using-greater-than",
 			Condition:       Condition("[BODY].data.id > 0"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data.id > 0",
 		},
 		{
 			Name:            "body-jsonpath-complex-int-using-greater-than-failure",
 			Condition:       Condition("[BODY].data.id > 5"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 1}}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].data.id (1) > 5",
 		},
+		{
+			Name:            "body-jsonpath-float-using-greater-than-issue433", // As of v5.3.1, Gatus will convert a float to an int. We're losing precision, but it's better than just returning 0
+			Condition:       Condition("[BODY].balance > 100"),
+			Result:          &Result{Body: []byte(`{"balance": "123.40000000000005"}`)},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].balance > 100",
+		},
 		{
 			Name:            "body-jsonpath-complex-int-using-less-than",
 			Condition:       Condition("[BODY].data.id < 5"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 2}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 2}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data.id < 5",
 		},
 		{
 			Name:            "body-jsonpath-complex-int-using-less-than-failure",
 			Condition:       Condition("[BODY].data.id < 5"),
-			Result:          &Result{body: []byte("{\"data\": {\"id\": 10}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"id\": 10}}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].data.id (10) < 5",
 		},
@@ -343,84 +378,84 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "len-body-jsonpath-complex",
 			Condition:       Condition("len([BODY].data.name) == 4"),
-			Result:          &Result{body: []byte("{\"data\": {\"name\": \"john\"}}")},
+			Result:          &Result{Body: []byte("{\"data\": {\"name\": \"john\"}}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY].data.name) == 4",
 		},
 		{
 			Name:            "len-body-array",
 			Condition:       Condition("len([BODY]) == 3"),
-			Result:          &Result{body: []byte("[{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]")},
+			Result:          &Result{Body: []byte("[{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY]) == 3",
 		},
 		{
 			Name:            "len-body-keyed-array",
 			Condition:       Condition("len([BODY].data) == 3"),
-			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			Result:          &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY].data) == 3",
 		},
 		{
 			Name:            "len-body-array-invalid",
 			Condition:       Condition("len([BODY].data) == 8"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "len([BODY].data) (INVALID) == 8",
 		},
 		{
 			Name:            "len-body-string",
 			Condition:       Condition("len([BODY]) == 8"),
-			Result:          &Result{body: []byte("john.doe")},
+			Result:          &Result{Body: []byte("john.doe")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY]) == 8",
 		},
 		{
 			Name:            "len-body-keyed-string",
 			Condition:       Condition("len([BODY].name) == 8"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY].name) == 8",
 		},
 		{
 			Name:            "len-body-keyed-int",
 			Condition:       Condition("len([BODY].age) == 2"),
-			Result:          &Result{body: []byte(`{"age":18}`)},
+			Result:          &Result{Body: []byte(`{"age":18}`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY].age) == 2",
 		},
 		{
 			Name:            "len-body-keyed-bool",
 			Condition:       Condition("len([BODY].adult) == 4"),
-			Result:          &Result{body: []byte(`{"adult":true}`)},
+			Result:          &Result{Body: []byte(`{"adult":true}`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY].adult) == 4",
 		},
 		{
 			Name:            "len-body-object-inside-array",
 			Condition:       Condition("len([BODY][0]) == 23"),
-			Result:          &Result{body: []byte(`[{"age":18,"adult":true}]`)},
+			Result:          &Result{Body: []byte(`[{"age":18,"adult":true}]`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY][0]) == 23",
 		},
 		{
 			Name:            "len-body-object-keyed-int-inside-array",
 			Condition:       Condition("len([BODY][0].age) == 2"),
-			Result:          &Result{body: []byte(`[{"age":18,"adult":true}]`)},
+			Result:          &Result{Body: []byte(`[{"age":18,"adult":true}]`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY][0].age) == 2",
 		},
 		{
 			Name:            "len-body-keyed-bool-inside-array",
 			Condition:       Condition("len([BODY][0].adult) == 4"),
-			Result:          &Result{body: []byte(`[{"age":18,"adult":true}]`)},
+			Result:          &Result{Body: []byte(`[{"age":18,"adult":true}]`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY][0].adult) == 4",
 		},
 		{
 			Name:            "len-body-object",
 			Condition:       Condition("len([BODY]) == 20"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "len([BODY]) == 20",
 		},
@@ -428,49 +463,49 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "pat-body-1",
 			Condition:       Condition("[BODY] == pat(*john*)"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY] == pat(*john*)",
 		},
 		{
 			Name:            "pat-body-2",
 			Condition:       Condition("[BODY].name == pat(john*)"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].name == pat(john*)",
 		},
 		{
 			Name:            "pat-body-failure",
 			Condition:       Condition("[BODY].name == pat(bob*)"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].name (john.doe) == pat(bob*)",
 		},
 		{
 			Name:            "pat-body-html",
 			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
-			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">john.doe</div></body></html>`)},
+			Result:          &Result{Body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">john.doe</div></body></html>`)},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY] == pat(*<div id=\"user\">john.doe</div>*)",
 		},
 		{
 			Name:            "pat-body-html-failure",
 			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
-			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			Result:          &Result{Body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY] (<!DOCTYPE html><html lang...(truncated)) == pat(*<div id=\"user\">john.doe</div>*)",
 		},
 		{
 			Name:            "pat-body-html-failure-alt",
 			Condition:       Condition("pat(*<div id=\"user\">john.doe</div>*) == [BODY]"),
-			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			Result:          &Result{Body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "pat(*<div id=\"user\">john.doe</div>*) == [BODY] (<!DOCTYPE html><html lang...(truncated))",
 		},
 		{
 			Name:            "pat-body-in-array",
 			Condition:       Condition("[BODY].data == pat(*Whatever*)"),
-			Result:          &Result{body: []byte("{\"data\": [\"hello\", \"world\", \"Whatever\"]}")},
+			Result:          &Result{Body: []byte("{\"data\": [\"hello\", \"world\", \"Whatever\"]}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].data == pat(*Whatever*)",
 		},
@@ -506,21 +541,21 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "any-body-1",
 			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
-			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"john.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
 		},
 		{
 			Name:            "any-body-2",
 			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
-			Result:          &Result{body: []byte("{\"name\": \"jane.doe\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"jane.doe\"}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
 		},
 		{
 			Name:            "any-body-failure",
 			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
-			Result:          &Result{body: []byte("{\"name\": \"bob\"}")},
+			Result:          &Result{Body: []byte("{\"name\": \"bob\"}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "[BODY].name (bob) == any(john.doe, jane.doe)",
 		},
@@ -564,14 +599,14 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "has",
 			Condition:       Condition("has([BODY].errors) == false"),
-			Result:          &Result{body: []byte("{}")},
+			Result:          &Result{Body: []byte("{}")},
 			ExpectedSuccess: true,
 			ExpectedOutput:  "has([BODY].errors) == false",
 		},
 		{
 			Name:                        "has-key-of-map",
 			Condition:                   Condition("has([BODY].article) == true"),
-			Result:                      &Result{body: []byte("{\n  \"article\": {\n    \"id\": 123,\n    \"title\": \"Hello, world!\",\n    \"author\": \"John Doe\",\n    \"tags\": [\"hello\", \"world\"],\n    \"content\": \"I really like Gatus!\"\n  }\n}")},
+			Result:                      &Result{Body: []byte("{\n  \"article\": {\n    \"id\": 123,\n    \"title\": \"Hello, world!\",\n    \"author\": \"John Doe\",\n    \"tags\": [\"hello\", \"world\"],\n    \"content\": \"I really like Gatus!\"\n  }\n}")},
 			DontResolveFailedConditions: false,
 			ExpectedSuccess:             true,
 			ExpectedOutput:              "has([BODY].article) == true",
@@ -579,14 +614,14 @@ func TestCondition_evaluate(t *testing.T) {
 		{
 			Name:            "has-failure",
 			Condition:       Condition("has([BODY].errors) == false"),
-			Result:          &Result{body: []byte("{\"errors\": [\"1\"]}")},
+			Result:          &Result{Body: []byte("{\"errors\": [\"1\"]}")},
 			ExpectedSuccess: false,
 			ExpectedOutput:  "has([BODY].errors) (true) == false",
 		},
 		{
 			Name:                        "has-failure-but-dont-resolve",
 			Condition:                   Condition("has([BODY].errors) == false"),
-			Result:                      &Result{body: []byte("{\"errors\": [\"1\"]}")},
+			Result:                      &Result{Body: []byte("{\"errors\": [\"1\"]}")},
 			DontResolveFailedConditions: true,
 			ExpectedSuccess:             false,
 			ExpectedOutput:              "has([BODY].errors) == false",

core/dns.go

@@ -61,26 +61,26 @@ func (d *DNS) query(url string, result *Result) {
 		switch rr.Header().Rrtype {
 		case dns.TypeA:
 			if a, ok := rr.(*dns.A); ok {
-				result.body = []byte(a.A.String())
+				result.Body = []byte(a.A.String())
 			}
 		case dns.TypeAAAA:
 			if aaaa, ok := rr.(*dns.AAAA); ok {
-				result.body = []byte(aaaa.AAAA.String())
+				result.Body = []byte(aaaa.AAAA.String())
 			}
 		case dns.TypeCNAME:
 			if cname, ok := rr.(*dns.CNAME); ok {
-				result.body = []byte(cname.Target)
+				result.Body = []byte(cname.Target)
 			}
 		case dns.TypeMX:
 			if mx, ok := rr.(*dns.MX); ok {
-				result.body = []byte(mx.Mx)
+				result.Body = []byte(mx.Mx)
 			}
 		case dns.TypeNS:
 			if ns, ok := rr.(*dns.NS); ok {
-				result.body = []byte(ns.Ns)
+				result.Body = []byte(ns.Ns)
 			}
 		default:
-			result.body = []byte("query type is not supported yet")
+			result.Body = []byte("query type is not supported yet")
 		}
 	}
 }

core/dns_test.go

@@ -90,12 +90,12 @@ func TestIntegrationQuery(t *testing.T) {
 			}
 			if test.inputDNS.QueryType == "NS" {
 				// Because there are often multiple nameservers backing a single domain, we'll only look at the suffix
-				if !pattern.Match(test.expectedBody, string(result.body)) {
-					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				if !pattern.Match(test.expectedBody, string(result.Body)) {
+					t.Errorf("got %s, expected result %s,", string(result.Body), test.expectedBody)
 				}
 			} else {
-				if string(result.body) != test.expectedBody {
-					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				if string(result.Body) != test.expectedBody {
+					t.Errorf("got %s, expected result %s,", string(result.Body), test.expectedBody)
 				}
 			}
 		})

core/endpoint.go

@@ -280,8 +280,6 @@ func (endpoint *Endpoint) EvaluateHealth() *Result {
 		}
 	}
 	result.Timestamp = time.Now()
-	// No need to keep the body after the endpoint has been evaluated
-	result.body = nil
 	// Clean up parameters that we don't need to keep in the results
 	if endpoint.UIConfig.HideURL {
 		for errIdx, errorString := range result.Errors {
@@ -356,9 +354,9 @@ func (endpoint *Endpoint) call(result *Result) {
 		}
 		result.HTTPStatus = response.StatusCode
 		result.Connected = response.StatusCode > 0
-		// Only read the body if there's a condition that uses the BodyPlaceholder
+		// Only read the Body if there's a condition that uses the BodyPlaceholder
 		if endpoint.needsToReadBody() {
-			result.body, err = io.ReadAll(response.Body)
+			result.Body, err = io.ReadAll(response.Body)
 			if err != nil {
 				result.AddError("error reading response body:" + err.Error())
 			}
@@ -387,7 +385,7 @@ func (endpoint *Endpoint) buildHTTPRequest() *http.Request {
 	return request
 }
 
-// needsToReadBody checks if there's any condition that requires the response body to be read
+// needsToReadBody checks if there's any condition that requires the response Body to be read
 func (endpoint *Endpoint) needsToReadBody() bool {
 	for _, condition := range endpoint.Conditions {
 		if condition.hasBodyPlaceholder() {

core/result.go

@@ -44,12 +44,11 @@ type Result struct {
 	// DomainExpiration is the duration before the domain expires
 	DomainExpiration time.Duration `json:"-"`
 
-	// body is the response body
+	// Body is the response body
 	//
-	// Note that this variable is only used during the evaluation of an Endpoint's health.
-	// This means that the call Endpoint.EvaluateHealth both populates the body (if necessary)
-	// and sets it to nil after the evaluation has been completed.
-	body []byte
+	// Note that this field is not persisted in the storage.
+	// It is used for health evaluation as well as debugging purposes.
+	Body []byte `json:"-"`
 }
 
 // AddError adds an error to the result's list of errors.

go.mod

@@ -1,63 +1,75 @@
 module github.com/TwiN/gatus/v5
 
-go 1.19
+go 1.20
 
 require (
-	github.com/TwiN/g8 v1.4.0
+	github.com/TwiN/deepmerge v0.2.0
+	github.com/TwiN/g8/v2 v2.0.0
 	github.com/TwiN/gocache/v2 v2.2.0
-	github.com/TwiN/health v1.5.0
-	github.com/TwiN/whois v1.1.0
-	github.com/coreos/go-oidc/v3 v3.4.0
-	github.com/go-ping/ping v0.0.0-20210911151512-381826476871
-	github.com/google/uuid v1.3.0
-	github.com/gorilla/mux v1.8.0
-	github.com/lib/pq v1.10.7
-	github.com/miekg/dns v1.1.50
-	github.com/prometheus/client_golang v1.14.0
-	github.com/wcharczuk/go-chart/v2 v2.1.0
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
-	golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094
-	gopkg.in/mail.v2 v2.3.1
-	gopkg.in/yaml.v2 v2.4.0
-	modernc.org/sqlite v1.19.5
-)
-
-require (
+	github.com/TwiN/health v1.6.0
+	github.com/TwiN/whois v1.1.3
+	github.com/coreos/go-oidc/v3 v3.6.0
+	github.com/gofiber/fiber/v2 v2.46.0
 	github.com/google/go-github/v48 v48.2.0
-	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/google/uuid v1.3.0
+	github.com/ishidawataru/sctp v0.0.0-20210707070123-9a39160e9062
+	github.com/lib/pq v1.10.7
+	github.com/miekg/dns v1.1.54
+	github.com/prometheus-community/pro-bing v0.2.0
+	github.com/prometheus/client_golang v1.16.0
+	github.com/valyala/fasthttp v1.48.0
+	github.com/wcharczuk/go-chart/v2 v2.1.0
+	golang.org/x/crypto v0.10.0
+	golang.org/x/oauth2 v0.8.0
+	gopkg.in/mail.v2 v2.3.1
+	gopkg.in/yaml.v3 v3.0.1
+	modernc.org/sqlite v1.23.1
 )
 
 require (
+	github.com/andybalholm/brotli v1.0.5 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/go-jose/go-jose/v3 v3.0.0 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/ishidawataru/sctp v0.0.0-20210707070123-9a39160e9062
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/mattn/go-isatty v0.0.16 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
+	github.com/klauspost/compress v1.16.5 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
+	github.com/philhofer/fwd v1.1.2 // indirect
 	github.com/prometheus/client_model v0.3.0 // indirect
-	github.com/prometheus/common v0.37.0 // indirect
-	github.com/prometheus/procfs v0.8.0 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
-	golang.org/x/mod v0.5.1 // indirect
-	golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b // indirect
-	golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f // indirect
-	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
-	golang.org/x/tools v0.1.7 // indirect
-	golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f // indirect
+	github.com/prometheus/common v0.42.0 // indirect
+	github.com/prometheus/procfs v0.10.1 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
+	github.com/rogpeppe/go-internal v1.11.0 // indirect
+	github.com/savsgio/dictpool v0.0.0-20221023140959-7bf2e61cea94 // indirect
+	github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee // indirect
+	github.com/tinylib/msgp v1.1.8 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/tcplisten v1.0.0 // indirect
+	golang.org/x/image v0.5.0 // indirect
+	golang.org/x/mod v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sync v0.2.0 // indirect
+	golang.org/x/sys v0.9.0 // indirect
+	golang.org/x/tools v0.4.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
-	gopkg.in/square/go-jose.v2 v2.6.0 // indirect
 	lukechampine.com/uint128 v1.2.0 // indirect
 	modernc.org/cc/v3 v3.40.0 // indirect
 	modernc.org/ccgo/v3 v3.16.13 // indirect
-	modernc.org/libc v1.21.5 // indirect
+	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
-	modernc.org/memory v1.4.0 // indirect
+	modernc.org/memory v1.5.0 // indirect
 	modernc.org/opt v0.1.3 // indirect
 	modernc.org/strutil v1.1.3 // indirect
 	modernc.org/token v1.0.1 // indirect

go.sum

@@ -1,806 +1,196 @@
-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 v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
-cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
-cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
-cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
-cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
-cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY=
-cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM=
-cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY=
-cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
-cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
-cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
-cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
-cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
-cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A=
-cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc=
-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/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow=
-cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM=
-cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M=
-cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s=
-cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU=
-cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U=
-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/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY=
-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=
-cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
-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/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/TwiN/g8 v1.4.0 h1:RUk5xTtxKCdMo0GGSbBVyjtAAfi2nqVbA9E0C4u5Cxo=
-github.com/TwiN/g8 v1.4.0/go.mod h1:ECyGJsoIb99klUfvVQoS1StgRLte9yvvPigGrHdy284=
+github.com/TwiN/deepmerge v0.2.0 h1:8P1tp2qDXllX6V1Ailg2XA074easAcvLMmW9v1jn0aE=
+github.com/TwiN/deepmerge v0.2.0/go.mod h1:cR9OWsvI13y+FxrbnPLuF6BX2tbYeOjkiI6JWjEGqAE=
+github.com/TwiN/g8/v2 v2.0.0 h1:+hwIbRLMhDd2iwHzkZUPp2FkX7yTx8ddYOnS91HkDqQ=
+github.com/TwiN/g8/v2 v2.0.0/go.mod h1:4sVAF27q8T8ISggRa/Fb0drw7wpB22B6eWd+/+SGMqE=
 github.com/TwiN/gocache/v2 v2.2.0 h1:M3B36KyH24BntxLrLaUb2kgTdq8DzCnfod0IekLG57w=
 github.com/TwiN/gocache/v2 v2.2.0/go.mod h1:SnUuBsrwGQeNcDG6vhkOMJnqErZM0JGjgIkuKryokYA=
-github.com/TwiN/health v1.5.0 h1:ETTtbQfUbiiIiVTSpAiNzesHQvm8qarV/8ctlZsVhwA=
-github.com/TwiN/health v1.5.0/go.mod h1:Z6TszwQPMvtSiVx1QMidVRgvVr4KZGfiwqcD7/Z+3iw=
-github.com/TwiN/whois v1.1.0 h1:lhyrC/9yIXntEnbJ+0IBy9Z5NBcreieYyamlvniwq88=
-github.com/TwiN/whois v1.1.0/go.mod h1:9WbCzYlR+r5eq9vbgJVh7A4H2uR2ct4wKEB0/QITJ/c=
-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/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-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/TwiN/health v1.6.0 h1:L2ks575JhRgQqWWOfKjw9B0ec172hx7GdToqkYUycQM=
+github.com/TwiN/health v1.6.0/go.mod h1:Z6TszwQPMvtSiVx1QMidVRgvVr4KZGfiwqcD7/Z+3iw=
+github.com/TwiN/whois v1.1.3 h1:DOexOmaCGuPCzzjcykE5MQQEiVawHHIIhVRyPUxbvWg=
+github.com/TwiN/whois v1.1.3/go.mod h1:VOJAH4+3chAik5gva5zxJNXv2voEHjMNCf1y07sqj9w=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 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 v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-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/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/coreos/go-oidc/v3 v3.4.0 h1:xz7elHb/LDwm/ERpwHd+5nb7wFHL32rsr6bBOgaeu6g=
-github.com/coreos/go-oidc/v3 v3.4.0/go.mod h1:eHUXhZtXPQLgEaDrOVTgwbgmz1xGOkJNye6h3zkD2Pw=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/coreos/go-oidc/v3 v3.6.0 h1:AKVxfYw1Gmkn/w96z0DbT/B/xFnzTd3MkZvWLjF4n/o=
+github.com/coreos/go-oidc/v3 v3.6.0/go.mod h1:ZpHUsHBucTUj6WOkrP4E20UPynbLZzhTQ1XKCXkxyPc=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
-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/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
-github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-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-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
-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-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
-github.com/go-ping/ping v0.0.0-20210911151512-381826476871 h1:wtjTfjwAR/BYYMJ+QOLI/3J/qGEI0fgrkZvgsEWK2/Q=
-github.com/go-ping/ping v0.0.0-20210911151512-381826476871/go.mod h1:xIFjORFzTxqIV/tDVGO4eDy/bLuSyawEeojSm3GfRGk=
-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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/go-jose/go-jose/v3 v3.0.0 h1:s6rrhirfEP/CGIoc6p+PZAeogN2SxKav6Wp7+dyMWVo=
+github.com/go-jose/go-jose/v3 v3.0.0/go.mod h1:RNkWWRld676jZEYoV3+XK8L2ZnNSvIsxFMht0mSX+u8=
+github.com/gofiber/fiber/v2 v2.46.0 h1:wkkWotblsGVlLjXj2dpgKQAYHtXumsK/HyFugQM68Ns=
+github.com/gofiber/fiber/v2 v2.46.0/go.mod h1:DNl0/c37WLe0g92U6lx1VMQuxGUQY5V7EIaVoEsUffc=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
-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/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
-github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 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.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
-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/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-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/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 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.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.3/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/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
-github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-github/v48 v48.2.0 h1:68puzySE6WqUY9KWmpOsDEQfDZsso98rT6pZcz9HqcE=
 github.com/google/go-github/v48 v48.2.0/go.mod h1:dDlehKBDo850ZPvCTK0sEqTCVWcrGl2LcDiajkYi89Y=
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
-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/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
-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/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
-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/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
-github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
-github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM=
-github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM=
-github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c=
-github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4=
-github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
-github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-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/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/ishidawataru/sctp v0.0.0-20210707070123-9a39160e9062 h1:G1+wBT0dwjIrBdLy0MIG0i+E4CQxEnedHXdauJEIH6g=
 github.com/ishidawataru/sctp v0.0.0-20210707070123-9a39160e9062/go.mod h1:co9pwDoBCm1kGxawmb4sPq0cSIOOWNPT4KnHotMP1Zg=
-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/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-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/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI=
+github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
 github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peKQ=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI=
-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/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
-github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
-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/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
+github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
+github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
+github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
+github.com/miekg/dns v1.1.54 h1:5jon9mWcb0sFJGpnI99tOMhCPyJ+RPVz5b63MQG0VWI=
+github.com/miekg/dns v1.1.54/go.mod h1:uInx36IzPl7FYnDcMeVWxj9byh7DutNykX4G9Sj60FY=
+github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
+github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw=
+github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0=
 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.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
-github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
-github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
-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/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus-community/pro-bing v0.2.0 h1:hyK7yPFndU3LCDwEQJwPQUCjNkp1DGP/VxyzrWfXZUU=
+github.com/prometheus-community/pro-bing v0.2.0/go.mod h1:20arNb2S8rNG3EtmjHyZZU92cfbhQx7oCHZ9sulAV+I=
+github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
+github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc=
 github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4=
 github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w=
-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/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE=
-github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
-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/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
-github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
+github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM=
+github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc=
+github.com/prometheus/procfs v0.10.1 h1:kYK1Va/YMlutzCGazswoHKo//tZVlFpKYh+PymziUAg=
+github.com/prometheus/procfs v0.10.1/go.mod h1:nwNm2aOCAYw8uTR/9bWRREkZFxAUcWzPHWJq+XBB/FM=
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-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/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/savsgio/dictpool v0.0.0-20221023140959-7bf2e61cea94 h1:rmMl4fXJhKMNWl+K+r/fq4FbbKI+Ia2m9hYBLm2h4G4=
+github.com/savsgio/dictpool v0.0.0-20221023140959-7bf2e61cea94/go.mod h1:90zrgN3D/WJsDd1iXHT96alCoN2KJo6/4x1DZC3wZs8=
+github.com/savsgio/gotils v0.0.0-20220530130905-52f3993e8d6d/go.mod h1:Gy+0tqhJvgGlqnTF8CVGP0AaGRjwBtXs/a5PA0Y3+A4=
+github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee h1:8Iv5m6xEo1NR1AvpV+7XmhI4r39LGNzwUL4YpMuL5vk=
+github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee/go.mod h1:qwtSXrKuJh/zsFQ12yEE89xfCrGKK63Rr7ctU/uCo4g=
 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.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/tinylib/msgp v1.1.6/go.mod h1:75BAfg2hauQhs3qedfdDZmWAPcFMAvJE5b9rGOMufyw=
+github.com/tinylib/msgp v1.1.8 h1:FCXC1xanKO4I8plpHGH2P7koL/RzZs12l/+r7vakfm0=
+github.com/tinylib/msgp v1.1.8/go.mod h1:qkpG+2ldGg4xRFmx+jfTvZPxfGFhi64BcnL9vkCm/Tw=
+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.48.0 h1:oJWvHb9BIZToTQS3MuQ2R3bJZiNSa2KiNdeI8A+79Tc=
+github.com/valyala/fasthttp v1.48.0/go.mod h1:k2zXd82h/7UZc3VOdJ2WaUqt1uZ/XpXAfE9i+HBC3lA=
+github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
+github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
 github.com/wcharczuk/go-chart/v2 v2.1.0 h1:tY2slqVQ6bN+yHSnDYwZebLQFkphK4WNrVwnt7CJZ2I=
 github.com/wcharczuk/go-chart/v2 v2.1.0/go.mod h1:yx7MvAVNcP/kN9lKXM/NTce4au4DFN99j6i1OwDclNA=
-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.2.1/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.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
-go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
-go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 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-20190911031432-227b76d455e7/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-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-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/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.10.0 h1:LKqV2xt9+kDzSTfOhx4FrkEBcMrAgHSYgzywV9zcGmM=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
 golang.org/x/image v0.0.0-20200927104501-e162460cd6b5/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
-golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
-golang.org/x/lint v0.0.0-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/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/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/image v0.5.0 h1:5JMiNunQeQw++mMOz48/ISeNu3Iweh/JaZU8ZLqHRrI=
+golang.org/x/image v0.5.0/go.mod h1:FVC7BI/5Ym8R25iw5OLsgshdUBbT1h5jZTpA+mvAdZ4=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
-golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-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/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.9.0 h1:KENHtAZL2y3NLMYZeHY9DW8HW8V+kQyJsY/V9JlKvCs=
+golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 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-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b h1:ZmngSVLe/wycRns9MKikG9OWIEjGcGAkacif7oYQaUY=
-golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
-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-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
-golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
-golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
-golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
-golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094 h1:2o1E+E8TpNLklK9nHiPiK1uzIYrIHt+cQx3ynCwq9V8=
-golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
-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/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.3.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8=
+golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE=
 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-20201020160332-67f06af15bc9/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/sync v0.0.0-20220601150217-0de741cfad7f h1:Ax0t5p6N38Ga0dThY21weqDEyz2oklo4IvDkpigvkD8=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/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/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
+golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-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-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-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/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-20210514084401-e8d321eab015/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-20210603125802-9665404d3644/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-20210616094352-59db8d763f22/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-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211210111614-af8b64212486/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-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
+golang.org/x/sys v0.9.0/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/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 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.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5/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/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 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.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
-golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
-golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.7 h1:6j8CgantCy3yc8JGBqkDLMKWqZ0RDU2g1HVgacojGWQ=
-golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
+golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.4.0 h1:7mTAgkunk3fr4GAloyyCasadO6h9zSsQZbwvcaIciV4=
+golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
 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/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
-golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f h1:uF6paiQQebLeSXkrTqHqz0MXhXXS1KgF41eUdBNvxK0=
-golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
-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/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
-google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
-google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
-google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU=
-google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94=
-google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo=
-google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4=
-google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw=
-google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU=
-google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k=
-google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
-google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
-google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
-google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
-google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo=
-google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g=
-google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA=
-google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8=
-google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs=
-google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
-google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw=
-google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg=
-google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o=
-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/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/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-20200513103714-09dca8ec2884/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/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
-google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
-google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
-google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
-google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
-google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
-google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
-google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
-google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
-google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
-google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
-google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w=
-google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
-google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
-google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
-google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
-google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
-google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
-google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
-google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
-google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
-google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
-google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
-google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
-google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
-google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
-google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
-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/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
-google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
-google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
-google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
-google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
-google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
-google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
-google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
-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/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
 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/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/mail.v2 v2.3.1 h1:WYFn/oANrAGP2C0dcV6/pbkPzv8yGzqTjPmTeO7qoXk=
 gopkg.in/mail.v2 v2.3.1/go.mod h1:htwXN1Qh09vZJ1NVKxQqHPBaCBbzKhp5GzuJEA4VJWw=
-gopkg.in/square/go-jose.v2 v2.6.0 h1:NGk74WTnPKBNUhNzQX7PYcTLUjoq7mzKk2OKbvwk2iI=
-gopkg.in/square/go-jose.v2 v2.6.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
-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.3/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.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 h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/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=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
 lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
 modernc.org/cc/v3 v3.40.0 h1:P3g79IUS/93SYhtoeaHW+kRCIrYaxJ27MFPv+7kaTOw=
@@ -809,22 +199,19 @@ modernc.org/ccgo/v3 v3.16.13 h1:Mkgdzl46i5F/CNR/Kj80Ri59hC8TKAhZrYSaqvkwzUw=
 modernc.org/ccgo/v3 v3.16.13/go.mod h1:2Quk+5YgpImhPjv2Qsob1DnZ/4som1lJTodubIcoUkY=
 modernc.org/ccorpus v1.11.6 h1:J16RXiiqiCgua6+ZvQot4yUuUy8zxgqbqEEUuGPlISk=
 modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM=
-modernc.org/libc v1.21.5 h1:xBkU9fnHV+hvZuPSRszN0AXDG4M7nwPLwTWwkYcvLCI=
-modernc.org/libc v1.21.5/go.mod h1:przBsL5RDOZajTVslkugzLBj1evTue36jEomFQOoYuI=
+modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
+modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
 modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
 modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
-modernc.org/memory v1.4.0 h1:crykUfNSnMAXaOJnnxcSzbUGMqkLWjklJKkBK2nwZwk=
-modernc.org/memory v1.4.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
+modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
+modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
 modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4=
 modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
-modernc.org/sqlite v1.19.5 h1:E3iHL55c1Vw1knqIeU9N7B0fSjuiOjHZo7iVMsO6U5U=
-modernc.org/sqlite v1.19.5/go.mod h1:EsYz8rfOvLCiYTy5ZFsOYzoCcRMu98YYkwAcCw5YIYw=
+modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM=
+modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk=
 modernc.org/strutil v1.1.3 h1:fNMm+oJklMGYfU9Ylcywl0CO5O6nTfaowNsh2wpPjzY=
 modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw=
-modernc.org/tcl v1.15.0 h1:oY+JeD11qVVSgVvodMJsu7Edf8tr5E/7tuhF5cNYz34=
+modernc.org/tcl v1.15.2 h1:C4ybAYCGJw968e+Me18oW55kD/FexcHbqH2xak1ROSY=
 modernc.org/token v1.0.1 h1:A3qvTqOwexpfZZeyI0FeGPDlSWX5pjZu9hF4lU+EKWg=
 modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
-modernc.org/z v1.7.0 h1:xkDw/KepgEjeizO2sNco+hqYkU12taxQFqPEmgm1GWE=
-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=
+modernc.org/z v1.7.3 h1:zDJf6iHjrnB+WRD88stbXokugjyc0/pB91ri1gO6LZY=

jsonpath/jsonpath_test.go

@@ -158,6 +158,22 @@ func TestEval(t *testing.T) {
 			ExpectedOutputLength: 0,
 			ExpectedError:        true,
 		},
+		{
+			Name:                 "float-as-string",
+			Path:                 "balance",
+			Data:                 `{"balance": "123.40000000000005"}`,
+			ExpectedOutput:       "123.40000000000005",
+			ExpectedOutputLength: 18,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "float-as-number",
+			Path:                 "balance",
+			Data:                 `{"balance": 123.40000000000005}`,
+			ExpectedOutput:       "123.40000000000005",
+			ExpectedOutputLength: 18,
+			ExpectedError:        false,
+		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {

main.go

@@ -52,14 +52,15 @@ func save() {
 	}
 }
 
-func loadConfiguration() (cfg *config.Config, err error) {
-	customConfigFile := os.Getenv("GATUS_CONFIG_FILE")
-	if len(customConfigFile) > 0 {
-		cfg, err = config.Load(customConfigFile)
-	} else {
-		cfg, err = config.LoadDefaultConfiguration()
+func loadConfiguration() (*config.Config, error) {
+	configPath := os.Getenv("GATUS_CONFIG_PATH")
+	// Backwards compatibility
+	if len(configPath) == 0 {
+		if configPath = os.Getenv("GATUS_CONFIG_FILE"); len(configPath) > 0 {
+			log.Println("WARNING: GATUS_CONFIG_FILE is deprecated. Please use GATUS_CONFIG_PATH instead.")
+		}
 	}
-	return
+	return config.LoadConfiguration(configPath)
 }
 
 // initializeStorage initializes the storage provider
@@ -79,14 +80,14 @@ func initializeStorage(cfg *config.Config) {
 	}
 	numberOfEndpointStatusesDeleted := store.Get().DeleteAllEndpointStatusesNotInKeys(keys)
 	if numberOfEndpointStatusesDeleted > 0 {
-		log.Printf("[config][validateStorageConfig] Deleted %d endpoint statuses because their matching endpoints no longer existed", numberOfEndpointStatusesDeleted)
+		log.Printf("[main][initializeStorage] Deleted %d endpoint statuses because their matching endpoints no longer existed", numberOfEndpointStatusesDeleted)
 	}
 }
 
 func listenToConfigurationFileChanges(cfg *config.Config) {
 	for {
 		time.Sleep(30 * time.Second)
-		if cfg.HasLoadedConfigurationFileBeenModified() {
+		if cfg.HasLoadedConfigurationBeenModified() {
 			log.Println("[main][listenToConfigurationFileChanges] Configuration file has been modified")
 			stop()
 			time.Sleep(time.Second) // Wait a bit to make sure everything is done.

security/config.go

@@ -2,10 +2,13 @@ package security
 
 import (
 	"encoding/base64"
+	"log"
 	"net/http"
 
-	"github.com/TwiN/g8"
-	"github.com/gorilla/mux"
+	g8 "github.com/TwiN/g8/v2"
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/adaptor"
+	"github.com/gofiber/fiber/v2/middleware/basicauth"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -29,20 +32,20 @@ func (c *Config) IsValid() bool {
 }
 
 // RegisterHandlers registers all handlers required based on the security configuration
-func (c *Config) RegisterHandlers(router *mux.Router) error {
+func (c *Config) RegisterHandlers(router fiber.Router) error {
 	if c.OIDC != nil {
 		if err := c.OIDC.initialize(); err != nil {
 			return err
 		}
-		router.HandleFunc("/oidc/login", c.OIDC.loginHandler)
-		router.HandleFunc("/authorization-code/callback", c.OIDC.callbackHandler)
+		router.All("/oidc/login", c.OIDC.loginHandler)
+		router.All("/authorization-code/callback", adaptor.HTTPHandlerFunc(c.OIDC.callbackHandler))
 	}
 	return nil
 }
 
 // ApplySecurityMiddleware applies an authentication middleware to the router passed.
-// The router passed should be a subrouter in charge of handlers that require authentication.
-func (c *Config) ApplySecurityMiddleware(api *mux.Router) error {
+// The router passed should be a sub-router in charge of handlers that require authentication.
+func (c *Config) ApplySecurityMiddleware(router fiber.Router) error {
 	if c.OIDC != nil {
 		// We're going to use g8 for session handling
 		clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
@@ -61,7 +64,7 @@ func (c *Config) ApplySecurityMiddleware(api *mux.Router) error {
 		// TODO: g8: Add a way to update cookie after? would need the writer
 		authorizationService := g8.NewAuthorizationService().WithClientProvider(clientProvider)
 		c.gate = g8.New().WithAuthorizationService(authorizationService).WithCustomTokenExtractor(customTokenExtractorFunc)
-		api.Use(c.gate.Protect)
+		router.Use(adaptor.HTTPMiddleware(c.gate.Protect))
 	} else if c.Basic != nil {
 		var decodedBcryptHash []byte
 		if len(c.Basic.PasswordBcryptHashBase64Encoded) > 0 {
@@ -71,29 +74,35 @@ func (c *Config) ApplySecurityMiddleware(api *mux.Router) error {
 				return err
 			}
 		}
-		api.Use(func(handler http.Handler) http.Handler {
-			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				usernameEntered, passwordEntered, ok := r.BasicAuth()
+		router.Use(basicauth.New(basicauth.Config{
+			Authorizer: func(username, password string) bool {
 				if len(c.Basic.PasswordBcryptHashBase64Encoded) > 0 {
-					if !ok || usernameEntered != c.Basic.Username || bcrypt.CompareHashAndPassword(decodedBcryptHash, []byte(passwordEntered)) != nil {
-						w.Header().Set("WWW-Authenticate", "Basic")
-						w.WriteHeader(http.StatusUnauthorized)
-						_, _ = w.Write([]byte("Unauthorized"))
-						return
+					if username != c.Basic.Username || bcrypt.CompareHashAndPassword(decodedBcryptHash, []byte(password)) != nil {
+						return false
 					}
 				}
-				handler.ServeHTTP(w, r)
-			})
-		})
+				return true
+			},
+			Unauthorized: func(ctx *fiber.Ctx) error {
+				ctx.Set("WWW-Authenticate", "Basic")
+				return ctx.Status(401).SendString("Unauthorized")
+			},
+		}))
 	}
 	return nil
 }
 
 // IsAuthenticated checks whether the user is authenticated
 // If the Config does not warrant authentication, it will always return true.
-func (c *Config) IsAuthenticated(r *http.Request) bool {
+func (c *Config) IsAuthenticated(ctx *fiber.Ctx) bool {
 	if c.gate != nil {
-		token := c.gate.ExtractTokenFromRequest(r)
+		// TODO: Update g8 to support fasthttp natively? (see g8's fasthttp branch)
+		request, err := adaptor.ConvertRequest(ctx, false)
+		if err != nil {
+			log.Printf("[IsAuthenticated] Unexpected error converting request: %v", err)
+			return false
+		}
+		token := c.gate.ExtractTokenFromRequest(request)
 		_, hasSession := sessions.Get(token)
 		return hasSession
 	}

security/config_test.go

@@ -5,7 +5,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/gorilla/mux"
+	"github.com/gofiber/fiber/v2"
 	"golang.org/x/oauth2"
 )
 
@@ -23,83 +23,96 @@ func TestConfig_ApplySecurityMiddleware(t *testing.T) {
 	///////////
 	// BASIC //
 	///////////
-	// Bcrypt
-	c := &Config{Basic: &BasicConfig{
-		Username:                        "john.doe",
-		PasswordBcryptHashBase64Encoded: "JDJhJDA4JDFoRnpPY1hnaFl1OC9ISlFsa21VS09wOGlPU1ZOTDlHZG1qeTFvb3dIckRBUnlHUmNIRWlT",
-	}}
-	api := mux.NewRouter()
-	api.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
+	t.Run("basic", func(t *testing.T) {
+		// Bcrypt
+		c := &Config{Basic: &BasicConfig{
+			Username:                        "john.doe",
+			PasswordBcryptHashBase64Encoded: "JDJhJDA4JDFoRnpPY1hnaFl1OC9ISlFsa21VS09wOGlPU1ZOTDlHZG1qeTFvb3dIckRBUnlHUmNIRWlT",
+		}}
+		app := fiber.New()
+		if err := c.ApplySecurityMiddleware(app); err != nil {
+			t.Error("expected no error, got", err)
+		}
+		app.Get("/test", func(c *fiber.Ctx) error {
+			return c.SendStatus(200)
+		})
+		// Try to access the route without basic auth
+		request := httptest.NewRequest("GET", "/test", http.NoBody)
+		response, err := app.Test(request)
+		if err != nil {
+			t.Fatal("expected no error, got", err)
+		}
+		if response.StatusCode != 401 {
+			t.Error("expected code to be 401, but was", response.StatusCode)
+		}
+		// Try again, but with basic auth
+		request = httptest.NewRequest("GET", "/test", http.NoBody)
+		request.SetBasicAuth("john.doe", "hunter2")
+		response, err = app.Test(request)
+		if err != nil {
+			t.Fatal("expected no error, got", err)
+		}
+		if response.StatusCode != 200 {
+			t.Error("expected code to be 200, but was", response.StatusCode)
+		}
 	})
-	if err := c.ApplySecurityMiddleware(api); err != nil {
-		t.Error("expected no error, but was", err)
-	}
-	// Try to access the route without basic auth
-	request, _ := http.NewRequest("GET", "/test", http.NoBody)
-	responseRecorder := httptest.NewRecorder()
-	api.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusUnauthorized {
-		t.Error("expected code to be 401, but was", responseRecorder.Code)
-	}
-	// Try again, but with basic auth
-	request, _ = http.NewRequest("GET", "/test", http.NoBody)
-	responseRecorder = httptest.NewRecorder()
-	request.SetBasicAuth("john.doe", "hunter2")
-	api.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusOK {
-		t.Error("expected code to be 200, but was", responseRecorder.Code)
-	}
 	//////////
 	// OIDC //
 	//////////
-	api = mux.NewRouter()
-	api.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
+	t.Run("oidc", func(t *testing.T) {
+		c := &Config{OIDC: &OIDCConfig{
+			IssuerURL:       "https://sso.gatus.io/",
+			RedirectURL:     "http://localhost:80/authorization-code/callback",
+			Scopes:          []string{"openid"},
+			AllowedSubjects: []string{"user1@example.com"},
+			oauth2Config:    oauth2.Config{},
+			verifier:        nil,
+		}}
+		app := fiber.New()
+		if err := c.ApplySecurityMiddleware(app); err != nil {
+			t.Error("expected no error, got", err)
+		}
+		app.Get("/test", func(c *fiber.Ctx) error {
+			return c.SendStatus(200)
+		})
+		// Try without any session cookie
+		request := httptest.NewRequest("GET", "/test", http.NoBody)
+		response, err := app.Test(request)
+		if err != nil {
+			t.Fatal("expected no error, got", err)
+		}
+		if response.StatusCode != 401 {
+			t.Error("expected code to be 401, but was", response.StatusCode)
+		}
+		// Try with a session cookie
+		request = httptest.NewRequest("GET", "/test", http.NoBody)
+		request.AddCookie(&http.Cookie{Name: "session", Value: "123"})
+		response, err = app.Test(request)
+		if err != nil {
+			t.Fatal("expected no error, got", err)
+		}
+		if response.StatusCode != 401 {
+			t.Error("expected code to be 401, but was", response.StatusCode)
+		}
 	})
-	c.OIDC = &OIDCConfig{
-		IssuerURL:       "https://sso.gatus.io/",
-		RedirectURL:     "http://localhost:80/authorization-code/callback",
-		Scopes:          []string{"openid"},
-		AllowedSubjects: []string{"user1@example.com"},
-		oauth2Config:    oauth2.Config{},
-		verifier:        nil,
-	}
-	c.Basic = nil
-	if err := c.ApplySecurityMiddleware(api); err != nil {
-		t.Error("expected no error, but was", err)
-	}
-	// Try without any session cookie
-	request, _ = http.NewRequest("GET", "/test", http.NoBody)
-	responseRecorder = httptest.NewRecorder()
-	api.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusUnauthorized {
-		t.Error("expected code to be 401, but was", responseRecorder.Code)
-	}
-	// Try with a session cookie
-	request, _ = http.NewRequest("GET", "/test", http.NoBody)
-	request.AddCookie(&http.Cookie{Name: "session", Value: "123"})
-	responseRecorder = httptest.NewRecorder()
-	api.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusUnauthorized {
-		t.Error("expected code to be 401, but was", responseRecorder.Code)
-	}
 }
 
 func TestConfig_RegisterHandlers(t *testing.T) {
 	c := &Config{}
-	router := mux.NewRouter()
-	c.RegisterHandlers(router)
+	app := fiber.New()
+	c.RegisterHandlers(app)
 	// Try to access the OIDC handler. This should fail, because the security config doesn't have OIDC
-	request, _ := http.NewRequest("GET", "/oidc/login", http.NoBody)
-	responseRecorder := httptest.NewRecorder()
-	router.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusNotFound {
-		t.Error("expected code to be 404, but was", responseRecorder.Code)
+	request := httptest.NewRequest("GET", "/oidc/login", http.NoBody)
+	response, err := app.Test(request)
+	if err != nil {
+		t.Fatal("expected no error, got", err)
+	}
+	if response.StatusCode != 404 {
+		t.Error("expected code to be 404, but was", response.StatusCode)
 	}
 	// Set an empty OIDC config. This should fail, because the IssuerURL is required.
 	c.OIDC = &OIDCConfig{}
-	if err := c.RegisterHandlers(router); err == nil {
+	if err := c.RegisterHandlers(app); err == nil {
 		t.Fatal("expected an error, but got none")
 	}
 	// Set the OIDC config and try again
@@ -109,13 +122,15 @@ func TestConfig_RegisterHandlers(t *testing.T) {
 		Scopes:          []string{"openid"},
 		AllowedSubjects: []string{"user1@example.com"},
 	}
-	if err := c.RegisterHandlers(router); err != nil {
+	if err := c.RegisterHandlers(app); err != nil {
 		t.Fatal("expected no error, but got", err)
 	}
-	request, _ = http.NewRequest("GET", "/oidc/login", http.NoBody)
-	responseRecorder = httptest.NewRecorder()
-	router.ServeHTTP(responseRecorder, request)
-	if responseRecorder.Code != http.StatusFound {
-		t.Error("expected code to be 302, but was", responseRecorder.Code)
+	request = httptest.NewRequest("GET", "/oidc/login", http.NoBody)
+	response, err = app.Test(request)
+	if err != nil {
+		t.Fatal("expected no error, got", err)
+	}
+	if response.StatusCode != 302 {
+		t.Error("expected code to be 302, but was", response.StatusCode)
 	}
 }

security/oidc.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/coreos/go-oidc/v3/oidc"
+	"github.com/gofiber/fiber/v2"
 	"github.com/google/uuid"
 	"golang.org/x/oauth2"
 )
@@ -47,28 +48,28 @@ func (c *OIDCConfig) initialize() error {
 	return nil
 }
 
-func (c *OIDCConfig) loginHandler(w http.ResponseWriter, r *http.Request) {
+func (c *OIDCConfig) loginHandler(ctx *fiber.Ctx) error {
 	state, nonce := uuid.NewString(), uuid.NewString()
-	http.SetCookie(w, &http.Cookie{
+	ctx.Cookie(&fiber.Cookie{
 		Name:     cookieNameState,
 		Value:    state,
 		Path:     "/",
 		MaxAge:   int(time.Hour.Seconds()),
-		SameSite: http.SameSiteLaxMode,
-		HttpOnly: true,
+		SameSite: "lax",
+		HTTPOnly: true,
 	})
-	http.SetCookie(w, &http.Cookie{
+	ctx.Cookie(&fiber.Cookie{
 		Name:     cookieNameNonce,
 		Value:    nonce,
 		Path:     "/",
 		MaxAge:   int(time.Hour.Seconds()),
-		SameSite: http.SameSiteLaxMode,
-		HttpOnly: true,
+		SameSite: "lax",
+		HTTPOnly: true,
 	})
-	http.Redirect(w, r, c.oauth2Config.AuthCodeURL(state, oidc.Nonce(nonce)), http.StatusFound)
+	return ctx.Redirect(c.oauth2Config.AuthCodeURL(state, oidc.Nonce(nonce)), http.StatusFound)
 }
 
-func (c *OIDCConfig) callbackHandler(w http.ResponseWriter, r *http.Request) {
+func (c *OIDCConfig) callbackHandler(w http.ResponseWriter, r *http.Request) { // TODO: Migrate to a native fiber handler
 	// Check if there's an error
 	if len(r.URL.Query().Get("error")) > 0 {
 		http.Error(w, r.URL.Query().Get("error")+": "+r.URL.Query().Get("error_description"), http.StatusBadRequest)

storage/store/sql/sql_test.go

@@ -97,7 +97,7 @@ func TestNewStore(t *testing.T) {
 func TestStore_InsertCleansUpOldUptimeEntriesProperly(t *testing.T) {
 	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpOldUptimeEntriesProperly.db", false)
 	defer store.Close()
-	now := time.Now().Round(time.Minute)
+	now := time.Now().Truncate(time.Hour)
 	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
 
 	store.Insert(&testEndpoint, &core.Result{Timestamp: now.Add(-5 * time.Hour), Success: true})

storage/store/store_test.go

@@ -1,6 +1,7 @@
 package store
 
 import (
+	"path/filepath"
 	"testing"
 	"time"
 
@@ -130,6 +131,8 @@ func TestStore_GetEndpointStatusByKey(t *testing.T) {
 	firstResult.Timestamp = now.Add(-time.Minute)
 	secondResult := testUnsuccessfulResult
 	secondResult.Timestamp = now
+	thirdResult := testSuccessfulResult
+	thirdResult.Timestamp = now
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
 			scenario.Store.Insert(&testEndpoint, &firstResult)
@@ -153,6 +156,14 @@ func TestStore_GetEndpointStatusByKey(t *testing.T) {
 			if endpointStatus.Results[0].Timestamp.After(endpointStatus.Results[1].Timestamp) {
 				t.Error("The result at index 0 should've been older than the result at index 1")
 			}
+			scenario.Store.Insert(&testEndpoint, &thirdResult)
+			endpointStatus, err = scenario.Store.GetEndpointStatusByKey(testEndpoint.Key(), paging.NewEndpointStatusParams().WithEvents(1, common.MaximumNumberOfEvents).WithResults(1, common.MaximumNumberOfResults))
+			if err != nil {
+				t.Fatal("shouldn't have returned an error, got", err.Error())
+			}
+			if len(endpointStatus.Results) != 3 {
+				t.Fatalf("endpointStatus.Results should've had 3 entries")
+			}
 			scenario.Store.Clear()
 		})
 	}
@@ -456,8 +467,8 @@ func TestStore_Insert(t *testing.T) {
 	secondResult.Timestamp = now
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			scenario.Store.Insert(&testEndpoint, &testSuccessfulResult)
-			scenario.Store.Insert(&testEndpoint, &testUnsuccessfulResult)
+			scenario.Store.Insert(&testEndpoint, &firstResult)
+			scenario.Store.Insert(&testEndpoint, &secondResult)
 			ss, err := scenario.Store.GetEndpointStatusByKey(testEndpoint.Key(), paging.NewEndpointStatusParams().WithEvents(1, common.MaximumNumberOfEvents).WithResults(1, common.MaximumNumberOfResults))
 			if err != nil {
 				t.Error("shouldn't have returned an error, got", err)
@@ -471,7 +482,7 @@ func TestStore_Insert(t *testing.T) {
 			if len(ss.Results) != 2 {
 				t.Fatalf("Endpoint '%s' should've had 2 results, got %d", ss.Name, len(ss.Results))
 			}
-			for i, expectedResult := range []core.Result{testSuccessfulResult, testUnsuccessfulResult} {
+			for i, expectedResult := range []core.Result{firstResult, secondResult} {
 				if expectedResult.HTTPStatus != ss.Results[i].HTTPStatus {
 					t.Errorf("Result at index %d should've had a HTTPStatus of %d, got %d", i, ss.Results[i].HTTPStatus, expectedResult.HTTPStatus)
 				}
@@ -566,6 +577,7 @@ func TestGet(t *testing.T) {
 }
 
 func TestInitialize(t *testing.T) {
+	dir := t.TempDir()
 	type Scenario struct {
 		Name        string
 		Cfg         *storage.Config
@@ -594,7 +606,7 @@ func TestInitialize(t *testing.T) {
 		},
 		{
 			Name:        "sqlite-with-path",
-			Cfg:         &storage.Config{Type: storage.TypeSQLite, Path: t.TempDir() + "/TestInitialize_sqlite-with-path.db"},
+			Cfg:         &storage.Config{Type: storage.TypeSQLite, Path: filepath.Join(dir, "TestInitialize_sqlite-with-path.db")},
 			ExpectedErr: nil,
 		},
 	}
@@ -629,7 +641,7 @@ func TestInitialize(t *testing.T) {
 }
 
 func TestAutoSave(t *testing.T) {
-	file := t.TempDir() + "/TestAutoSave.db"
+	file := filepath.Join(t.TempDir(), "/TestAutoSave.db")
 	if err := Initialize(&storage.Config{Path: file}); err != nil {
 		t.Fatal("shouldn't have returned an error")
 	}

testdata/badcert.key

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+wat
+-----END PRIVATE KEY-----

testdata/badcert.pem

@@ -0,0 +1,3 @@
+-----BEGIN CERTIFICATE-----
+wat
+-----END CERTIFICATE-----

testdata/cert.key

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgJh67FWpz8wrN1mM/
+CebkZN0zF83691ZVD83XlbNLRUqhRANCAAScfyPxScqz+Z/yNtAID/FOORy9J6LM
+DUAJevGDvAZCMp/nh+Ps3nLrMoRlykcux3mq+N8HPlJ8R3eetB4S1tHY
+-----END PRIVATE KEY-----

testdata/cert.pem

@@ -0,0 +1,10 @@
+-----BEGIN CERTIFICATE-----
+MIIBaDCCAQ2gAwIBAgICBNIwCgYIKoZIzj0EAwIwFTETMBEGA1UEChMKR2F0dXMg
+dGVzdDAgFw0yMzA0MjIxODUwMDVaGA8yMjk3MDIwNDE4NTAwNVowFTETMBEGA1UE
+ChMKR2F0dXMgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJx/I/FJyrP5
+n/I20AgP8U45HL0noswNQAl68YO8BkIyn+eH4+zecusyhGXKRy7Hear43wc+UnxH
+d560HhLW0dijSzBJMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcD
+ATAMBgNVHRMBAf8EAjAAMBQGA1UdEQQNMAuCCWxvY2FsaG9zdDAKBggqhkjOPQQD
+AgNJADBGAiEA/SdthKOoNw3azSHuPid7XJsXYB8DisIC9LBwcb/QTMECIQCAB36Y
+OI15ao+J/RUz2sXdPXCAN8hlohi6OnmZmJB32g==
+-----END CERTIFICATE-----

vendor/github.com/TwiN/g8/.gitattributes

@@ -1 +0,0 @@
-* text=lf

vendor/github.com/TwiN/g8/.gitignore

@@ -1,2 +0,0 @@
-.idea
-*.iml

vendor/github.com/TwiN/g8/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 TwiN
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/TwiN/g8/README.md

@@ -1,287 +0,0 @@
-# g8
-
-![test](https://github.com/TwiN/g8/workflows/test/badge.svg?branch=master) 
-[![Go Report Card](https://goreportcard.com/badge/github.com/TwiN/g8)](https://goreportcard.com/report/github.com/TwiN/g8)
-[![codecov](https://codecov.io/gh/TwiN/g8/branch/master/graph/badge.svg)](https://codecov.io/gh/TwiN/g8)
-[![Go version](https://img.shields.io/github/go-mod/go-version/TwiN/g8.svg)](https://github.com/TwiN/g8)
-[![Go Reference](https://pkg.go.dev/badge/github.com/TwiN/g8.svg)](https://pkg.go.dev/github.com/TwiN/g8)
-[![Follow TwiN](https://img.shields.io/github/followers/TwiN?label=Follow&style=social)](https://github.com/TwiN)
-
-g8, pronounced gate, is a simple Go library for protecting HTTP handlers.
-
-Tired of constantly re-implementing a security layer for each application? Me too, that's why I made g8.
-
-
-## Installation
-```console
-go get -u github.com/TwiN/g8
-```
-
-
-## Usage
-Because the entire purpose of g8 is to NOT waste time configuring the layer of security, the primary emphasis is to 
-keep it as simple as possible.
-
-
-### Simple
-Just want a simple layer of security without the need for advanced permissions? This configuration is what you're
-looking for.
-
-```go
-authorizationService := g8.NewAuthorizationService().WithToken("mytoken")
-gate := g8.New().WithAuthorizationService(authorizationService)
-
-router := http.NewServeMux()
-router.Handle("/unprotected", yourHandler)
-router.Handle("/protected", gate.Protect(yourHandler))
-
-http.ListenAndServe(":8080", router)
-```
-
-The endpoint `/protected` is now only accessible if you pass the header `Authorization: Bearer mytoken`.
-
-If you use `http.HandleFunc` instead of `http.Handle`, you may use `gate.ProtectFunc(yourHandler)` instead.
-
-If you're not using the `Authorization` header, you can specify a custom token extractor. 
-This enables use cases like [Protecting a handler using session cookie](#protecting-a-handler-using-session-cookie)
-
-
-### Advanced permissions
-If you have tokens with more permissions than others, g8's permission system will make managing authorization a breeze.
-
-Rather than registering tokens, think of it as registering clients, the only difference being that clients may be 
-configured with permissions while tokens cannot. 
-
-```go
-authorizationService := g8.NewAuthorizationService().WithClient(g8.NewClient("mytoken").WithPermission("admin"))
-gate := g8.New().WithAuthorizationService(authorizationService)
-
-router := http.NewServeMux()
-router.Handle("/unprotected", yourHandler)
-router.Handle("/protected-with-admin", gate.ProtectWithPermissions(yourHandler, []string{"admin"}))
-
-http.ListenAndServe(":8080", router)
-```
-
-The endpoint `/protected-with-admin` is now only accessible if you pass the header `Authorization: Bearer mytoken`,
-because the client with the token `mytoken` has the permission `admin`. Note that the following handler would also be
-accessible with that token:
-```go
-router.Handle("/protected", gate.Protect(yourHandler))
-```
-
-To clarify, both clients and tokens have access to handlers that aren't protected with extra permissions, and 
-essentially, tokens are registered as clients with no extra permissions in the background.
-
-Creating a token like so:
-```go
-authorizationService := g8.NewAuthorizationService().WithToken("mytoken")
-```
-is the equivalent of creating the following client:
-```go
-authorizationService := g8.NewAuthorizationService().WithClient(g8.NewClient("mytoken"))
-```
-
-
-### With client provider
-A client provider's task is to retrieve a Client from an external source (e.g. a database) when provided with a token.
-You should use a client provider when you have a lot of tokens and it wouldn't make sense to register all of them using
-`AuthorizationService`'s `WithToken`/`WithTokens`/`WithClient`/`WithClients`.
-
-Note that the provider is used as a fallback source. As such, if a token is explicitly registered using one of the 4 
-aforementioned functions, the client provider will not be used.
-
-```go
-clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-    // We'll assume that the following function calls your database and returns a struct "User" that 
-    // has the user's token as well as the permissions granted to said user
-    user := database.GetUserByToken(token)
-    if user != nil {
-        return g8.NewClient(user.Token).WithPermissions(user.Permissions)
-    }
-    return nil
-})
-authorizationService := g8.NewAuthorizationService().WithClientProvider(clientProvider)
-gate := g8.New().WithAuthorizationService(authorizationService)
-```
-
-You can also configure the client provider to cache the output of the function you provide to retrieve clients by token:
-```go
-clientProvider := g8.NewClientProvider(...).WithCache(ttl, maxSize)
-```
-
-Since g8 leverages [TwiN/gocache](https://github.com/TwiN/gocache), you can also use gocache's 
-constants for configuring the TTL and the maximum size:
-- Setting the TTL to `gocache.NoExpiration` (-1) will disable the TTL. 
-- Setting the maximum size to `gocache.NoMaxSize` (0) will disable the maximum cache size
-
-If you're using a TTL and have a lot of tokens (100k+), you may want to use `clientProvider.StartJanitor()` to allow 
-the cache to passively delete expired entries. If you have to re-initialize the client provider after the janitor has
-been started, make sure to stop the janitor first (`clientProvider.StopJanitor()`). This is because the janitor runs on 
-a separate goroutine, thus, if you were to re-create a client provider and re-assign it, the old client provider would 
-still exist in memory with the old cache. I'm only specifying this for completeness, because for the overwhelming 
-majority of people, the gate will be created on application start and never modified again until the application shuts
-down, in which case, you don't even need to worry about stopping the janitor.
-
-To avoid any misunderstandings, using a client provider is not mandatory. If you only have a few tokens and you can load
-them on application start, you can just leverage `AuthorizationService`'s `WithToken`/`WithTokens`/`WithClient`/`WithClients`.
-
-
-## AuthorizationService
-As the previous examples may have hinted, there are several ways to create clients. The one thing they have
-in common is that they all go through AuthorizationService, which is in charge of both managing clients and determining
-whether a request should be blocked or allowed through.
-
-| Function           | Description                                                                                                                      | 
-|:-------------------|:---------------------------------------------------------------------------------------------------------------------------------|
-| WithToken          | Creates a single static client with no extra permissions                                                                         |
-| WithTokens         | Creates a slice of static clients with no extra permissions                                                                      |
-| WithClient         | Creates a single static client                                                                                                   |
-| WithClients        | Creates a slice of static clients                                                                                                |
-| WithClientProvider | Creates a client provider which will allow a fallback to a dynamic source (e.g. to a database) when a static client is not found |
-
-Except for `WithClientProvider`, every functions listed above can be called more than once.
-As a result, you may safely perform actions like this:
-```go
-authorizationService := g8.NewAuthorizationService().
-    WithToken("123").
-    WithToken("456").
-    WithClient(g8.NewClient("789").WithPermission("admin"))
-gate := g8.New().WithAuthorizationService(authorizationService)
-```
-
-Be aware that g8.Client supports a list of permissions as well. You may call `WithPermission` several times, or call
-`WithPermissions` with a slice of permissions instead.
-
-
-### Permissions
-Unlike client permissions, handler permissions are requirements.
-
-A client may have as many permissions as you want, but for said client to have access to a handler protected by
-permissions, the client must have all permissions defined by said handler in order to have access to it.
-
-In other words, a client with the permissions `create`, `read`, `update` and `delete` would have access to all of these handlers:
-```go
-gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClient(g8.NewClient("mytoken").WithPermissions([]string{"create", "read", "update", "delete"})))
-router := http.NewServeMux()
-router.Handle("/", gate.Protect(homeHandler)) // equivalent of gate.ProtectWithPermissions(homeHandler, []string{})
-router.Handle("/create", gate.ProtectWithPermissions(createHandler, []string{"create"}))
-router.Handle("/read", gate.ProtectWithPermissions(readHandler, []string{"read"}))
-router.Handle("/update", gate.ProtectWithPermissions(updateHandler, []string{"update"}))
-router.Handle("/delete", gate.ProtectWithPermissions(deleteHandler, []string{"delete"}))
-router.Handle("/crud", gate.ProtectWithPermissions(crudHandler, []string{"create", "read", "update", "delete"}))
-```
-But it would not have access to the following handler, because while `mytoken` has the `read` permission, it does not 
-have the `backup` permission:
-```go
-router.Handle("/backup", gate.ProtectWithPermissions(&testHandler{}, []string{"read", "backup"}))
-```
-
-If you're using an HTTP library that supports middlewares like [mux](https://github.com/gorilla/mux), you can protect 
-an entire group of handlers instead using `gate.Protect` or `gate.PermissionMiddleware()`:
-```go
-router := mux.NewRouter()
-
-userRouter := router.PathPrefix("/").Subrouter()
-userRouter.Use(gate.Protect)
-userRouter.HandleFunc("/api/v1/users/me", getUserProfile).Methods("GET")
-userRouter.HandleFunc("/api/v1/users/me/friends", getUserFriends).Methods("GET")
-userRouter.HandleFunc("/api/v1/users/me/email", updateUserEmail).Methods("PATCH")
-
-adminRouter := router.PathPrefix("/").Subrouter()
-adminRouter.Use(gate.PermissionMiddleware("admin"))
-adminRouter.HandleFunc("/api/v1/users/{id}/ban", banUserByID).Methods("POST")
-adminRouter.HandleFunc("/api/v1/users/{id}/delete", deleteUserByID).Methods("DELETE")
-```
-
-
-## Rate limiting
-To add a rate limit of 100 requests per second:
-```go
-gate := g8.New().WithRateLimit(100)
-```
-
-
-## Accessing the token from the protected handlers
-If you need to access the token from the handlers you are protecting with g8, you can retrieve it from the
-request context by using the key `g8.TokenContextKey`:
-```go
-http.Handle("/handle", gate.ProtectFunc(func(w http.ResponseWriter, r *http.Request) {
-    token, _ := r.Context().Value(g8.TokenContextKey).(string)
-    // ...
-}))
-```
-
-## Examples
-### Protecting a handler using session cookie
-If you want to only allow authenticated users to access a handler, you can use a custom token extractor function 
-combined with a client provider.
-
-First, we'll create a function to extract the session ID from the session cookie. While a session ID does not 
-theoretically refer to a token, g8 uses the term `token` as a blanket term to refer to any string that can be used to
-identify a client.
-```go
-customTokenExtractorFunc := func(request *http.Request) string {
-    sessionCookie, err := request.Cookie("session")
-    if err != nil {
-        return ""
-    }
-    return sessionCookie.Value
-}
-```
-
-Next, we need to create a client provider that will validate our token, which refers to the session ID in this case.
-```go
-clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-    // We'll assume that the following function calls your database and validates whether the session is valid.
-    isSessionValid := database.CheckIfSessionIsValid(token)
-    if !isSessionValid {
-        return nil // Returning nil will cause the gate to return a 401 Unauthorized.
-    }
-    // You could also retrieve the user and their permissions if you wanted instead, but for this example,
-    // all we care about is confirming whether the session is valid or not.
-    return g8.NewClient(token)
-})
-```
-
-Keep in mind that you can get really creative with the client provider above.
-For instance, you could refresh the session's expiration time, which will allow the user to stay logged in for 
-as long as they're active.
-
-You're also not limited to using something stateful like the example above. You could use a JWT and have your client
-provider validate said JWT.
-
-Finally, we can create the authorization service and the gate:
-```go
-authorizationService := g8.NewAuthorizationService().WithClientProvider(clientProvider)
-gate := g8.New().WithAuthorizationService(authorizationService).WithCustomTokenExtractor(customTokenExtractorFunc)
-```
-
-If you need to access the token (session ID in this case) from the protected handlers, you can retrieve it from the
-request context by using the key `g8.TokenContextKey`:
-```go
-http.Handle("/handle", gate.ProtectFunc(func(w http.ResponseWriter, r *http.Request) {
-    sessionID, _ := r.Context().Value(g8.TokenContextKey).(string)
-    // ...
-}))
-```
-
-### Using a custom header
-The logic is the same as the example above:
-```go
-customTokenExtractorFunc := func(request *http.Request) string {
-    return request.Header.Get("X-API-Token")
-}
-
-clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-    // We'll assume that the following function calls your database and returns a struct "User" that 
-    // has the user's token as well as the permissions granted to said user
-    user := database.GetUserByToken(token)
-    if user != nil {
-        return g8.NewClient(user.Token).WithPermissions(user.Permissions)
-    }
-    return nil
-})
-authorizationService := g8.NewAuthorizationService().WithClientProvider(clientProvider)
-gate := g8.New().WithAuthorizationService(authorizationService).WithCustomTokenExtractor(customTokenExtractorFunc)
-```

vendor/github.com/TwiN/g8/authorization.go

@@ -1,122 +0,0 @@
-package g8
-
-import (
-	"sync"
-)
-
-// AuthorizationService is the service that manages client/token registry and client fallback as well as the service
-// that determines whether a token meets the specific requirements to be authorized by a Gate or not.
-type AuthorizationService struct {
-	clients        map[string]*Client
-	clientProvider *ClientProvider
-
-	mutex sync.RWMutex
-}
-
-// NewAuthorizationService creates a new AuthorizationService
-func NewAuthorizationService() *AuthorizationService {
-	return &AuthorizationService{
-		clients: make(map[string]*Client),
-	}
-}
-
-// WithToken is used to specify a single token for which authorization will be granted
-//
-// The client that will be created from this token will have access to all handlers that are not protected with a
-// specific permission.
-//
-// In other words, if you were to do the following:
-//     gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithToken("12345"))
-//
-// The following handler would be accessible with the token 12345:
-//     router.Handle("/1st-handler", gate.Protect(yourHandler))
-//
-// But not this one would not be accessible with the token 12345:
-//     router.Handle("/2nd-handler", gate.ProtectWithPermissions(yourOtherHandler, []string{"admin"}))
-//
-// Calling this function multiple times will add multiple clients, though you may want to use WithTokens instead
-// if you plan to add multiple clients
-//
-// If you wish to configure advanced permissions, consider using WithClient instead.
-//
-func (authorizationService *AuthorizationService) WithToken(token string) *AuthorizationService {
-	authorizationService.mutex.Lock()
-	authorizationService.clients[token] = NewClient(token)
-	authorizationService.mutex.Unlock()
-	return authorizationService
-}
-
-// WithTokens is used to specify a slice of tokens for which authorization will be granted
-func (authorizationService *AuthorizationService) WithTokens(tokens []string) *AuthorizationService {
-	authorizationService.mutex.Lock()
-	for _, token := range tokens {
-		authorizationService.clients[token] = NewClient(token)
-	}
-	authorizationService.mutex.Unlock()
-	return authorizationService
-}
-
-// WithClient is used to specify a single client for which authorization will be granted
-//
-// When compared to WithToken, the advantage of using this function is that you may specify the client's
-// permissions and thus, be a lot more granular with what endpoint a token has access to.
-//
-// In other words, if you were to do the following:
-//     gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClient(g8.NewClient("12345").WithPermission("mod")))
-//
-// The following handlers would be accessible with the token 12345:
-//     router.Handle("/1st-handler", gate.ProtectWithPermissions(yourHandler, []string{"mod"}))
-//     router.Handle("/2nd-handler", gate.Protect(yourOtherHandler))
-//
-// But not this one, because the user does not have the permission "admin":
-//     router.Handle("/3rd-handler", gate.ProtectWithPermissions(yetAnotherHandler, []string{"admin"}))
-//
-// Calling this function multiple times will add multiple clients, though you may want to use WithClients instead
-// if you plan to add multiple clients
-func (authorizationService *AuthorizationService) WithClient(client *Client) *AuthorizationService {
-	authorizationService.mutex.Lock()
-	authorizationService.clients[client.Token] = client
-	authorizationService.mutex.Unlock()
-	return authorizationService
-}
-
-// WithClients is used to specify a slice of clients for which authorization will be granted
-func (authorizationService *AuthorizationService) WithClients(clients []*Client) *AuthorizationService {
-	authorizationService.mutex.Lock()
-	for _, client := range clients {
-		authorizationService.clients[client.Token] = client
-	}
-	authorizationService.mutex.Unlock()
-	return authorizationService
-}
-
-// WithClientProvider allows specifying a custom provider to fetch clients by token.
-//
-// For example, you can use it to fallback to making a call in your database when a request is made with a token that
-// hasn't been specified via WithToken, WithTokens, WithClient or WithClients.
-func (authorizationService *AuthorizationService) WithClientProvider(provider *ClientProvider) *AuthorizationService {
-	authorizationService.clientProvider = provider
-	return authorizationService
-}
-
-// IsAuthorized checks whether a client with a given token exists and has the permissions required.
-//
-// If permissionsRequired is nil or empty and a client with the given token exists, said client will have access to all
-// handlers that are not protected by a given permission.
-func (authorizationService *AuthorizationService) IsAuthorized(token string, permissionsRequired []string) bool {
-	if len(token) == 0 {
-		return false
-	}
-	authorizationService.mutex.RLock()
-	client, _ := authorizationService.clients[token]
-	authorizationService.mutex.RUnlock()
-	// If there's no clients with the given token directly stored in the AuthorizationService, fall back to the
-	// client provider, if there's one configured.
-	if client == nil && authorizationService.clientProvider != nil {
-		client = authorizationService.clientProvider.GetClientByToken(token)
-	}
-	if client != nil {
-		return client.HasPermissions(permissionsRequired)
-	}
-	return false
-}

vendor/github.com/TwiN/g8/client.go

@@ -1,58 +0,0 @@
-package g8
-
-// Client is a struct containing both a Token and a slice of extra Permissions that said token has.
-type Client struct {
-	// Token is the value used to authenticate with the API.
-	Token string
-
-	// Permissions is a slice of extra permissions that may be used for more granular access control.
-	//
-	// If you only wish to use Gate.Protect and Gate.ProtectFunc, you do not have to worry about this,
-	// since they're only used by Gate.ProtectWithPermissions and Gate.ProtectFuncWithPermissions
-	Permissions []string
-}
-
-// NewClient creates a Client with a given token
-func NewClient(token string) *Client {
-	return &Client{
-		Token: token,
-	}
-}
-
-// NewClientWithPermissions creates a Client with a slice of permissions
-// Equivalent to using NewClient and WithPermissions
-func NewClientWithPermissions(token string, permissions []string) *Client {
-	return NewClient(token).WithPermissions(permissions)
-}
-
-// WithPermissions adds a slice of permissions to a client
-func (client *Client) WithPermissions(permissions []string) *Client {
-	client.Permissions = append(client.Permissions, permissions...)
-	return client
-}
-
-// WithPermission adds a permission to a client
-func (client *Client) WithPermission(permission string) *Client {
-	client.Permissions = append(client.Permissions, permission)
-	return client
-}
-
-// HasPermission checks whether a client has a given permission
-func (client Client) HasPermission(permissionRequired string) bool {
-	for _, permission := range client.Permissions {
-		if permissionRequired == permission {
-			return true
-		}
-	}
-	return false
-}
-
-// HasPermissions checks whether a client has the all permissions passed
-func (client Client) HasPermissions(permissionsRequired []string) bool {
-	for _, permissionRequired := range permissionsRequired {
-		if !client.HasPermission(permissionRequired) {
-			return false
-		}
-	}
-	return true
-}

vendor/github.com/TwiN/g8/clientprovider.go

@@ -1,140 +0,0 @@
-package g8
-
-import (
-	"errors"
-	"time"
-
-	"github.com/TwiN/gocache/v2"
-)
-
-var (
-	// ErrNoExpiration is the error returned by ClientProvider.StartCacheJanitor if there was an attempt to start the
-	// janitor despite no expiration being configured.
-	// To clarify, this is because the cache janitor is only useful when an expiration is set.
-	ErrNoExpiration = errors.New("no point starting the janitor if the TTL is set to not expire")
-
-	// ErrCacheNotInitialized is the error returned by ClientProvider.StartCacheJanitor if there was an attempt to start
-	// the janitor despite the cache not having been initialized using ClientProvider.WithCache
-	ErrCacheNotInitialized = errors.New("cannot start janitor because cache is not configured")
-)
-
-// ClientProvider has the task of retrieving a Client from an external source (e.g. a database) when provided with a
-// token. It should be used when you have a lot of tokens, and it wouldn't make sense to register all of them using
-// AuthorizationService's WithToken, WithTokens, WithClient or WithClients.
-//
-// Note that the provider is used as a fallback source. As such, if a token is explicitly registered using one of the 4
-// aforementioned functions, the client provider will not be used by the AuthorizationService when a request is made
-// with said token. It will, however, be called upon if a token that is not explicitly registered in
-// AuthorizationService is sent alongside a request going through the Gate.
-//
-//     clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-//         // We'll assume that the following function calls your database and returns a struct "User" that
-//         // has the user's token as well as the permissions granted to said user
-//         user := database.GetUserByToken(token)
-//         if user != nil {
-//             return g8.NewClient(user.Token).WithPermissions(user.Permissions)
-//         }
-//         return nil
-//     })
-//     gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider))
-//
-type ClientProvider struct {
-	getClientByTokenFunc func(token string) *Client
-
-	cache *gocache.Cache
-	ttl   time.Duration
-}
-
-// NewClientProvider creates a ClientProvider
-// The parameter that must be passed is a function that the provider will use to retrieve a client by a given token
-//
-// Example:
-//     clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-//         // We'll assume that the following function calls your database and returns a struct "User" that
-//         // has the user's token as well as the permissions granted to said user
-//         user := database.GetUserByToken(token)
-//         if user == nil {
-//             return nil
-//         }
-//         return g8.NewClient(user.Token).WithPermissions(user.Permissions)
-//     })
-//     gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider))
-//
-func NewClientProvider(getClientByTokenFunc func(token string) *Client) *ClientProvider {
-	return &ClientProvider{
-		getClientByTokenFunc: getClientByTokenFunc,
-	}
-}
-
-// WithCache adds cache options to the ClientProvider.
-//
-// ttl is the time until the cache entry will expire. A TTL of gocache.NoExpiration (-1) means no expiration
-// maxSize is the maximum amount of entries that can be in the cache at any given time.
-// If a value of gocache.NoMaxSize (0) or less is provided for maxSize, there will be no maximum size.
-//
-// Example:
-//     clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
-//         // We'll assume that the following function calls your database and returns a struct "User" that
-//         // has the user's token as well as the permissions granted to said user
-//         user := database.GetUserByToken(token)
-//         if user != nil {
-//             return g8.NewClient(user.Token).WithPermissions(user.Permissions)
-//         }
-//         return nil
-//     })
-//     gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider.WithCache(time.Hour, 70000)))
-//
-func (provider *ClientProvider) WithCache(ttl time.Duration, maxSize int) *ClientProvider {
-	provider.cache = gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(maxSize)
-	provider.ttl = ttl
-	return provider
-}
-
-// StartCacheJanitor starts the cache janitor, which passively deletes expired cache entries in the background.
-//
-// Not really necessary unless you have a lot of clients (100000+).
-//
-// Even without the janitor, active eviction will still happen (i.e. when GetClientByToken is called, but the cache
-// entry for the given token has expired, the cache entry will be automatically deleted and re-fetched from the
-// user-defined getClientByTokenFunc)
-func (provider *ClientProvider) StartCacheJanitor() error {
-	if provider.cache == nil {
-		// Can't start the cache janitor if there's no cache
-		return ErrCacheNotInitialized
-	}
-	if provider.ttl != gocache.NoExpiration {
-		return provider.cache.StartJanitor()
-	}
-	return ErrNoExpiration
-}
-
-// StopCacheJanitor stops the cache janitor
-//
-// Not required unless your application initializes multiple providers over the course of its lifecycle.
-// In English, that means if you initialize a ClientProvider only once on application start and it stays up
-// until your application shuts down, you don't need to call this function.
-func (provider *ClientProvider) StopCacheJanitor() {
-	if provider.cache != nil {
-		provider.cache.StopJanitor()
-	}
-}
-
-// GetClientByToken retrieves a client by its token through the provided getClientByTokenFunc.
-func (provider *ClientProvider) GetClientByToken(token string) *Client {
-	if provider.cache == nil {
-		return provider.getClientByTokenFunc(token)
-	}
-	if cachedClient, exists := provider.cache.Get(token); exists {
-		if cachedClient == nil {
-			return nil
-		}
-		// Safely typecast the client.
-		// Regardless of whether the typecast is successful or not, we return client since it'll be either client or
-		// nil. Technically, it should never be nil, but it's better to be safe than sorry.
-		client, _ := cachedClient.(*Client)
-		return client
-	}
-	client := provider.getClientByTokenFunc(token)
-	provider.cache.SetWithTTL(token, client, provider.ttl)
-	return client
-}

vendor/github.com/TwiN/g8/gate.go

@@ -1,238 +0,0 @@
-package g8
-
-import (
-	"context"
-	"net/http"
-	"strings"
-)
-
-const (
-	// AuthorizationHeader is the header in which g8 looks for the authorization bearer token
-	AuthorizationHeader = "Authorization"
-
-	// DefaultUnauthorizedResponseBody is the default response body returned if a request was sent with a missing or invalid token
-	DefaultUnauthorizedResponseBody = "token is missing or invalid"
-
-	// DefaultTooManyRequestsResponseBody is the default response body returned if a request exceeded the allowed rate limit
-	DefaultTooManyRequestsResponseBody = "too many requests"
-
-	// TokenContextKey is the key used to store the token in the context.
-	TokenContextKey = "g8.token"
-)
-
-// Gate is lock to the front door of your API, letting only those you allow through.
-type Gate struct {
-	authorizationService     *AuthorizationService
-	unauthorizedResponseBody []byte
-
-	customTokenExtractorFunc func(request *http.Request) string
-
-	rateLimiter                 *RateLimiter
-	tooManyRequestsResponseBody []byte
-}
-
-// Deprecated: use New instead.
-func NewGate(authorizationService *AuthorizationService) *Gate {
-	return &Gate{
-		authorizationService:        authorizationService,
-		unauthorizedResponseBody:    []byte(DefaultUnauthorizedResponseBody),
-		tooManyRequestsResponseBody: []byte(DefaultTooManyRequestsResponseBody),
-	}
-}
-
-// New creates a new Gate.
-func New() *Gate {
-	return &Gate{
-		unauthorizedResponseBody:    []byte(DefaultUnauthorizedResponseBody),
-		tooManyRequestsResponseBody: []byte(DefaultTooManyRequestsResponseBody),
-	}
-}
-
-// WithAuthorizationService sets the authorization service to use.
-//
-// If there is no authorization service, Gate will not enforce authorization.
-func (gate *Gate) WithAuthorizationService(authorizationService *AuthorizationService) *Gate {
-	gate.authorizationService = authorizationService
-	return gate
-}
-
-// WithCustomUnauthorizedResponseBody sets a custom response body when Gate determines that a request must be blocked
-func (gate *Gate) WithCustomUnauthorizedResponseBody(unauthorizedResponseBody []byte) *Gate {
-	gate.unauthorizedResponseBody = unauthorizedResponseBody
-	return gate
-}
-
-// WithCustomTokenExtractor allows the specification of a custom function to extract a token from a request.
-// If a custom token extractor is not specified, the token will be extracted from the Authorization header.
-//
-// For instance, if you're using a session cookie, you can extract the token from the cookie like so:
-//
-//	authorizationService := g8.NewAuthorizationService()
-//	customTokenExtractorFunc := func(request *http.Request) string {
-//		sessionCookie, err := request.Cookie("session")
-//		if err != nil {
-//			return ""
-//		}
-//		return sessionCookie.Value
-//	}
-//	gate := g8.New().WithAuthorizationService(authorizationService).WithCustomTokenExtractor(customTokenExtractorFunc)
-//
-// You would normally use this with a client provider that matches whatever need you have.
-// For example, if you're using a session cookie, your client provider would retrieve the user from the session ID
-// extracted by this custom token extractor.
-//
-// Note that for the sake of convenience, the token extracted from the request is passed the protected handlers request
-// context under the key TokenContextKey. This is especially useful if the token is in fact a session ID.
-func (gate *Gate) WithCustomTokenExtractor(customTokenExtractorFunc func(request *http.Request) string) *Gate {
-	gate.customTokenExtractorFunc = customTokenExtractorFunc
-	return gate
-}
-
-// WithRateLimit adds rate limiting to the Gate
-//
-// If you just want to use a gate for rate limiting purposes:
-//
-//	gate := g8.New().WithRateLimit(50)
-func (gate *Gate) WithRateLimit(maximumRequestsPerSecond int) *Gate {
-	gate.rateLimiter = NewRateLimiter(maximumRequestsPerSecond)
-	return gate
-}
-
-// Protect secures a handler, requiring requests going through to have a valid Authorization Bearer token.
-// Unlike ProtectWithPermissions, Protect will allow access to any registered tokens, regardless of their permissions
-// or lack thereof.
-//
-// Example:
-//
-//	gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithToken("token"))
-//	router := http.NewServeMux()
-//	// Without protection
-//	router.Handle("/handle", yourHandler)
-//	// With protection
-//	router.Handle("/handle", gate.Protect(yourHandler))
-//
-// The token extracted from the request is passed to the handlerFunc request context under the key TokenContextKey
-func (gate *Gate) Protect(handler http.Handler) http.Handler {
-	return gate.ProtectWithPermissions(handler, nil)
-}
-
-// ProtectWithPermissions secures a handler, requiring requests going through to have a valid Authorization Bearer token
-// as well as a slice of permissions that must be met.
-//
-// Example:
-//
-//	gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClient(g8.NewClient("token").WithPermission("ADMIN")))
-//	router := http.NewServeMux()
-//	// Without protection
-//	router.Handle("/handle", yourHandler)
-//	// With protection
-//	router.Handle("/handle", gate.ProtectWithPermissions(yourHandler, []string{"admin"}))
-//
-// The token extracted from the request is passed to the handlerFunc request context under the key TokenContextKey
-func (gate *Gate) ProtectWithPermissions(handler http.Handler, permissions []string) http.Handler {
-	return gate.ProtectFuncWithPermissions(func(writer http.ResponseWriter, request *http.Request) {
-		handler.ServeHTTP(writer, request)
-	}, permissions)
-}
-
-// ProtectWithPermission does the same thing as ProtectWithPermissions, but for a single permission instead of a
-// slice of permissions
-//
-// See ProtectWithPermissions for further documentation
-func (gate *Gate) ProtectWithPermission(handler http.Handler, permission string) http.Handler {
-	return gate.ProtectFuncWithPermissions(func(writer http.ResponseWriter, request *http.Request) {
-		handler.ServeHTTP(writer, request)
-	}, []string{permission})
-}
-
-// ProtectFunc secures a handlerFunc, requiring requests going through to have a valid Authorization Bearer token.
-// Unlike ProtectFuncWithPermissions, ProtectFunc will allow access to any registered tokens, regardless of their
-// permissions or lack thereof.
-//
-// Example:
-//
-//	gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithToken("token"))
-//	router := http.NewServeMux()
-//	// Without protection
-//	router.HandleFunc("/handle", yourHandlerFunc)
-//	// With protection
-//	router.HandleFunc("/handle", gate.ProtectFunc(yourHandlerFunc))
-//
-// The token extracted from the request is passed to the handlerFunc request context under the key TokenContextKey
-func (gate *Gate) ProtectFunc(handlerFunc http.HandlerFunc) http.HandlerFunc {
-	return gate.ProtectFuncWithPermissions(handlerFunc, nil)
-}
-
-// ProtectFuncWithPermissions secures a handler, requiring requests going through to have a valid Authorization Bearer
-// token as well as a slice of permissions that must be met.
-//
-// Example:
-//
-//	gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClient(g8.NewClient("token").WithPermission("admin")))
-//	router := http.NewServeMux()
-//	// Without protection
-//	router.HandleFunc("/handle", yourHandlerFunc)
-//	// With protection
-//	router.HandleFunc("/handle", gate.ProtectFuncWithPermissions(yourHandlerFunc, []string{"admin"}))
-//
-// The token extracted from the request is passed to the handlerFunc request context under the key TokenContextKey
-func (gate *Gate) ProtectFuncWithPermissions(handlerFunc http.HandlerFunc, permissions []string) http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		if gate.rateLimiter != nil {
-			if !gate.rateLimiter.Try() {
-				writer.WriteHeader(http.StatusTooManyRequests)
-				_, _ = writer.Write(gate.tooManyRequestsResponseBody)
-				return
-			}
-		}
-		if gate.authorizationService != nil {
-			token := gate.ExtractTokenFromRequest(request)
-			if !gate.authorizationService.IsAuthorized(token, permissions) {
-				writer.WriteHeader(http.StatusUnauthorized)
-				_, _ = writer.Write(gate.unauthorizedResponseBody)
-				return
-			}
-			request = request.WithContext(context.WithValue(request.Context(), TokenContextKey, token))
-		}
-		handlerFunc(writer, request)
-	}
-}
-
-// ProtectFuncWithPermission does the same thing as ProtectFuncWithPermissions, but for a single permission instead of a
-// slice of permissions
-//
-// See ProtectFuncWithPermissions for further documentation
-func (gate *Gate) ProtectFuncWithPermission(handlerFunc http.HandlerFunc, permission string) http.HandlerFunc {
-	return gate.ProtectFuncWithPermissions(handlerFunc, []string{permission})
-}
-
-// ExtractTokenFromRequest extracts a token from a request.
-//
-// By default, it extracts the bearer token from the AuthorizationHeader, but if a customTokenExtractorFunc is defined,
-// it will use that instead.
-//
-// Note that this method is internally used by Protect, ProtectWithPermission, ProtectFunc and
-// ProtectFuncWithPermissions, but it is exposed in case you need to use it directly.
-func (gate *Gate) ExtractTokenFromRequest(request *http.Request) string {
-	if gate.customTokenExtractorFunc != nil {
-		// A custom token extractor function is defined, so we'll use it instead of the default token extraction logic
-		return gate.customTokenExtractorFunc(request)
-	}
-	return strings.TrimPrefix(request.Header.Get(AuthorizationHeader), "Bearer ")
-}
-
-// PermissionMiddleware is a middleware that behaves like ProtectWithPermission, but it is meant to be used
-// as a middleware for libraries that support such a feature.
-//
-// For instance, if you are using github.com/gorilla/mux, you can use PermissionMiddleware like so:
-//
-//	router := mux.NewRouter()
-//	router.Use(gate.PermissionMiddleware("admin"))
-//	router.Handle("/admin/handle", adminHandler)
-//
-// If you do not want to protect a router with a specific permission, you can use Gate.Protect instead.
-func (gate *Gate) PermissionMiddleware(permissions ...string) func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return gate.ProtectWithPermissions(next, permissions)
-	}
-}

vendor/github.com/TwiN/g8/ratelimiter.go

@@ -1,42 +0,0 @@
-package g8
-
-import (
-	"sync"
-	"time"
-)
-
-// RateLimiter is a fixed rate limiter
-type RateLimiter struct {
-	maximumExecutionsPerSecond int
-	executionsLeftInWindow     int
-	windowStartTime            time.Time
-	mutex                      sync.Mutex
-}
-
-// NewRateLimiter creates a RateLimiter
-func NewRateLimiter(maximumExecutionsPerSecond int) *RateLimiter {
-	return &RateLimiter{
-		windowStartTime:            time.Now(),
-		executionsLeftInWindow:     maximumExecutionsPerSecond,
-		maximumExecutionsPerSecond: maximumExecutionsPerSecond,
-	}
-}
-
-// Try updates the number of executions if the rate limit quota hasn't been reached and returns whether the
-// attempt was successful or not.
-//
-// Returns false if the execution was not successful (rate limit quota has been reached)
-// Returns true if the execution was successful (rate limit quota has not been reached)
-func (r *RateLimiter) Try() bool {
-	r.mutex.Lock()
-	defer r.mutex.Unlock()
-	if time.Now().Add(-time.Second).After(r.windowStartTime) {
-		r.windowStartTime = time.Now()
-		r.executionsLeftInWindow = r.maximumExecutionsPerSecond
-	}
-	if r.executionsLeftInWindow == 0 {
-		return false
-	}
-	r.executionsLeftInWindow--
-	return true
-}

vendor/github.com/TwiN/gocache/v2/.gitattributes

@@ -1 +0,0 @@
-* text=lf

vendor/github.com/TwiN/gocache/v2/.gitignore

@@ -1 +0,0 @@
-.idea

vendor/github.com/TwiN/gocache/v2/LICENSE.md

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2022 TwiN
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/TwiN/gocache/v2/README.md

@@ -1,361 +0,0 @@
-# gocache
-![test](https://github.com/TwiN/gocache/workflows/test/badge.svg?branch=master) 
-[![Go Report Card](https://goreportcard.com/badge/github.com/TwiN/gocache)](https://goreportcard.com/report/github.com/TwiN/gocache)
-[![codecov](https://codecov.io/gh/TwiN/gocache/branch/master/graph/badge.svg)](https://codecov.io/gh/TwiN/gocache)
-[![Go version](https://img.shields.io/github/go-mod/go-version/TwiN/gocache.svg)](https://github.com/TwiN/gocache)
-[![Go Reference](https://pkg.go.dev/badge/github.com/TwiN/gocache.svg)](https://pkg.go.dev/github.com/TwiN/gocache/v2)
-[![Follow TwiN](https://img.shields.io/github/followers/TwiN?label=Follow&style=social)](https://github.com/TwiN)
-
-gocache is an easy-to-use, high-performance, lightweight and thread-safe (goroutine-safe) in-memory key-value cache 
-with support for LRU and FIFO eviction policies as well as expiration, bulk operations and even retrieval of keys by pattern.
-
-
-## Table of Contents
-
-- [Features](#features)
-- [Usage](#usage)
-  - [Initializing the cache](#initializing-the-cache)
-  - [Functions](#functions)
-  - [Examples](#examples)
-    - [Creating or updating an entry](#creating-or-updating-an-entry)
-    - [Getting an entry](#getting-an-entry)
-    - [Deleting an entry](#deleting-an-entry)
-    - [Complex example](#complex-example)
-- [Persistence](#persistence)
-- [Eviction](#eviction)
-  - [MaxSize](#maxsize)
-  - [MaxMemoryUsage](#maxmemoryusage)
-- [Expiration](#expiration)
-- [Performance](#performance)
-  - [Summary](#summary)
-  - [Results](#results)
-- [FAQ](#faq)
-  - [How can I persist the data on application termination?](#how-can-i-persist-the-data-on-application-termination)
-
-
-## Features
-gocache supports the following cache eviction policies: 
-- First in first out (FIFO)
-- Least recently used (LRU)
-
-It also supports cache entry TTL, which is both active and passive. Active expiration means that if you attempt 
-to retrieve a cache key that has already expired, it will delete it on the spot and the behavior will be as if
-the cache key didn't exist. As for passive expiration, there's a background task that will take care of deleting
-expired keys.
-
-It also includes what you'd expect from a cache, like GET/SET, bulk operations and get by pattern.
-
-
-## Usage
-```
-go get -u github.com/TwiN/gocache/v2
-```
-
-
-### Initializing the cache
-```go
-cache := gocache.NewCache().WithMaxSize(1000).WithEvictionPolicy(gocache.LeastRecentlyUsed)
-```
-
-If you're planning on using expiration (`SetWithTTL` or `Expire`) and you want expired entries to be automatically deleted 
-in the background, make sure to start the janitor when you instantiate the cache:
-
-```go
-cache.StartJanitor()
-```
-
-### Functions
-| Function                          | Description                                                                                                                                                                                                                                                        |
-|-----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| WithMaxSize                       | Sets the max size of the cache. `gocache.NoMaxSize` means there is no limit. If not set, the default max size is `gocache.DefaultMaxSize`.                                                                                                                         |
-| WithMaxMemoryUsage                | Sets the max memory usage of the cache. `gocache.NoMaxMemoryUsage` means there is no limit. The default behavior is to not evict based on memory usage.                                                                                                            |
-| WithEvictionPolicy                | Sets the eviction algorithm to be used when the cache reaches the max size. If not set, the default eviction policy is `gocache.FirstInFirstOut` (FIFO).                                                                                                           |
-| WithDefaultTTL                    | Sets the default TTL for each entry.                                                                                                                                                                                                                               |
-| WithForceNilInterfaceOnNilPointer | Configures whether values with a nil pointer passed to write functions should be forcefully set to nil. Defaults to true.                                                                                                                                          |
-| StartJanitor                      | Starts the janitor, which is in charge of deleting expired cache entries in the background.                                                                                                                                                                        |
-| StopJanitor                       | Stops the janitor.                                                                                                                                                                                                                                                 |
-| Set                               | Same as `SetWithTTL`, but using the default TTL (which is `gocache.NoExpiration`, unless configured otherwise).                                                                                                                                                    |
-| SetWithTTL                        | Creates or updates a cache entry with the given key, value and expiration time. If the max size after the aforementioned operation is above the configured max size, the tail will be evicted. Depending on the eviction policy, the tail is defined as the oldest |
-| SetAll                            | Same as `Set`, but in bulk.                                                                                                                                                                                                                                        |
-| SetAllWithTTL                     | Same as `SetWithTTL`, but in bulk.                                                                                                                                                                                                                                 |
-| Get                               | Gets a cache entry by its key.                                                                                                                                                                                                                                     |
-| GetByKeys                         | Gets a map of entries by their keys. The resulting map will contain all keys, even if some of the keys in the slice passed as parameter were not present in the cache.                                                                                             |
-| GetAll                            | Gets all cache entries.                                                                                                                                                                                                                                            |
-| GetKeysByPattern                  | Retrieves a slice of keys that matches a given pattern.                                                                                                                                                                                                            |
-| Delete                            | Removes a key from the cache.                                                                                                                                                                                                                                      |
-| DeleteAll                         | Removes multiple keys from the cache.                                                                                                                                                                                                                              |
-| DeleteKeysByPattern               | Removes all keys that that matches a given pattern.                                                                                                                                                                                                                |
-| Count                             | Gets the size of the cache. This includes cache keys which may have already expired, but have not been removed yet.                                                                                                                                                |
-| Clear                             | Wipes the cache.                                                                                                                                                                                                                                                   |
-| TTL                               | Gets the time until a cache key expires.                                                                                                                                                                                                                           |
-| Expire                            | Sets the expiration time of an existing cache key.                                                                                                                                                                                                                 |
-
-For further documentation, please refer to [Go Reference](https://pkg.go.dev/github.com/TwiN/gocache)
-
-
-### Examples
-
-#### Creating or updating an entry
-```go
-cache.Set("key", "value") 
-cache.Set("key", 1)
-cache.Set("key", struct{ Text string }{Test: "value"})
-cache.SetWithTTL("key", []byte("value"), 24*time.Hour)
-```
-
-#### Getting an entry
-```go
-value, exists := cache.Get("key")
-```
-You can also get multiple entries by using `cache.GetByKeys([]string{"key1", "key2"})`
-
-#### Deleting an entry
-```go
-cache.Delete("key")
-```
-You can also delete multiple entries by using `cache.DeleteAll([]string{"key1", "key2"})`
-
-#### Complex example
-```go
-package main
-
-import (
-    "fmt"
-    "time"
-
-    "github.com/TwiN/gocache/v2"
-)
-
-func main() {
-    cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(10000)
-    cache.StartJanitor() // Passively manages expired entries
-    defer cache.StopJanitor()
-
-    cache.Set("key", "value")
-    cache.SetWithTTL("key-with-ttl", "value", 60*time.Minute)
-    cache.SetAll(map[string]any{"k1": "v1", "k2": "v2", "k3": "v3"})
-
-    fmt.Println("[Count] Cache size:", cache.Count())
-
-    value, exists := cache.Get("key")
-    fmt.Printf("[Get] key=key; value=%s; exists=%v\n", value, exists)
-    for key, value := range cache.GetByKeys([]string{"k1", "k2", "k3"}) {
-        fmt.Printf("[GetByKeys] key=%s; value=%s\n", key, value)
-    }
-    for _, key := range cache.GetKeysByPattern("key*", 0) {
-        fmt.Printf("[GetKeysByPattern] pattern=key*; key=%s\n", key)
-    }
-
-    cache.Expire("key", time.Hour)
-    time.Sleep(500*time.Millisecond)
-    timeUntilExpiration, _ := cache.TTL("key")
-    fmt.Println("[TTL] Number of minutes before 'key' expires:", int(timeUntilExpiration.Seconds()))
-
-    cache.Delete("key")
-    cache.DeleteAll([]string{"k1", "k2", "k3"})
-    
-    cache.Clear()
-    fmt.Println("[Count] Cache size after clearing the cache:", cache.Count())
-}
-```
-
-<details>
-  <summary>Output</summary>
-
-```
-[Count] Cache size: 5
-[Get] key=key; value=value; exists=true
-[GetByKeys] key=k1; value=v1
-[GetByKeys] key=k2; value=v2
-[GetByKeys] key=k3; value=v3
-[GetKeysByPattern] pattern=key*; key=key-with-ttl
-[GetKeysByPattern] pattern=key*; key=key
-[TTL] Number of minutes before 'key' expires: 3599
-[Count] Cache size after clearing the cache: 0
-```
-</details>
-
-
-## Persistence
-Prior to v2, gocache supported persistence out of the box.
-
-After some thinking, I decided that persistence added too many dependencies, and given than this is a cache library
-and most people wouldn't be interested in persistence, I decided to get rid of it.
-
-That being said, you can use the `GetAll` and `SetAll` methods of `gocache.Cache` to implement persistence yourself.
-
-
-## Eviction
-### MaxSize
-Eviction by MaxSize is the default behavior, and is also the most efficient.
-
-The code below will create a cache that has a maximum size of 1000:
-```go
-cache := gocache.NewCache().WithMaxSize(1000)
-```
-This means that whenever an operation causes the total size of the cache to go above 1000, the tail will be evicted.
-
-### MaxMemoryUsage
-Eviction by MaxMemoryUsage is **disabled by default**, and is in alpha.
-
-The code below will create a cache that has a maximum memory usage of 50MB:
-```go
-cache := gocache.NewCache().WithMaxSize(0).WithMaxMemoryUsage(50*gocache.Megabyte)
-```
-This means that whenever an operation causes the total memory usage of the cache to go above 50MB, one or more tails
-will be evicted.
-
-Unlike evictions caused by reaching the MaxSize, evictions triggered by MaxMemoryUsage may lead to multiple entries
-being evicted in a row. The reason for this is that if, for instance, you had 100 entries of 0.1MB each and you suddenly added 
-a single entry of 10MB, 100 entries would need to be evicted to make enough space for that new big entry.
-
-It's very important to keep in mind that eviction by MaxMemoryUsage is approximate.
-
-**The only memory taken into consideration is the size of the cache, not the size of the entire application.**
-If you pass along 100MB worth of data in a matter of seconds, even though the cache's memory usage will remain
-under 50MB (or whatever you configure the MaxMemoryUsage to), the memory footprint generated by that 100MB will 
-still exist until the next GC cycle.
-
-As previously mentioned, this is a work in progress, and here's a list of the things you should keep in mind:
-- The memory usage of structs are a gross estimation and may not reflect the actual memory usage.
-- Native types (string, int, bool, []byte, etc.) are the most accurate for calculating the memory usage.
-- Adding an entry bigger than the configured MaxMemoryUsage will work, but it will evict all other entries.
-
-
-## Expiration
-There are two ways that the deletion of expired keys can take place:
-- Active
-- Passive
-
-**Active deletion of expired keys** happens when an attempt is made to access the value of a cache entry that expired. 
-`Get`, `GetByKeys` and `GetAll` are the only functions that can trigger active deletion of expired keys.
-
-**Passive deletion of expired keys** runs in the background and is managed by the janitor. 
-If you do not start the janitor, there will be no passive deletion of expired keys.
-
-
-## Performance
-### Summary
-- **Set**: Both map and gocache have the same performance.
-- **Get**: Map is faster than gocache.
-
-This is because gocache keeps track of the head and the tail for eviction and expiration/TTL. 
-
-Ultimately, the difference is negligible. 
-
-We could add a way to disable eviction or disable expiration altogether just to match the map's performance, 
-but if you're looking into using a library like gocache, odds are, you want more than just a map.
-
-
-### Results
-| key    | value    |
-|:-------|:---------|
-| goos   | windows  |
-| goarch | amd64    |
-| cpu    | i7-9700K |
-| mem    | 32G DDR4 |
-
-```
-// Normal map
-BenchmarkMap_Get-8                                                              49944228     24.2 ns/op      7 B/op   0 allocs/op
-BenchmarkMap_Set/small_value-8                                                   3939964    394.1 ns/op    188 B/op   2 allocs/op
-BenchmarkMap_Set/medium_value-8                                                  3868586    395.5 ns/op    191 B/op   2 allocs/op
-BenchmarkMap_Set/large_value-8                                                   3992138    385.3 ns/op    186 B/op   2 allocs/op
-// Gocache                                                                                               
-BenchmarkCache_Get/FirstInFirstOut-8                                            27907950     44.3 ns/op     7 B/op    0 allocs/op
-BenchmarkCache_Get/LeastRecentlyUsed-8                                          28211396     44.2 ns/op     7 B/op    0 allocs/op
-BenchmarkCache_Set/FirstInFirstOut_small_value-8                                 3139538    373.5 ns/op    185 B/op   3 allocs/op
-BenchmarkCache_Set/FirstInFirstOut_medium_value-8                                3099516    378.6 ns/op    186 B/op   3 allocs/op
-BenchmarkCache_Set/FirstInFirstOut_large_value-8                                 3086776    386.7 ns/op    186 B/op   3 allocs/op
-BenchmarkCache_Set/LeastRecentlyUsed_small_value-8                               3070555    379.0 ns/op    187 B/op   3 allocs/op
-BenchmarkCache_Set/LeastRecentlyUsed_medium_value-8                              3056928    383.8 ns/op    187 B/op   3 allocs/op
-BenchmarkCache_Set/LeastRecentlyUsed_large_value-8                               3108250    383.8 ns/op    186 B/op   3 allocs/op
-BenchmarkCache_SetUsingMaxMemoryUsage/medium_value-8                             2773315    449.0 ns/op    210 B/op   4 allocs/op
-BenchmarkCache_SetUsingMaxMemoryUsage/large_value-8                              2731818    440.0 ns/op    211 B/op   4 allocs/op
-BenchmarkCache_SetUsingMaxMemoryUsage/small_value-8                              2659296    446.8 ns/op    213 B/op   4 allocs/op
-BenchmarkCache_SetWithMaxSize/100_small_value-8                                  4848658    248.8 ns/op    114 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/10000_small_value-8                                4117632    293.7 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/100000_small_value-8                               3867402    313.0 ns/op    110 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/100_medium_value-8                                 4750057    250.1 ns/op    113 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/10000_medium_value-8                               4143772    294.5 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/100000_medium_value-8                              3768883    313.2 ns/op    111 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/100_large_value-8                                  4822646    251.1 ns/op    114 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/10000_large_value-8                                4154428    291.6 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSize/100000_large_value-8                               3897358    313.7 ns/op    110 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100_small_value-8                            4784180    254.2 ns/op    114 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/10000_small_value-8                          4067042    292.0 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100000_small_value-8                         3832760    313.8 ns/op    111 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100_medium_value-8                           4846706    252.2 ns/op    114 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/10000_medium_value-8                         4103817    292.5 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100000_medium_value-8                        3845623    315.1 ns/op    111 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100_large_value-8                            4744513    257.9 ns/op    114 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/10000_large_value-8                          3956316    299.5 ns/op    106 B/op   3 allocs/op
-BenchmarkCache_SetWithMaxSizeAndLRU/100000_large_value-8                         3876843    351.3 ns/op    110 B/op   3 allocs/op
-BenchmarkCache_GetSetMultipleConcurrent-8                                         750088   1566.0 ns/op    128 B/op   8 allocs/op
-BenchmarkCache_GetSetConcurrentWithFrequentEviction/FirstInFirstOut-8            3836961    316.2 ns/op     80 B/op   1 allocs/op
-BenchmarkCache_GetSetConcurrentWithFrequentEviction/LeastRecentlyUsed-8          3846165    315.6 ns/op     80 B/op   1 allocs/op
-BenchmarkCache_GetConcurrently/FirstInFirstOut-8                                 4830342    239.8 ns/op      8 B/op   1 allocs/op
-BenchmarkCache_GetConcurrently/LeastRecentlyUsed-8                               4895587    243.2 ns/op      8 B/op   1 allocs/op
-(Trimmed "BenchmarkCache_" for readability)                                                              
-WithForceNilInterfaceOnNilPointer/true_with_nil_struct_pointer-8                 6901461    178.5 ns/op      7 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointer/true-8                                         6629566    180.7 ns/op      7 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointer/false_with_nil_struct_pointer-8                6282798    170.1 ns/op      7 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointer/false-8                                        6741382    172.6 ns/op      7 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointerWithConcurrency/true_with_nil_struct_pointer-8  4432951    258.0 ns/op      8 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointerWithConcurrency/true-8                          4676943    244.4 ns/op      8 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointerWithConcurrency/false_with_nil_struct_pointer-8 4818418    239.6 ns/op      8 B/op   1 allocs/op
-WithForceNilInterfaceOnNilPointerWithConcurrency/false-8                         5025937    238.2 ns/op      8 B/op   1 allocs/op
-```
-
-
-## FAQ
-
-### How can I persist the data on application termination?
-While creating your own auto save feature might come in handy, it may still lead to loss of data if the application 
-automatically saves every 10 minutes and your application crashes 9 minutes after the previous save.
-
-To increase your odds of not losing any data, you can use Go's `signal` package, more specifically its `Notify` function
-which allows listening for termination signals like SIGTERM and SIGINT. Once a termination signal is caught, you can
-add the necessary logic for a graceful shutdown.
-
-In the following example, the code that would usually be present in the `main` function is moved to a different function
-named `Start` which is launched on a different goroutine so that listening for a termination signals is what blocks the
-main goroutine instead:
-```go
-package main
-
-import (
-    "log"
-    "os"
-    "os/signal"
-    "syscall"
-
-    "github.com/TwiN/gocache/v2"
-)
-
-var cache = gocache.NewCache()
-
-func main() {
-    data := retrieveCacheEntriesUsingWhateverMeanYouUsedToPersistIt()
-    cache.SetAll(data)
-    // Start everything else on another goroutine to prevent blocking the main goroutine
-    go Start()
-    // Wait for termination signal
-    sig := make(chan os.Signal, 1)
-    done := make(chan bool, 1)
-    signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
-    go func() {
-        <-sig
-        log.Println("Received termination signal, attempting to gracefully shut down")
-        // Persist the cache entries
-        cacheEntries := cache.GetAll()
-        persistCacheEntriesHoweverYouWant(cacheEntries)
-        // Tell the main goroutine that we're done
-        done <- true
-    }()
-    <-done
-    log.Println("Shutting down")
-}
-```
-
-Note that this won't protect you from a SIGKILL, as this signal cannot be caught.

vendor/github.com/TwiN/gocache/v2/entry.go

@@ -1,108 +0,0 @@
-package gocache
-
-import (
-	"fmt"
-	"time"
-	"unsafe"
-)
-
-// Entry is a cache entry
-type Entry struct {
-	// Key is the name of the cache entry
-	Key string
-
-	// Value is the value of the cache entry
-	Value any
-
-	// RelevantTimestamp is the variable used to store either:
-	// - creation timestamp, if the Cache's EvictionPolicy is FirstInFirstOut
-	// - last access timestamp, if the Cache's EvictionPolicy is LeastRecentlyUsed
-	//
-	// Note that updating an existing entry will also update this value
-	RelevantTimestamp time.Time
-
-	// Expiration is the unix time in nanoseconds at which the entry will expire (-1 means no expiration)
-	Expiration int64
-
-	next     *Entry
-	previous *Entry
-}
-
-// Accessed updates the Entry's RelevantTimestamp to now
-func (entry *Entry) Accessed() {
-	entry.RelevantTimestamp = time.Now()
-}
-
-// Expired returns whether the Entry has expired
-func (entry Entry) Expired() bool {
-	if entry.Expiration > 0 {
-		if time.Now().UnixNano() > entry.Expiration {
-			return true
-		}
-	}
-	return false
-}
-
-// SizeInBytes returns the size of an entry in bytes, approximately.
-func (entry *Entry) SizeInBytes() int {
-	return toBytes(entry.Key) + toBytes(entry.Value) + 32
-}
-
-func toBytes(value any) int {
-	switch value.(type) {
-	case string:
-		return int(unsafe.Sizeof(value)) + len(value.(string))
-	case int8, uint8, bool:
-		return int(unsafe.Sizeof(value)) + 1
-	case int16, uint16:
-		return int(unsafe.Sizeof(value)) + 2
-	case int32, uint32, float32, complex64:
-		return int(unsafe.Sizeof(value)) + 4
-	case int64, uint64, int, uint, float64, complex128:
-		return int(unsafe.Sizeof(value)) + 8
-	case []any:
-		size := 0
-		for _, v := range value.([]any) {
-			size += toBytes(v)
-		}
-		return int(unsafe.Sizeof(value)) + size
-	case []string:
-		size := 0
-		for _, v := range value.([]string) {
-			size += toBytes(v)
-		}
-		return int(unsafe.Sizeof(value)) + size
-	case []int8:
-		return int(unsafe.Sizeof(value)) + len(value.([]int8))
-	case []uint8:
-		return int(unsafe.Sizeof(value)) + len(value.([]uint8))
-	case []bool:
-		return int(unsafe.Sizeof(value)) + len(value.([]bool))
-	case []int16:
-		return int(unsafe.Sizeof(value)) + (len(value.([]int16)) * 2)
-	case []uint16:
-		return int(unsafe.Sizeof(value)) + (len(value.([]uint16)) * 2)
-	case []int32:
-		return int(unsafe.Sizeof(value)) + (len(value.([]int32)) * 4)
-	case []uint32:
-		return int(unsafe.Sizeof(value)) + (len(value.([]uint32)) * 4)
-	case []float32:
-		return int(unsafe.Sizeof(value)) + (len(value.([]float32)) * 4)
-	case []complex64:
-		return int(unsafe.Sizeof(value)) + (len(value.([]complex64)) * 4)
-	case []int64:
-		return int(unsafe.Sizeof(value)) + (len(value.([]int64)) * 8)
-	case []uint64:
-		return int(unsafe.Sizeof(value)) + (len(value.([]uint64)) * 8)
-	case []int:
-		return int(unsafe.Sizeof(value)) + (len(value.([]int)) * 8)
-	case []uint:
-		return int(unsafe.Sizeof(value)) + (len(value.([]uint)) * 8)
-	case []float64:
-		return int(unsafe.Sizeof(value)) + (len(value.([]float64)) * 8)
-	case []complex128:
-		return int(unsafe.Sizeof(value)) + (len(value.([]complex128)) * 8)
-	default:
-		return int(unsafe.Sizeof(value)) + len(fmt.Sprintf("%v", value))
-	}
-}

vendor/github.com/TwiN/gocache/v2/gocache.go

@@ -1,599 +0,0 @@
-package gocache
-
-import (
-	"errors"
-	"reflect"
-	"sync"
-	"time"
-)
-
-var (
-	Debug = false
-)
-
-const (
-	// NoMaxSize means that the cache has no maximum number of entries in the cache
-	// Setting Cache.maxSize to this value also means there will be no eviction
-	NoMaxSize = 0
-
-	// NoMaxMemoryUsage means that the cache has no maximum number of entries in the cache
-	NoMaxMemoryUsage = 0
-
-	// DefaultMaxSize is the max size set if no max size is specified
-	DefaultMaxSize = 100000
-
-	// NoExpiration is the value that must be used as TTL to specify that the given key should never expire
-	NoExpiration = -1
-
-	Kilobyte = 1024
-	Megabyte = 1024 * Kilobyte
-	Gigabyte = 1024 * Megabyte
-)
-
-var (
-	ErrKeyDoesNotExist       = errors.New("key does not exist")         // Returned when a cache key does not exist
-	ErrKeyHasNoExpiration    = errors.New("key has no expiration")      // Returned when a cache key has no expiration
-	ErrJanitorAlreadyRunning = errors.New("janitor is already running") // Returned when the janitor has already been started
-)
-
-// Cache is the core struct of gocache which contains the data as well as all relevant configuration fields
-//
-// Do not instantiate this struct directly, use NewCache instead
-type Cache struct {
-	// maxSize is the maximum amount of entries that can be in the cache at any given time
-	// By default, this is set to DefaultMaxSize
-	maxSize int
-
-	// maxMemoryUsage is the maximum amount of memory that can be taken up by the cache at any time
-	// By default, this is set to NoMaxMemoryUsage, meaning that the default behavior is to not evict
-	// based on maximum memory usage
-	maxMemoryUsage int
-
-	// evictionPolicy is the eviction policy
-	evictionPolicy EvictionPolicy
-
-	// defaultTTL is the default TTL for each entry
-	// Defaults to NoExpiration
-	defaultTTL time.Duration
-
-	// stats is the object that contains cache statistics/metrics
-	stats *Statistics
-
-	// entries is the content of the cache
-	entries map[string]*Entry
-
-	// mutex is the lock for making concurrent operations on the cache
-	mutex sync.RWMutex
-
-	// head is the cache entry at the head of the cache
-	head *Entry
-
-	// tail is the last cache node and also the next entry that will be evicted
-	tail *Entry
-
-	// stopJanitor is the channel used to stop the janitor
-	stopJanitor chan bool
-
-	// memoryUsage is the approximate memory usage of the cache (dataset only) in bytes
-	memoryUsage int
-
-	// forceNilInterfaceOnNilPointer determines whether all Set-like functions should set a value as nil if the
-	// interface passed has a nil value but not a nil type.
-	//
-	// By default, interfaces are only nil when both their type and value is nil.
-	// This means that when you pass a pointer to a nil value, the type of the interface
-	// will still show as nil, which means that if you don't cast the interface after
-	// retrieving it, a nil check will return that the value is not false.
-	forceNilInterfaceOnNilPointer bool
-}
-
-// MaxSize returns the maximum amount of keys that can be present in the cache before
-// new entries trigger the eviction of the tail
-func (cache *Cache) MaxSize() int {
-	return cache.maxSize
-}
-
-// MaxMemoryUsage returns the configured maxMemoryUsage of the cache
-func (cache *Cache) MaxMemoryUsage() int {
-	return cache.maxMemoryUsage
-}
-
-// EvictionPolicy returns the EvictionPolicy of the Cache
-func (cache *Cache) EvictionPolicy() EvictionPolicy {
-	return cache.evictionPolicy
-}
-
-// Stats returns statistics from the cache
-func (cache *Cache) Stats() Statistics {
-	cache.mutex.RLock()
-	stats := Statistics{
-		EvictedKeys: cache.stats.EvictedKeys,
-		ExpiredKeys: cache.stats.ExpiredKeys,
-		Hits:        cache.stats.Hits,
-		Misses:      cache.stats.Misses,
-	}
-	cache.mutex.RUnlock()
-	return stats
-}
-
-// MemoryUsage returns the current memory usage of the cache's dataset in bytes
-// If MaxMemoryUsage is set to NoMaxMemoryUsage, this will return 0
-func (cache *Cache) MemoryUsage() int {
-	return cache.memoryUsage
-}
-
-// WithMaxSize sets the maximum amount of entries that can be in the cache at any given time
-// A maxSize of 0 or less means infinite
-func (cache *Cache) WithMaxSize(maxSize int) *Cache {
-	if maxSize < 0 {
-		maxSize = NoMaxSize
-	}
-	if maxSize != NoMaxSize && cache.Count() == 0 {
-		cache.entries = make(map[string]*Entry, maxSize)
-	}
-	cache.maxSize = maxSize
-	return cache
-}
-
-// WithMaxMemoryUsage sets the maximum amount of memory that can be used by the cache at any given time
-//
-// NOTE: This is approximate.
-//
-// Setting this to NoMaxMemoryUsage will disable eviction by memory usage
-func (cache *Cache) WithMaxMemoryUsage(maxMemoryUsageInBytes int) *Cache {
-	if maxMemoryUsageInBytes < 0 {
-		maxMemoryUsageInBytes = NoMaxMemoryUsage
-	}
-	cache.maxMemoryUsage = maxMemoryUsageInBytes
-	return cache
-}
-
-// WithEvictionPolicy sets eviction algorithm.
-//
-// Defaults to FirstInFirstOut (FIFO)
-func (cache *Cache) WithEvictionPolicy(policy EvictionPolicy) *Cache {
-	cache.evictionPolicy = policy
-	return cache
-}
-
-// WithDefaultTTL sets the default TTL for each entry (unless a different TTL is specified using SetWithTTL or SetAllWithTTL)
-//
-// Defaults to NoExpiration (-1)
-func (cache *Cache) WithDefaultTTL(ttl time.Duration) *Cache {
-	if ttl > 1 {
-		cache.defaultTTL = ttl
-	}
-	return cache
-}
-
-// WithForceNilInterfaceOnNilPointer sets whether all Set-like functions should set a value as nil if the
-// interface passed has a nil value but not a nil type.
-//
-// In Go, an interface is only nil if both its type and value are nil, which means that a nil pointer
-// (e.g. (*Struct)(nil)) will retain its attribution to the type, and the unmodified value returned from
-// Cache.Get, for instance, would return false when compared with nil if this option is set to false.
-//
-// We can bypass this by detecting if the interface's value is nil and setting it to nil rather than
-// a nil pointer, which will make the value returned from Cache.Get return true when compared with nil.
-// This is exactly what passing true to WithForceNilInterfaceOnNilPointer does, and it's also the default behavior.
-//
-// Alternatively, you may pass false to WithForceNilInterfaceOnNilPointer, which will mean that you'll have
-// to cast the value returned from Cache.Get to its original type to check for whether the pointer returned
-// is nil or not.
-//
-// If set to true (default):
-//
-//	cache := gocache.NewCache().WithForceNilInterfaceOnNilPointer(true)
-//	cache.Set("key", (*Struct)(nil))
-//	value, _ := cache.Get("key")
-//	// the following returns true, because the interface{} (any) was forcefully set to nil
-//	if value == nil {}
-//	// the following will panic, because the value has been casted to its type (which is nil)
-//	if value.(*Struct) == nil {}
-//
-// If set to false:
-//
-//	cache := gocache.NewCache().WithForceNilInterfaceOnNilPointer(false)
-//	cache.Set("key", (*Struct)(nil))
-//	value, _ := cache.Get("key")
-//	// the following returns false, because the interface{} (any) returned has a non-nil type (*Struct)
-//	if value == nil {}
-//	// the following returns true, because the value has been cast to its type
-//	if value.(*Struct) == nil {}
-//
-// In other words, if set to true, you do not need to cast the value returned from the cache to
-// check if the value is nil.
-//
-// Defaults to true
-func (cache *Cache) WithForceNilInterfaceOnNilPointer(forceNilInterfaceOnNilPointer bool) *Cache {
-	cache.forceNilInterfaceOnNilPointer = forceNilInterfaceOnNilPointer
-	return cache
-}
-
-// NewCache creates a new Cache
-//
-// Should be used in conjunction with Cache.WithMaxSize, Cache.WithMaxMemoryUsage and/or Cache.WithEvictionPolicy
-//
-//	gocache.NewCache().WithMaxSize(10000).WithEvictionPolicy(gocache.LeastRecentlyUsed)
-func NewCache() *Cache {
-	return &Cache{
-		maxSize:                       DefaultMaxSize,
-		evictionPolicy:                FirstInFirstOut,
-		defaultTTL:                    NoExpiration,
-		stats:                         &Statistics{},
-		entries:                       make(map[string]*Entry),
-		mutex:                         sync.RWMutex{},
-		stopJanitor:                   nil,
-		forceNilInterfaceOnNilPointer: true,
-	}
-}
-
-// Set creates or updates a key with a given value
-func (cache *Cache) Set(key string, value any) {
-	cache.SetWithTTL(key, value, cache.defaultTTL)
-}
-
-// SetWithTTL creates or updates a key with a given value and sets an expiration time (-1 is NoExpiration)
-//
-// The TTL provided must be greater than 0, or NoExpiration (-1). If a negative value that isn't -1 (NoExpiration) is
-// provided, the entry will not be created if the key doesn't exist
-func (cache *Cache) SetWithTTL(key string, value any, ttl time.Duration) {
-	// An interface is only nil if both its value and its type are nil, however, passing a nil pointer as an interface{}
-	// means that the interface itself is not nil, because the interface value is nil but not the type.
-	if cache.forceNilInterfaceOnNilPointer {
-		if value != nil && (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
-			value = nil
-		}
-	}
-	cache.mutex.Lock()
-	entry, ok := cache.get(key)
-	if !ok {
-		// A negative TTL that isn't -1 (NoExpiration) or 0 is an entry that will expire instantly,
-		// so might as well just not create it in the first place
-		if ttl != NoExpiration && ttl < 1 {
-			cache.mutex.Unlock()
-			return
-		}
-		// Cache entry doesn't exist, so we have to create a new one
-		entry = &Entry{
-			Key:               key,
-			Value:             value,
-			RelevantTimestamp: time.Now(),
-			next:              cache.head,
-		}
-		if cache.head == nil {
-			cache.tail = entry
-		} else {
-			cache.head.previous = entry
-		}
-		cache.head = entry
-		cache.entries[key] = entry
-		if cache.maxMemoryUsage != NoMaxMemoryUsage {
-			cache.memoryUsage += entry.SizeInBytes()
-		}
-	} else {
-		// A negative TTL that isn't -1 (NoExpiration) or 0 is an entry that will expire instantly,
-		// so might as well just delete it immediately instead of updating it
-		if ttl != NoExpiration && ttl < 1 {
-			cache.delete(key)
-			cache.mutex.Unlock()
-			return
-		}
-		if cache.maxMemoryUsage != NoMaxMemoryUsage {
-			// Subtract the old entry from the cache's memoryUsage
-			cache.memoryUsage -= entry.SizeInBytes()
-		}
-		// Update existing entry's value
-		entry.Value = value
-		entry.RelevantTimestamp = time.Now()
-		if cache.maxMemoryUsage != NoMaxMemoryUsage {
-			// Add the memory usage of the new entry to the cache's memoryUsage
-			cache.memoryUsage += entry.SizeInBytes()
-		}
-		// Because we just updated the entry, we need to move it back to HEAD
-		cache.moveExistingEntryToHead(entry)
-	}
-	if ttl != NoExpiration {
-		entry.Expiration = time.Now().Add(ttl).UnixNano()
-	} else {
-		entry.Expiration = NoExpiration
-	}
-	// If the cache doesn't have a maxSize/maxMemoryUsage, then there's no point
-	// checking if we need to evict an entry, so we'll just return now
-	if cache.maxSize == NoMaxSize && cache.maxMemoryUsage == NoMaxMemoryUsage {
-		cache.mutex.Unlock()
-		return
-	}
-	// If there's a maxSize and the cache has more entries than the maxSize, evict
-	if cache.maxSize != NoMaxSize && len(cache.entries) > cache.maxSize {
-		cache.evict()
-	}
-	// If there's a maxMemoryUsage and the memoryUsage is above the maxMemoryUsage, evict
-	if cache.maxMemoryUsage != NoMaxMemoryUsage && cache.memoryUsage > cache.maxMemoryUsage {
-		for cache.memoryUsage > cache.maxMemoryUsage && len(cache.entries) > 0 {
-			cache.evict()
-		}
-	}
-	cache.mutex.Unlock()
-}
-
-// SetAll creates or updates multiple values
-func (cache *Cache) SetAll(entries map[string]any) {
-	cache.SetAllWithTTL(entries, cache.defaultTTL)
-}
-
-// SetAllWithTTL creates or updates multiple values
-func (cache *Cache) SetAllWithTTL(entries map[string]any, ttl time.Duration) {
-	for key, value := range entries {
-		cache.SetWithTTL(key, value, ttl)
-	}
-}
-
-// Get retrieves an entry using the key passed as parameter
-// If there is no such entry, the value returned will be nil and the boolean will be false
-// If there is an entry, the value returned will be the value cached and the boolean will be true
-func (cache *Cache) Get(key string) (any, bool) {
-	cache.mutex.Lock()
-	entry, ok := cache.get(key)
-	if !ok {
-		cache.stats.Misses++
-		cache.mutex.Unlock()
-		return nil, false
-	}
-	if entry.Expired() {
-		cache.stats.ExpiredKeys++
-		cache.delete(key)
-		cache.mutex.Unlock()
-		return nil, false
-	}
-	cache.stats.Hits++
-	if cache.evictionPolicy == LeastRecentlyUsed {
-		entry.Accessed()
-		if cache.head == entry {
-			cache.mutex.Unlock()
-			return entry.Value, true
-		}
-		// Because the eviction policy is LRU, we need to move the entry back to HEAD
-		cache.moveExistingEntryToHead(entry)
-	}
-	cache.mutex.Unlock()
-	return entry.Value, true
-}
-
-// GetValue retrieves an entry using the key passed as parameter
-// Unlike Get, this function only returns the value
-func (cache *Cache) GetValue(key string) any {
-	value, _ := cache.Get(key)
-	return value
-}
-
-// GetByKeys retrieves multiple entries using the keys passed as parameter
-// All keys are returned in the map, regardless of whether they exist or not, however, entries that do not exist in the
-// cache will return nil, meaning that there is no way of determining whether a key genuinely has the value nil, or
-// whether it doesn't exist in the cache using only this function.
-func (cache *Cache) GetByKeys(keys []string) map[string]any {
-	entries := make(map[string]any)
-	for _, key := range keys {
-		entries[key], _ = cache.Get(key)
-	}
-	return entries
-}
-
-// GetAll retrieves all cache entries
-//
-// If the eviction policy is LeastRecentlyUsed, note that unlike Get and GetByKeys, this does not update the last access
-// timestamp. The reason for this is that since all cache entries will be accessed, updating the last access timestamp
-// would provide very little benefit while harming the ability to accurately determine the next key that will be evicted
-//
-// You should probably avoid using this if you have a lot of entries.
-//
-// GetKeysByPattern is a good alternative if you want to retrieve entries that you do not have the key for, as it only
-// retrieves the keys and does not trigger active eviction and has a parameter for setting a limit to the number of keys
-// you wish to retrieve.
-func (cache *Cache) GetAll() map[string]any {
-	entries := make(map[string]any)
-	cache.mutex.Lock()
-	for key, entry := range cache.entries {
-		if entry.Expired() {
-			cache.delete(key)
-			continue
-		}
-		entries[key] = entry.Value
-	}
-	cache.stats.Hits += uint64(len(entries))
-	cache.mutex.Unlock()
-	return entries
-}
-
-// GetKeysByPattern retrieves a slice of keys that match a given pattern
-// If the limit is set to 0, the entire cache will be searched for matching keys.
-// If the limit is above 0, the search will stop once the specified number of matching keys have been found.
-//
-// e.g.
-//
-//	cache.GetKeysByPattern("*some*", 0) will return all keys containing "some" in them
-//	cache.GetKeysByPattern("*some*", 5) will return 5 keys (or less) containing "some" in them
-//
-// Note that GetKeysByPattern does not trigger active evictions, nor does it count as accessing the entry (if LRU).
-// The reason for that behavior is that these two (active eviction and access) only applies when you access the value
-// of the cache entry, and this function only returns the keys.
-func (cache *Cache) GetKeysByPattern(pattern string, limit int) []string {
-	var matchingKeys []string
-	cache.mutex.Lock()
-	for key, value := range cache.entries {
-		if value.Expired() {
-			continue
-		}
-		if MatchPattern(pattern, key) {
-			matchingKeys = append(matchingKeys, key)
-			if limit > 0 && len(matchingKeys) >= limit {
-				break
-			}
-		}
-	}
-	cache.mutex.Unlock()
-	return matchingKeys
-}
-
-// Delete removes a key from the cache
-//
-// Returns false if the key did not exist.
-func (cache *Cache) Delete(key string) bool {
-	cache.mutex.Lock()
-	ok := cache.delete(key)
-	cache.mutex.Unlock()
-	return ok
-}
-
-// DeleteAll deletes multiple entries based on the keys passed as parameter
-//
-// Returns the number of keys deleted
-func (cache *Cache) DeleteAll(keys []string) int {
-	numberOfKeysDeleted := 0
-	cache.mutex.Lock()
-	for _, key := range keys {
-		if cache.delete(key) {
-			numberOfKeysDeleted++
-		}
-	}
-	cache.mutex.Unlock()
-	return numberOfKeysDeleted
-}
-
-// DeleteKeysByPattern deletes all entries matching a given key pattern and returns the number of entries deleted.
-//
-// Note that DeleteKeysByPattern does not trigger active evictions, nor does it count as accessing the entry (if LRU).
-func (cache *Cache) DeleteKeysByPattern(pattern string) int {
-	return cache.DeleteAll(cache.GetKeysByPattern(pattern, 0))
-}
-
-// Count returns the total amount of entries in the cache, regardless of whether they're expired or not
-func (cache *Cache) Count() int {
-	cache.mutex.RLock()
-	count := len(cache.entries)
-	cache.mutex.RUnlock()
-	return count
-}
-
-// Clear deletes all entries from the cache
-func (cache *Cache) Clear() {
-	cache.mutex.Lock()
-	cache.entries = make(map[string]*Entry)
-	cache.memoryUsage = 0
-	cache.head = nil
-	cache.tail = nil
-	cache.mutex.Unlock()
-}
-
-// TTL returns the time until the cache entry specified by the key passed as parameter
-// will be deleted.
-func (cache *Cache) TTL(key string) (time.Duration, error) {
-	cache.mutex.RLock()
-	entry, ok := cache.get(key)
-	cache.mutex.RUnlock()
-	if !ok {
-		return 0, ErrKeyDoesNotExist
-	}
-	if entry.Expiration == NoExpiration {
-		return 0, ErrKeyHasNoExpiration
-	}
-	timeUntilExpiration := time.Until(time.Unix(0, entry.Expiration))
-	if timeUntilExpiration < 0 {
-		// The key has already expired but hasn't been deleted yet.
-		// From the client's perspective, this means that the cache entry doesn't exist
-		return 0, ErrKeyDoesNotExist
-	}
-	return timeUntilExpiration, nil
-}
-
-// Expire sets a key's expiration time
-//
-// A TTL of -1 means that the key will never expire
-// A TTL of 0 means that the key will expire immediately
-// If using LRU, note that this does not reset the position of the key
-//
-// Returns true if the cache key exists and has had its expiration time altered
-func (cache *Cache) Expire(key string, ttl time.Duration) bool {
-	entry, ok := cache.get(key)
-	if !ok || entry.Expired() {
-		return false
-	}
-	if ttl != NoExpiration {
-		entry.Expiration = time.Now().Add(ttl).UnixNano()
-	} else {
-		entry.Expiration = NoExpiration
-	}
-	return true
-}
-
-// get retrieves an entry using the key passed as parameter, but unlike Get, it doesn't update the access time or
-// move the position of the entry to the head
-func (cache *Cache) get(key string) (*Entry, bool) {
-	entry, ok := cache.entries[key]
-	return entry, ok
-}
-
-func (cache *Cache) delete(key string) bool {
-	entry, ok := cache.entries[key]
-	if ok {
-		if cache.maxMemoryUsage != NoMaxMemoryUsage {
-			cache.memoryUsage -= entry.SizeInBytes()
-		}
-		cache.removeExistingEntryReferences(entry)
-		delete(cache.entries, key)
-	}
-	return ok
-}
-
-// moveExistingEntryToHead replaces the current cache head for an existing entry
-func (cache *Cache) moveExistingEntryToHead(entry *Entry) {
-	if !(entry == cache.head && entry == cache.tail) {
-		cache.removeExistingEntryReferences(entry)
-	}
-	if entry != cache.head {
-		entry.next = cache.head
-		entry.previous = nil
-		if cache.head != nil {
-			cache.head.previous = entry
-		}
-		cache.head = entry
-	}
-}
-
-// removeExistingEntryReferences modifies the next and previous reference of an existing entry and re-links
-// the next and previous entry accordingly, as well as the cache head or/and the cache tail if necessary.
-// Note that it does not remove the entry from the cache, only the references.
-func (cache *Cache) removeExistingEntryReferences(entry *Entry) {
-	if cache.tail == entry && cache.head == entry {
-		cache.tail = nil
-		cache.head = nil
-	} else if cache.tail == entry {
-		cache.tail = cache.tail.previous
-	} else if cache.head == entry {
-		cache.head = cache.head.next
-	}
-	if entry.previous != nil {
-		entry.previous.next = entry.next
-	}
-	if entry.next != nil {
-		entry.next.previous = entry.previous
-	}
-	entry.next = nil
-	entry.previous = nil
-}
-
-// evict removes the tail from the cache
-func (cache *Cache) evict() {
-	if cache.tail == nil || len(cache.entries) == 0 {
-		return
-	}
-	if cache.tail != nil {
-		oldTail := cache.tail
-		cache.removeExistingEntryReferences(oldTail)
-		delete(cache.entries, oldTail.Key)
-		if cache.maxMemoryUsage != NoMaxMemoryUsage {
-			cache.memoryUsage -= oldTail.SizeInBytes()
-		}
-		cache.stats.EvictedKeys++
-	}
-}

vendor/github.com/TwiN/gocache/v2/janitor.go

@@ -1,146 +0,0 @@
-package gocache
-
-import (
-	"log"
-	"time"
-)
-
-const (
-	// JanitorShiftTarget is the target number of expired keys to find during passive clean up duty
-	// before pausing the passive expired keys eviction process
-	JanitorShiftTarget = 25
-
-	// JanitorMaxIterationsPerShift is the maximum number of nodes to traverse before pausing
-	//
-	// This is to prevent the janitor from traversing the entire cache, which could take a long time
-	// to complete depending on the size of the cache.
-	//
-	// By limiting it to a small number, we are effectively reducing the impact of passive eviction.
-	JanitorMaxIterationsPerShift = 1000
-
-	// JanitorMinShiftBackOff is the minimum interval between each iteration of steps
-	// defined by JanitorMaxIterationsPerShift
-	JanitorMinShiftBackOff = 50 * time.Millisecond
-
-	// JanitorMaxShiftBackOff is the maximum interval between each iteration of steps
-	// defined by JanitorMaxIterationsPerShift
-	JanitorMaxShiftBackOff = 500 * time.Millisecond
-)
-
-// StartJanitor starts the janitor on a different goroutine
-// The janitor's job is to delete expired keys in the background, in other words, it takes care of passive eviction.
-// It can be stopped by calling Cache.StopJanitor.
-// If you do not start the janitor, expired keys will only be deleted when they are accessed through Get, GetByKeys, or
-// GetAll.
-func (cache *Cache) StartJanitor() error {
-	if cache.stopJanitor != nil {
-		return ErrJanitorAlreadyRunning
-	}
-	cache.stopJanitor = make(chan bool)
-	go func() {
-		// rather than starting from the tail on every run, we can try to start from the last traversed entry
-		var lastTraversedNode *Entry
-		totalNumberOfExpiredKeysInPreviousRunFromTailToHead := 0
-		backOff := JanitorMinShiftBackOff
-		for {
-			select {
-			case <-time.After(backOff):
-				// Passive clean up duty
-				cache.mutex.Lock()
-				if cache.tail != nil {
-					start := time.Now()
-					steps := 0
-					expiredEntriesFound := 0
-					current := cache.tail
-					if lastTraversedNode != nil {
-						// Make sure the lastTraversedNode is still in the cache, otherwise we might be traversing nodes that were already deleted.
-						// Furthermore, we need to make sure that the entry from the cache has the same pointer as the lastTraversedNode
-						// to verify that there isn't just a new cache entry with the same key (i.e. in case lastTraversedNode got evicted)
-						if entryFromCache, isInCache := cache.get(lastTraversedNode.Key); isInCache && entryFromCache == lastTraversedNode {
-							current = lastTraversedNode
-						}
-					}
-					if current == cache.tail {
-						if Debug {
-							log.Printf("There are currently %d entries in the cache. The last walk resulted in finding %d expired keys", len(cache.entries), totalNumberOfExpiredKeysInPreviousRunFromTailToHead)
-						}
-						totalNumberOfExpiredKeysInPreviousRunFromTailToHead = 0
-					}
-					for current != nil {
-						// since we're walking from the tail to the head, we get the previous reference
-						var previous *Entry
-						steps++
-						if current.Expired() {
-							expiredEntriesFound++
-							// Because delete will remove the previous reference from the entry, we need to store the
-							// previous reference before we delete it
-							previous = current.previous
-							cache.delete(current.Key)
-							cache.stats.ExpiredKeys++
-						}
-						if current == cache.head {
-							lastTraversedNode = nil
-							break
-						}
-						// Travel to the current node's previous node only if no specific previous node has been specified
-						if previous != nil {
-							current = previous
-						} else {
-							current = current.previous
-						}
-						lastTraversedNode = current
-						if steps == JanitorMaxIterationsPerShift || expiredEntriesFound >= JanitorShiftTarget {
-							if expiredEntriesFound > 0 {
-								backOff = JanitorMinShiftBackOff
-							} else {
-								if backOff*2 <= JanitorMaxShiftBackOff {
-									backOff *= 2
-								} else {
-									backOff = JanitorMaxShiftBackOff
-								}
-							}
-							break
-						}
-					}
-					if Debug {
-						log.Printf("traversed %d nodes and found %d expired entries in %s before stopping\n", steps, expiredEntriesFound, time.Since(start))
-					}
-					totalNumberOfExpiredKeysInPreviousRunFromTailToHead += expiredEntriesFound
-				} else {
-					if backOff*2 < JanitorMaxShiftBackOff {
-						backOff *= 2
-					} else {
-						backOff = JanitorMaxShiftBackOff
-					}
-				}
-				cache.mutex.Unlock()
-			case <-cache.stopJanitor:
-				cache.stopJanitor <- true
-				return
-			}
-		}
-	}()
-	//if Debug {
-	//	go func() {
-	//		var m runtime.MemStats
-	//		for {
-	//			runtime.ReadMemStats(&m)
-	//			log.Printf("Alloc=%vMB; HeapReleased=%vMB; Sys=%vMB; HeapInUse=%vMB; HeapObjects=%v; HeapObjectsFreed=%v; GC=%v; cache.memoryUsage=%vMB; cacheSize=%d\n", m.Alloc/1024/1024, m.HeapReleased/1024/1024, m.Sys/1024/1024, m.HeapInuse/1024/1024, m.HeapObjects, m.Frees, m.NumGC, cache.memoryUsage/1024/1024, cache.Count())
-	//			time.Sleep(3 * time.Second)
-	//		}
-	//	}()
-	//}
-	return nil
-}
-
-// StopJanitor stops the janitor
-func (cache *Cache) StopJanitor() {
-	if cache.stopJanitor != nil {
-		// Tell the janitor to stop, and then wait for the janitor to reply on the same channel that it's stopping
-		// This may seem a bit odd, but this allows us to avoid a data race condition when trying to set
-		// cache.stopJanitor to nil
-		cache.stopJanitor <- true
-		<-cache.stopJanitor
-		cache.stopJanitor = nil
-	}
-}

vendor/github.com/TwiN/gocache/v2/pattern.go

@@ -1,12 +0,0 @@
-package gocache
-
-import "path/filepath"
-
-// MatchPattern checks whether a string matches a pattern
-func MatchPattern(pattern, s string) bool {
-	if pattern == "*" {
-		return true
-	}
-	matched, _ := filepath.Match(pattern, s)
-	return matched
-}

vendor/github.com/TwiN/gocache/v2/policy.go

@@ -1,33 +0,0 @@
-package gocache
-
-// EvictionPolicy is what dictates how evictions are handled
-type EvictionPolicy string
-
-const (
-	// LeastRecentlyUsed is an eviction policy that causes the most recently accessed cache entry to be moved to the
-	// head of the cache. Effectively, this causes the cache entries that have not been accessed for some time to
-	// gradually move closer and closer to the tail, and since the tail is the entry that gets deleted when an eviction
-	// is required, it allows less used cache entries to be evicted while keeping recently accessed entries at or close
-	// to the head.
-	//
-	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
-	// put 3 at the head and 1 at the tail:
-	//     3 (head) -> 2 -> 1 (tail)
-	// If the cache entry 1 was then accessed, 1 would become the head and 2 the tail:
-	//     1 (head) -> 3 -> 2 (tail)
-	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (2) would then be evicted:
-	//     4 (head) -> 1 -> 3 (tail)
-	LeastRecentlyUsed EvictionPolicy = "LeastRecentlyUsed"
-
-	// FirstInFirstOut is an eviction policy that causes cache entries to be evicted in the same order that they are
-	// created.
-	//
-	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
-	// put 3 at the head and 1 at the tail:
-	//     3 (head) -> 2 -> 1 (tail)
-	// If the cache entry 1 was then accessed, unlike with LeastRecentlyUsed, nothing would change:
-	//     3 (head) -> 2 -> 1 (tail)
-	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (1) would then be evicted:
-	//     4 (head) -> 3 -> 2 (tail)
-	FirstInFirstOut EvictionPolicy = "FirstInFirstOut"
-)