Remove web.context-root

Migrate frontend to Vue + Add service detail page

.dockerignore

@@ -1,3 +1,6 @@
 example
+Dockerfile
 .github
 .idea
+.git
+web/app

.github/codecov.yml

@@ -0,0 +1,6 @@
+ignore:
+  - "watchdog/watchdog.go"
+
+coverage:
+  status:
+    patch: off

.github/workflows/build.yml

@@ -15,13 +15,19 @@ jobs:
     timeout-minutes: 5
     steps:
       - name: Set up Go 1.15
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v2
         with:
           go-version: 1.15
-        id: go
       - name: Check out code into the Go module directory
         uses: actions/checkout@v2
       - name: Build binary to make sure it works
         run: go build -mod vendor
       - name: Test
-        run: go test -mod vendor -cover ./...
+        # We're using "sudo" because one of the tests leverages ping, which requires super-user privileges.
+        # As for the "PATH=$PATH", we need it to use the same "go" executable that was configured by the "Set
+        # up Go" step (otherwise, it'd use sudo's "go" executable)
+        run: sudo "PATH=$PATH" go test -mod vendor ./... -race -coverprofile=coverage.txt -covermode=atomic
+      - name: Codecov
+        uses: codecov/codecov-action@v1.0.14
+        with:
+          file: ./coverage.txt

.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: publish
+on:
+  release:
+    types: [published]
+jobs:
+  build:
+    name: Publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Get the release
+        run: echo RELEASE=${GITHUB_REF/refs\/tags\//} >> $GITHUB_ENV
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Login to Docker Registry
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/amd64,linux/arm/v7,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            ${{ env.IMAGE_REPOSITORY }}:${{ env.RELEASE }}

.gitignore

@@ -1,2 +1,3 @@
-bin
-.idea
+.idea
+.vscode
+gatus

Dockerfile

@@ -1,16 +1,20 @@
 # Build the go application into a binary
 FROM golang:alpine as builder
-WORKDIR /app
-ADD . ./
-RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus .
 RUN apk --update add ca-certificates
+WORKDIR /app
+COPY . ./
+RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus .
+
+# Run Tests inside docker image if you don't have a configured go environment
+#RUN apk update && apk add --virtual build-dependencies build-base gcc
+#RUN go test ./... -mod vendor
 
 # Run the binary on an empty container
 FROM scratch
 COPY --from=builder /app/gatus .
 COPY --from=builder /app/config.yaml ./config/config.yaml
-COPY --from=builder /app/static static/
+COPY --from=builder /app/web/static ./web/static
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 ENV PORT=8080
 EXPOSE ${PORT}
-ENTRYPOINT ["/gatus"]
+ENTRYPOINT ["/gatus"]

LICENSE.md

@@ -1,201 +1,9 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+MIT License
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Copyright (c) 2020 TwinProduction
 
-   1. Definitions.
+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:
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2020 TwinProduction
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+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.

Makefile

@@ -0,0 +1,11 @@
+docker-build:
+	docker build -t twinproduction/gatus:latest .
+
+docker-build-and-run:
+	docker build -t twinproduction/gatus:latest . && docker run -p 8080:8080 --name gatus twinproduction/gatus:latest
+
+build-frontend:
+	npm --prefix web/app run build
+
+run-frontend:
+	npm --prefix web/app run serve

alerting/config.go

@@ -2,14 +2,30 @@ package alerting
 
 import (
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
 	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
 	"github.com/TwinProduction/gatus/alerting/provider/slack"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 )
 
+// Config is the configuration for alerting providers
 type Config struct {
-	Slack     *slack.AlertProvider     `yaml:"slack"`
+	// Slack is the configuration for the slack alerting provider
+	Slack *slack.AlertProvider `yaml:"slack"`
+
+	// Mattermost is the configuration for the mattermost alerting provider
+	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
+
+	// Messagebird is the configuration for the messagebird alerting provider
+	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`
+
+	// Pagerduty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`
-	Twilio    *twilio.AlertProvider    `yaml:"twilio"`
-	Custom    *custom.AlertProvider    `yaml:"custom"`
+
+	// Twilio is the configuration for the twilio alerting provider
+	Twilio *twilio.AlertProvider `yaml:"twilio"`
+
+	// Custom is the configuration for the custom alerting provider
+	Custom *custom.AlertProvider `yaml:"custom"`
 }

alerting/provider/custom/custom.go

@@ -2,26 +2,30 @@ package custom
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
-	"github.com/TwinProduction/gatus/client"
-	"github.com/TwinProduction/gatus/core"
 	"io/ioutil"
 	"net/http"
+	"os"
 	"strings"
+
+	"github.com/TwinProduction/gatus/client"
+	"github.com/TwinProduction/gatus/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
 // Technically, all alert providers should be reachable using the custom alert provider
 type AlertProvider struct {
-	Url     string            `yaml:"url"`
-	Method  string            `yaml:"method,omitempty"`
-	Body    string            `yaml:"body,omitempty"`
-	Headers map[string]string `yaml:"headers,omitempty"`
+	URL      string            `yaml:"url"`
+	Method   string            `yaml:"method,omitempty"`
+	Insecure bool              `yaml:"insecure,omitempty"`
+	Body     string            `yaml:"body,omitempty"`
+	Headers  map[string]string `yaml:"headers,omitempty"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
-	return len(provider.Url) > 0
+	return len(provider.URL) > 0
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
@@ -29,9 +33,9 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	return provider
 }
 
-func (provider *AlertProvider) buildRequest(serviceName, alertDescription string, resolved bool) *http.Request {
+func (provider *AlertProvider) buildHTTPRequest(serviceName, alertDescription string, resolved bool) *http.Request {
 	body := provider.Body
-	providerUrl := provider.Url
+	providerURL := provider.URL
 	method := provider.Method
 	if strings.Contains(body, "[ALERT_DESCRIPTION]") {
 		body = strings.ReplaceAll(body, "[ALERT_DESCRIPTION]", alertDescription)
@@ -46,24 +50,24 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
 		}
 	}
-	if strings.Contains(providerUrl, "[ALERT_DESCRIPTION]") {
-		providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_DESCRIPTION]", alertDescription)
+	if strings.Contains(providerURL, "[ALERT_DESCRIPTION]") {
+		providerURL = strings.ReplaceAll(providerURL, "[ALERT_DESCRIPTION]", alertDescription)
 	}
-	if strings.Contains(providerUrl, "[SERVICE_NAME]") {
-		providerUrl = strings.ReplaceAll(providerUrl, "[SERVICE_NAME]", serviceName)
+	if strings.Contains(providerURL, "[SERVICE_NAME]") {
+		providerURL = strings.ReplaceAll(providerURL, "[SERVICE_NAME]", serviceName)
 	}
-	if strings.Contains(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]") {
+	if strings.Contains(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]") {
 		if resolved {
-			providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
 		} else {
-			providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
 		}
 	}
 	if len(method) == 0 {
-		method = "GET"
+		method = http.MethodGet
 	}
 	bodyBuffer := bytes.NewBuffer([]byte(body))
-	request, _ := http.NewRequest(method, providerUrl, bodyBuffer)
+	request, _ := http.NewRequest(method, providerURL, bodyBuffer)
 	for k, v := range provider.Headers {
 		request.Header.Set(k, v)
 	}
@@ -72,8 +76,14 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 
 // Send a request to the alert provider and return the body
 func (provider *AlertProvider) Send(serviceName, alertDescription string, resolved bool) ([]byte, error) {
-	request := provider.buildRequest(serviceName, alertDescription, resolved)
-	response, err := client.GetHttpClient().Do(request)
+	if os.Getenv("MOCK_ALERT_PROVIDER") == "true" {
+		if os.Getenv("MOCK_ALERT_PROVIDER_ERROR") == "true" {
+			return nil, errors.New("error")
+		}
+		return []byte("{}"), nil
+	}
+	request := provider.buildHTTPRequest(serviceName, alertDescription, resolved)
+	response, err := client.GetHTTPClient(provider.Insecure).Do(request)
 	if err != nil {
 		return nil, err
 	}
@@ -81,9 +91,8 @@ func (provider *AlertProvider) Send(serviceName, alertDescription string, resolv
 		body, err := ioutil.ReadAll(response.Body)
 		if err != nil {
 			return nil, fmt.Errorf("call to provider alert returned status code %d", response.StatusCode)
-		} else {
-			return nil, fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
 		}
+		return nil, fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
 	}
 	return ioutil.ReadAll(response.Body)
 }

alerting/provider/custom/custom_test.go

@@ -3,33 +3,34 @@ package custom
 import (
 	"io/ioutil"
 	"testing"
+
+	"github.com/TwinProduction/gatus/core"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{Url: ""}
+	invalidProvider := AlertProvider{URL: ""}
 	if invalidProvider.IsValid() {
 		t.Error("provider shouldn't have been valid")
 	}
-	validProvider := AlertProvider{Url: "http://example.com"}
+	validProvider := AlertProvider{URL: "http://example.com"}
 	if !validProvider.IsValid() {
 		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_buildRequestWhenResolved(t *testing.T) {
+func TestAlertProvider_buildHTTPRequestWhenResolved(t *testing.T) {
 	const (
-		ExpectedUrl  = "http://example.com/service-name"
+		ExpectedURL  = "http://example.com/service-name?event=RESOLVED&description=alert-description"
 		ExpectedBody = "service-name,alert-description,RESOLVED"
 	)
 	customAlertProvider := &AlertProvider{
-		Url:     "http://example.com/[SERVICE_NAME]",
-		Method:  "GET",
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
 		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
 		Headers: nil,
 	}
-	request := customAlertProvider.buildRequest("service-name", "alert-description", true)
-	if request.URL.String() != ExpectedUrl {
-		t.Error("expected URL to be", ExpectedUrl, "was", request.URL.String())
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
 	}
 	body, _ := ioutil.ReadAll(request.Body)
 	if string(body) != ExpectedBody {
@@ -37,23 +38,33 @@ func TestAlertProvider_buildRequestWhenResolved(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_buildRequestWhenTriggered(t *testing.T) {
+func TestAlertProvider_buildHTTPRequestWhenTriggered(t *testing.T) {
 	const (
-		ExpectedUrl  = "http://example.com/service-name"
+		ExpectedURL  = "http://example.com/service-name?event=TRIGGERED&description=alert-description"
 		ExpectedBody = "service-name,alert-description,TRIGGERED"
 	)
 	customAlertProvider := &AlertProvider{
-		Url:     "http://example.com/[SERVICE_NAME]",
-		Method:  "GET",
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
 		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers: nil,
+		Headers: map[string]string{"Authorization": "Basic hunter2"},
 	}
-	request := customAlertProvider.buildRequest("service-name", "alert-description", false)
-	if request.URL.String() != ExpectedUrl {
-		t.Error("expected URL to be", ExpectedUrl, "was", request.URL.String())
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", false)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
 	}
 	body, _ := ioutil.ReadAll(request.Body)
 	if string(body) != ExpectedBody {
 		t.Error("expected body to be", ExpectedBody, "was", string(body))
 	}
 }
+
+func TestAlertProvider_ToCustomAlertProvider(t *testing.T) {
+	provider := AlertProvider{URL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if customAlertProvider != customAlertProvider {
+		t.Error("customAlertProvider should've been equal to customAlertProvider")
+	}
+}

alerting/provider/mattermost/mattermost.go

@@ -0,0 +1,75 @@
+package mattermost
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Mattermost
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+	Insecure   bool   `yaml:"insecure,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.WebhookURL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	var color string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		color = "#36A64F"
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		color = "#DD0000"
+	}
+	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)
+	}
+	return &custom.AlertProvider{
+		URL:      provider.WebhookURL,
+		Method:   http.MethodPost,
+		Insecure: provider.Insecure,
+		Body: fmt.Sprintf(`{
+  "text": "",
+  "username": "gatus",
+  "icon_url": "https://raw.githubusercontent.com/TwinProduction/gatus/master/static/logo.png",
+  "attachments": [
+    {
+      "title": ":rescue_worker_helmet: Gatus",
+      "fallback": "Gatus - %s",
+      "text": "%s:\n> %s",
+      "short": false,
+      "color": "%s",
+      "fields": [
+        {
+          "title": "URL",
+          "value": "%s",
+          "short": false
+        },
+        {
+          "title": "Condition results",
+          "value": "%s",
+          "short": false
+        }
+      ]
+    }
+  ]
+}`, message, message, alert.Description, color, service.URL, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}

alerting/provider/mattermost/mattermost_test.go

@@ -0,0 +1,41 @@
+package mattermost
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+}

alerting/provider/messagebird/messagebird.go

@@ -0,0 +1,50 @@
+package messagebird
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+const (
+	restAPIURL = "https://rest.messagebird.com/messages"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Messagebird
+type AlertProvider struct {
+	AccessKey  string `yaml:"access-key"`
+	Originator string `yaml:"originator"`
+	Recipients string `yaml:"recipients"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.AccessKey) > 0 && len(provider.Originator) > 0 && len(provider.Recipients) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+// Reference doc for messagebird https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+	}
+
+	return &custom.AlertProvider{
+		URL:    restAPIURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "originator": "%s",
+  "recipients": "%s",
+  "body": "%s"
+}`, provider.Originator, provider.Recipients, message),
+		Headers: map[string]string{
+			"Content-Type":  "application/json",
+			"Authorization": fmt.Sprintf("AccessKey %s", provider.AccessKey),
+		},
+	}
+}

alerting/provider/messagebird/messagebird_test.go

@@ -0,0 +1,53 @@
+package messagebird
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+}

alerting/provider/pagerduty/pagerduty.go

@@ -2,6 +2,8 @@ package pagerduty
 
 import (
 	"fmt"
+	"net/http"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -16,8 +18,10 @@ func (provider *AlertProvider) IsValid() bool {
 	return len(provider.IntegrationKey) == 32
 }
 
-// https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+//
+// relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message, eventAction, resolveKey string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
@@ -29,8 +33,8 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		resolveKey = ""
 	}
 	return &custom.AlertProvider{
-		Url:    "https://events.pagerduty.com/v2/enqueue",
-		Method: "POST",
+		URL:    "https://events.pagerduty.com/v2/enqueue",
+		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "routing_key": "%s",
   "dedup_key": "%s",

alerting/provider/pagerduty/pagerduty_test.go

@@ -1,6 +1,11 @@
 package pagerduty
 
-import "testing"
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
 
 func TestAlertProvider_IsValid(t *testing.T) {
 	invalidProvider := AlertProvider{IntegrationKey: ""}
@@ -12,3 +17,25 @@ func TestAlertProvider_IsValid(t *testing.T) {
 		t.Error("provider should've been valid")
 	}
 }
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+}

alerting/provider/provider.go

@@ -2,6 +2,11 @@ package provider
 
 import (
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
+	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
+	"github.com/TwinProduction/gatus/alerting/provider/slack"
+	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -13,3 +18,13 @@ type AlertProvider interface {
 	// ToCustomAlertProvider converts the provider into a custom.AlertProvider
 	ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider
 }
+
+var (
+	// Validate interface implementation on compile
+	_ AlertProvider = (*custom.AlertProvider)(nil)
+	_ AlertProvider = (*twilio.AlertProvider)(nil)
+	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*mattermost.AlertProvider)(nil)
+	_ AlertProvider = (*messagebird.AlertProvider)(nil)
+	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+)

alerting/provider/slack/slack.go

@@ -2,24 +2,25 @@ package slack
 
 import (
 	"fmt"
+	"net/http"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Slack
 type AlertProvider struct {
-	WebhookUrl string `yaml:"webhook-url"`
+	WebhookURL string `yaml:"webhook-url"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
-	return len(provider.WebhookUrl) > 0
+	return len(provider.WebhookURL) > 0
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
 func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
-	var message string
-	var color string
+	var message, color, results string
 	if resolved {
 		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
 		color = "#36A64F"
@@ -27,19 +28,18 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
 		color = "#DD0000"
 	}
-	var results string
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
 		if conditionResult.Success {
-			prefix = ":heavy_check_mark:"
+			prefix = ":white_check_mark:"
 		} else {
 			prefix = ":x:"
 		}
 		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	return &custom.AlertProvider{
-		Url:    provider.WebhookUrl,
-		Method: "POST",
+		URL:    provider.WebhookURL,
+		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "text": "",
   "attachments": [
@@ -55,7 +55,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
           "short": false
         }
       ]
-    },
+    }
   ]
 }`, message, alert.Description, color, results),
 		Headers: map[string]string{"Content-Type": "application/json"},

alerting/provider/slack/slack_test.go

@@ -1,14 +1,41 @@
 package slack
 
-import "testing"
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{WebhookUrl: ""}
+	invalidProvider := AlertProvider{WebhookURL: ""}
 	if invalidProvider.IsValid() {
 		t.Error("provider shouldn't have been valid")
 	}
-	validProvider := AlertProvider{WebhookUrl: "http://example.com"}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
 	if !validProvider.IsValid() {
 		t.Error("provider should've been valid")
 	}
 }
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+}

alerting/provider/twilio/twilio.go

@@ -3,9 +3,11 @@ package twilio
 import (
 	"encoding/base64"
 	"fmt"
+	"net/http"
+	"net/url"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
-	"net/url"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Twilio
@@ -22,7 +24,7 @@ func (provider *AlertProvider) IsValid() bool {
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
@@ -30,8 +32,8 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
 	}
 	return &custom.AlertProvider{
-		Url:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
-		Method: "POST",
+		URL:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
+		Method: http.MethodPost,
 		Body: url.Values{
 			"To":   {provider.To},
 			"From": {provider.From},

alerting/provider/twilio/twilio_test.go

@@ -1,6 +1,11 @@
 package twilio
 
-import "testing"
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
 
 func TestTwilioAlertProvider_IsValid(t *testing.T) {
 	invalidProvider := AlertProvider{}
@@ -17,3 +22,35 @@ func TestTwilioAlertProvider_IsValid(t *testing.T) {
 		t.Error("provider should've been valid")
 	}
 }
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{
+		SID:   "1",
+		Token: "1",
+		From:  "1",
+		To:    "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{
+		SID:   "1",
+		Token: "1",
+		From:  "1",
+		To:    "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+}

client/client.go

@@ -1,19 +1,84 @@
 package client
 
 import (
+	"crypto/tls"
+	"net"
 	"net/http"
 	"time"
+
+	"github.com/go-ping/ping"
 )
 
 var (
-	client *http.Client
+	secureHTTPClient   *http.Client
+	insecureHTTPClient *http.Client
+
+	// pingTimeout is the timeout for the Ping function
+	// This is mainly exposed for testing purposes
+	pingTimeout = 5 * time.Second
 )
 
-func GetHttpClient() *http.Client {
-	if client == nil {
-		client = &http.Client{
-			Timeout: time.Second * 10,
+// GetHTTPClient returns the shared HTTP client
+func GetHTTPClient(insecure bool) *http.Client {
+	if insecure {
+		if insecureHTTPClient == nil {
+			insecureHTTPClient = &http.Client{
+				Timeout: 10 * time.Second,
+				Transport: &http.Transport{
+					MaxIdleConns:        100,
+					MaxIdleConnsPerHost: 20,
+					TLSClientConfig: &tls.Config{
+						InsecureSkipVerify: true,
+					},
+				},
+			}
+		}
+		return insecureHTTPClient
+	}
+	if secureHTTPClient == nil {
+		secureHTTPClient = &http.Client{
+			Timeout: 10 * time.Second,
+			Transport: &http.Transport{
+				MaxIdleConns:        100,
+				MaxIdleConnsPerHost: 20,
+			},
 		}
 	}
-	return client
+	return secureHTTPClient
+}
+
+// CanCreateTCPConnection checks whether a connection can be established with a TCP service
+func CanCreateTCPConnection(address string) bool {
+	conn, err := net.DialTimeout("tcp", address, 5*time.Second)
+	if err != nil {
+		return false
+	}
+	_ = conn.Close()
+	return true
+}
+
+// Ping checks if an address can be pinged and returns the round-trip time if the address can be pinged
+//
+// Note that this function takes at least 100ms, even if the address is 127.0.0.1
+func Ping(address string) (bool, time.Duration) {
+	pinger, err := ping.NewPinger(address)
+	if err != nil {
+		return false, 0
+	}
+	pinger.Count = 1
+	pinger.Timeout = pingTimeout
+	pinger.SetNetwork("ip4")
+	pinger.SetPrivileged(true)
+	err = pinger.Run()
+	if err != nil {
+		return false, 0
+	}
+	if pinger.Statistics() != nil {
+		// If the packet loss is 100, it means that the packet didn't reach the host
+		if pinger.Statistics().PacketLoss == 100 {
+			return false, pinger.Timeout
+		}
+		return true, pinger.Statistics().MaxRtt
+	}
+	return true, 0
 }

client/client_test.go

@@ -1,13 +1,51 @@
 package client
 
-import "testing"
+import (
+	"testing"
+	"time"
+)
 
-func TestGetHttpClient(t *testing.T) {
-	if client != nil {
-		t.Error("client should've been nil since it hasn't been called a single time yet")
+func TestGetHTTPClient(t *testing.T) {
+	if secureHTTPClient != nil {
+		t.Error("secureHTTPClient should've been nil since it hasn't been called a single time yet")
 	}
-	_ = GetHttpClient()
-	if client == nil {
-		t.Error("client shouldn't have been nil, since it has been called once")
+	if insecureHTTPClient != nil {
+		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	}
+	_ = GetHTTPClient(false)
+	if secureHTTPClient == nil {
+		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+	if insecureHTTPClient != nil {
+		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	}
+	_ = GetHTTPClient(true)
+	if secureHTTPClient == nil {
+		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+	if insecureHTTPClient == nil {
+		t.Error("insecureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+}
+
+func TestPing(t *testing.T) {
+	pingTimeout = 500 * time.Millisecond
+	if success, rtt := Ping("127.0.0.1"); !success {
+		t.Error("expected true")
+		if rtt == 0 {
+			t.Error("Round-trip time returned on success should've higher than 0")
+		}
+	}
+	if success, rtt := Ping("256.256.256.256"); success {
+		t.Error("expected false, because the IP is invalid")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
+	}
+	if success, rtt := Ping("192.168.152.153"); success {
+		t.Error("expected false, because the IP is valid but the host should be unreachable")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
 	}
 }

config.yaml

@@ -1,16 +1,38 @@
-metrics: true
 services:
-  - name: twinnation
+  - name: front-end
+    group: core
     url: "https://twinnation.org/health"
-    interval: 30s
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 1000"
-  - name: cat-fact
-    url: "https://cat-fact.herokuapp.com/facts/random"
     interval: 1m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 150"
+
+  - name: back-end
+    group: core
+    url: "http://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: monitoring
+    group: internal
+    url: "http://example.com/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: nas
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: cat-fact
+    url: "https://cat-fact.herokuapp.com/facts/random"
+    interval: 5m
     conditions:
       - "[STATUS] == 200"
       - "[BODY].deleted == false"
-      - "len([BODY].text) > 0"
+      - "len([BODY].text) > 0"

config/config.go

@@ -2,36 +2,80 @@ package config
 
 import (
 	"errors"
-	"github.com/TwinProduction/gatus/alerting"
-	"github.com/TwinProduction/gatus/alerting/provider"
-	"github.com/TwinProduction/gatus/core"
-	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"log"
 	"os"
+
+	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/provider"
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/k8s"
+	"github.com/TwinProduction/gatus/security"
+	"gopkg.in/yaml.v2"
 )
 
 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
 	DefaultConfigurationFilePath = "config/config.yaml"
+
+	// DefaultFallbackConfigurationFilePath is the default fallback path that will be used to search for the
+	// configuration file if DefaultConfigurationFilePath didn't work
+	DefaultFallbackConfigurationFilePath = "config/config.yml"
+
+	// DefaultAddress is the default address the service will bind to
+	DefaultAddress = "0.0.0.0"
+
+	// DefaultPort is the default port the service will listen on
+	DefaultPort = 8080
 )
 
 var (
-	ErrNoServiceInConfig  = errors.New("configuration file should contain at least 1 service")
+	// ErrNoServiceInConfig is an error returned when a configuration file has no services configured
+	ErrNoServiceInConfig = errors.New("configuration file should contain at least 1 service")
+
+	// ErrConfigFileNotFound is an error returned when the configuration file could not be found
 	ErrConfigFileNotFound = errors.New("configuration file not found")
-	ErrConfigNotLoaded    = errors.New("configuration is nil")
-	config                *Config
+
+	// ErrConfigNotLoaded is an error returned when an attempt to Get() the configuration before loading it is made
+	ErrConfigNotLoaded = errors.New("configuration is nil")
+
+	// ErrInvalidSecurityConfig is an error returned when the security configuration is invalid
+	ErrInvalidSecurityConfig = errors.New("invalid security configuration")
+
+	config *Config
 )
 
 // Config is the main configuration structure
 type Config struct {
-	Metrics  bool             `yaml:"metrics"`
-	Debug    bool             `yaml:"debug"`
+	// Debug Whether to enable debug logs
+	Debug bool `yaml:"debug"`
+
+	// Metrics Whether to expose metrics at /metrics
+	Metrics bool `yaml:"metrics"`
+
+	// DisableMonitoringLock Whether to disable the monitoring lock
+	// The monitoring lock is what prevents multiple services from being processed at the same time.
+	// Disabling this may lead to inaccurate response times
+	DisableMonitoringLock bool `yaml:"disable-monitoring-lock"`
+
+	// Security Configuration for securing access to Gatus
+	Security *security.Config `yaml:"security"`
+
+	// Alerting Configuration for alerting
 	Alerting *alerting.Config `yaml:"alerting"`
-	Services []*core.Service  `yaml:"services"`
+
+	// Services List of services to monitor
+	Services []*core.Service `yaml:"services"`
+
+	// Kubernetes is the Kubernetes configuration
+	Kubernetes *k8s.Config `yaml:"kubernetes"`
+
+	// Web is the configuration for the web listener
+	Web *webConfig `yaml:"web"`
 }
 
+// Get returns the configuration, or panics if the configuration hasn't loaded yet
 func Get() *Config {
 	if config == nil {
 		panic(ErrConfigNotLoaded)
@@ -39,25 +83,33 @@ func Get() *Config {
 	return config
 }
 
+// Set sets the configuration
+// Used only for testing
+func Set(cfg *Config) {
+	config = cfg
+}
+
+// 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) error {
 	log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
 	cfg, err := readConfigurationFile(configFile)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return ErrConfigFileNotFound
-		} else {
-			return err
 		}
+		return err
 	}
 	config = cfg
 	return nil
 }
 
+// LoadDefaultConfiguration loads the default configuration file
 func LoadDefaultConfiguration() error {
 	err := Load(DefaultConfigurationFilePath)
 	if err != nil {
 		if err == ErrConfigFileNotFound {
-			return Load("config/config.yml")
+			return Load(DefaultFallbackConfigurationFilePath)
 		}
 		return err
 	}
@@ -78,16 +130,49 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 	yamlBytes = []byte(os.ExpandEnv(string(yamlBytes)))
 	// Parse configuration file
 	err = yaml.Unmarshal(yamlBytes, &config)
-	// Check if the configuration file at least has services.
-	if config == nil || config.Services == nil || len(config.Services) == 0 {
+	if err != nil {
+		return
+	}
+	// Check if the configuration file at least has services configured or Kubernetes auto discovery enabled
+	if config == nil || ((config.Services == nil || len(config.Services) == 0) && (config.Kubernetes == nil || !config.Kubernetes.AutoDiscover)) {
 		err = ErrNoServiceInConfig
 	} else {
+		// Note that the functions below may panic, and this is on purpose to prevent Gatus from starting with
+		// invalid configurations
 		validateAlertingConfig(config)
+		validateSecurityConfig(config)
 		validateServicesConfig(config)
+		validateKubernetesConfig(config)
+		validateWebConfig(config)
 	}
 	return
 }
 
+func validateWebConfig(config *Config) {
+	if config.Web == nil {
+		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort}
+	} else {
+		config.Web.validateAndSetDefaults()
+	}
+}
+
+func validateKubernetesConfig(config *Config) {
+	if config.Kubernetes != nil && config.Kubernetes.AutoDiscover {
+		if config.Kubernetes.ServiceTemplate == nil {
+			panic("kubernetes.service-template cannot be nil")
+		}
+		if config.Debug {
+			log.Println("[config][validateKubernetesConfig] Automatically discovering Kubernetes services...")
+		}
+		discoveredServices, err := k8s.DiscoverServices(config.Kubernetes)
+		if err != nil {
+			panic(err)
+		}
+		config.Services = append(config.Services, discoveredServices...)
+		log.Printf("[config][validateKubernetesConfig] Discovered %d Kubernetes services", len(discoveredServices))
+	}
+}
+
 func validateServicesConfig(config *Config) {
 	for _, service := range config.Services {
 		if config.Debug {
@@ -98,6 +183,20 @@ func validateServicesConfig(config *Config) {
 	log.Printf("[config][validateServicesConfig] Validated %d services", len(config.Services))
 }
 
+func validateSecurityConfig(config *Config) {
+	if config.Security != nil {
+		if config.Security.IsValid() {
+			if config.Debug {
+				log.Printf("[config][validateSecurityConfig] Basic security configuration has been validated")
+			}
+		} else {
+			// If there was an attempt to configure security, then it must mean that some confidential or private
+			// data are exposed. As a result, we'll force a panic because it's better to be safe than sorry.
+			panic(ErrInvalidSecurityConfig)
+		}
+	}
+}
+
 func validateAlertingConfig(config *Config) {
 	if config.Alerting == nil {
 		log.Printf("[config][validateAlertingConfig] Alerting is not configured")
@@ -105,6 +204,8 @@ func validateAlertingConfig(config *Config) {
 	}
 	alertTypes := []core.AlertType{
 		core.SlackAlert,
+		core.MattermostAlert,
+		core.MessagebirdAlert,
 		core.TwilioAlert,
 		core.PagerDutyAlert,
 		core.CustomAlert,
@@ -126,6 +227,7 @@ func validateAlertingConfig(config *Config) {
 	log.Printf("[config][validateAlertingConfig] configuredProviders=%s; ignoredProviders=%s", validProviders, invalidProviders)
 }
 
+// GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding core.AlertType
 func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) provider.AlertProvider {
 	switch alertType {
 	case core.SlackAlert:
@@ -134,6 +236,18 @@ func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) pr
 			return nil
 		}
 		return config.Alerting.Slack
+	case core.MattermostAlert:
+		if config.Alerting.Mattermost == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Mattermost
+	case core.MessagebirdAlert:
+		if config.Alerting.Messagebird == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Messagebird
 	case core.TwilioAlert:
 		if config.Alerting.Twilio == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil

config/config_test.go

@@ -1,16 +1,51 @@
 package config
 
 import (
-	"github.com/TwinProduction/gatus/core"
+	"fmt"
+	"strings"
 	"testing"
 	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/k8stest"
+	v1 "k8s.io/api/core/v1"
 )
 
+func TestGetBeforeConfigIsLoaded(t *testing.T) {
+	defer func() { recover() }()
+	Get()
+	t.Fatal("Should've panicked because the configuration hasn't been loaded yet")
+}
+
+func TestSet(t *testing.T) {
+	if config != nil {
+		t.Fatal("config should've been nil")
+	}
+	Set(&Config{})
+	if config == nil {
+		t.Fatal("config shouldn't have been nil")
+	}
+}
+
+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 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 TestParseAndValidateConfigBytes(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
     interval: 15s
     conditions:
       - "[STATUS] == 200"
@@ -29,12 +64,18 @@ services:
 	if len(config.Services) != 2 {
 		t.Error("Should have returned two services")
 	}
-	if config.Services[0].Url != "https://twinnation.org/actuator/health" {
-		t.Errorf("URL should have been %s", "https://twinnation.org/actuator/health")
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
 	}
-	if config.Services[1].Url != "https://api.github.com/healthz" {
+	if config.Services[1].URL != "https://api.github.com/healthz" {
 		t.Errorf("URL should have been %s", "https://api.github.com/healthz")
 	}
+	if config.Services[0].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
+	if config.Services[1].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
 	if config.Services[0].Interval != 15*time.Second {
 		t.Errorf("Interval should have been %s", 15*time.Second)
 	}
@@ -51,6 +92,39 @@ services:
 
 func TestParseAndValidateConfigBytesDefault(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Metrics {
+		t.Error("Metrics should've been false by default")
+	}
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
+	}
+	if config.Services[0].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if config.Web.Address != DefaultAddress {
+		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
+	}
+	if config.Web.Port != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithAddress(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  address: 127.0.0.1
 services:
   - name: twinnation
     url: https://twinnation.org/actuator/health
@@ -66,20 +140,112 @@ services:
 	if config.Metrics {
 		t.Error("Metrics should've been false by default")
 	}
-	if config.Services[0].Url != "https://twinnation.org/actuator/health" {
+	if config.Services[0].URL != "https://twinnation.org/actuator/health" {
 		t.Errorf("URL should have been %s", "https://twinnation.org/actuator/health")
 	}
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
+
+	if config.Web.Address != "127.0.0.1" {
+		t.Errorf("Bind address should have been %s, because it is specified in config", "127.0.0.1")
+	}
+
+	if config.Web.Port != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
 }
 
-func TestParseAndValidateConfigBytesWithMetrics(t *testing.T) {
+func TestParseAndValidateConfigBytesWithPort(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  port: 12345
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Metrics {
+		t.Error("Metrics should've been false by default")
+	}
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
+	}
+	if config.Services[0].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if config.Web.Address != DefaultAddress {
+		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
+	}
+	if config.Web.Port != 12345 {
+		t.Errorf("Port should have been %d, because it is specified in config", 12345)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithPortAndHost(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  port: 12345
+  address: 127.0.0.1
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Metrics {
+		t.Error("Metrics should've been false by default")
+	}
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
+	}
+	if config.Services[0].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if config.Web.Address != "127.0.0.1" {
+		t.Errorf("Bind address should have been %s, because it is specified in config", "127.0.0.1")
+	}
+	if config.Web.Port != 12345 {
+		t.Errorf("Port should have been %d, because it is specified in config", 12345)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidPort(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+web:
+  port: 65536
+  address: 127.0.0.1
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	t.Fatal("Should've panicked because the configuration specifies an invalid port value")
+}
+
+func TestParseAndValidateConfigBytesWithMetricsAndCustomUserAgentHeader(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
 metrics: true
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
+    headers:
+      User-Agent: Test/2.0
     conditions:
       - "[STATUS] == 200"
 `))
@@ -92,12 +258,59 @@ services:
 	if !config.Metrics {
 		t.Error("Metrics should have been true")
 	}
-	if config.Services[0].Url != "https://twinnation.org/actuator/health" {
-		t.Errorf("URL should have been %s", "https://twinnation.org/actuator/health")
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
 	}
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
+	if config.Web.Address != DefaultAddress {
+		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
+	}
+	if config.Web.Port != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
+	if userAgent := config.Services[0].Headers["User-Agent"]; userAgent != "Test/2.0" {
+		t.Errorf("User-Agent should've been %s, got %s", "Test/2.0", userAgent)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithMetricsAndHostAndPort(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+metrics: true
+web:
+  address: 192.168.0.1
+  port: 9090
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if !config.Metrics {
+		t.Error("Metrics should have been true")
+	}
+	if config.Web.Address != "192.168.0.1" {
+		t.Errorf("Bind address should have been %s, because it is the default value", "192.168.0.1")
+	}
+	if config.Web.Port != 9090 {
+		t.Errorf("Port should have been %d, because it is specified in config", 9090)
+	}
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
+	}
+	if config.Services[0].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if userAgent := config.Services[0].Headers["User-Agent"]; userAgent != core.GatusUserAgent {
+		t.Errorf("User-Agent should've been %s because it's the default value, got %s", core.GatusUserAgent, userAgent)
+	}
 }
 
 func TestParseAndValidateBadConfigBytes(t *testing.T) {
@@ -118,19 +331,30 @@ badconfig:
 
 func TestParseAndValidateConfigBytesWithAlerting(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
+debug: true
+
 alerting:
   slack:
     webhook-url: "http://example.com"
   pagerduty:
     integration-key: "00000000000000000000000000000000"
+  messagebird:
+    access-key: "1"
+    originator: "31619191918"
+    recipients: "31619191919"
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
     alerts:
       - type: slack
         enabled: true
+      - type: pagerduty
+        enabled: true
         failure-threshold: 7
+        success-threshold: 5
         description: "Healthcheck failed 7 times in a row"
+      - type: messagebird
+        enabled: true
     conditions:
       - "[STATUS] == 200"
 `))
@@ -149,20 +373,32 @@ services:
 	if config.Alerting.Slack == nil || !config.Alerting.Slack.IsValid() {
 		t.Fatal("Slack alerting config should've been valid")
 	}
-	if config.Alerting.Slack.WebhookUrl != "http://example.com" {
-		t.Errorf("Slack webhook should've been %s, but was %s", "http://example.com", config.Alerting.Slack.WebhookUrl)
+	if config.Alerting.Slack.WebhookURL != "http://example.com" {
+		t.Errorf("Slack webhook should've been %s, but was %s", "http://example.com", config.Alerting.Slack.WebhookURL)
 	}
 	if config.Alerting.PagerDuty == nil || !config.Alerting.PagerDuty.IsValid() {
 		t.Fatal("PagerDuty alerting config should've been valid")
 	}
+	if config.Alerting.Messagebird == nil || !config.Alerting.Messagebird.IsValid() {
+		t.Fatal("Messagebird alerting config should've been valid")
+	}
 	if config.Alerting.PagerDuty.IntegrationKey != "00000000000000000000000000000000" {
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
+	if config.Alerting.Messagebird.AccessKey != "1" {
+		t.Errorf("Messagebird access key should've been %s, but was %s", "1", config.Alerting.Messagebird.AccessKey)
+	}
+	if config.Alerting.Messagebird.Originator != "31619191918" {
+		t.Errorf("Messagebird originator field should've been %s, but was %s", "31619191918", config.Alerting.Messagebird.Originator)
+	}
+	if config.Alerting.Messagebird.Recipients != "31619191919" {
+		t.Errorf("Messagebird to recipients should've been %s, but was %s", "31619191919", config.Alerting.Messagebird.Recipients)
+	}
 	if len(config.Services) != 1 {
 		t.Error("There should've been 1 service")
 	}
-	if config.Services[0].Url != "https://twinnation.org/actuator/health" {
-		t.Errorf("URL should have been %s", "https://twinnation.org/actuator/health")
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
 	}
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
@@ -170,23 +406,35 @@ services:
 	if config.Services[0].Alerts == nil {
 		t.Fatal("The service alerts shouldn't have been nil")
 	}
-	if len(config.Services[0].Alerts) != 1 {
-		t.Fatal("There should've been 1 alert configured")
+	if len(config.Services[0].Alerts) != 3 {
+		t.Fatal("There should've been 3 alert configured")
 	}
 	if !config.Services[0].Alerts[0].Enabled {
 		t.Error("The alert should've been enabled")
 	}
-	if config.Services[0].Alerts[0].FailureThreshold != 7 {
-		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[0].FailureThreshold)
+	if config.Services[0].Alerts[0].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[0].FailureThreshold)
 	}
-	if config.Services[0].Alerts[0].FailureThreshold != 7 {
-		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
+	if config.Services[0].Alerts[0].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
+	}
+	if config.Services[0].Alerts[1].FailureThreshold != 7 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[1].FailureThreshold)
+	}
+	if config.Services[0].Alerts[1].SuccessThreshold != 5 {
+		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 5, config.Services[0].Alerts[1].SuccessThreshold)
 	}
 	if config.Services[0].Alerts[0].Type != core.SlackAlert {
 		t.Errorf("The type of the alert should've been %s, but it was %s", core.SlackAlert, config.Services[0].Alerts[0].Type)
 	}
-	if config.Services[0].Alerts[0].Description != "Healthcheck failed 7 times in a row" {
-		t.Errorf("The type of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[0].Description)
+	if config.Services[0].Alerts[1].Type != core.PagerDutyAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.PagerDutyAlert, config.Services[0].Alerts[1].Type)
+	}
+	if config.Services[0].Alerts[1].Description != "Healthcheck failed 7 times in a row" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[0].Description)
+	}
+	if config.Services[0].Alerts[2].Type != core.MessagebirdAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.MessagebirdAlert, config.Services[0].Alerts[1].Type)
 	}
 }
 
@@ -197,7 +445,9 @@ alerting:
     integration-key: "INVALID_KEY"
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
+    alerts:
+      - type: pagerduty
     conditions:
       - "[STATUS] == 200"
 `))
@@ -217,3 +467,248 @@ services:
 		t.Fatal("PagerDuty alerting config should've been invalid")
 	}
 }
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfig(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    url: "https://example.com"
+    body: |
+      {
+        "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+      }
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	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.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Fatal("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.Insecure {
+		t.Fatal("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfigThatHasInsecureSetToTrue(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    url: "https://example.com"
+    method: "POST"
+    insecure: true
+    body: |
+      {
+        "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+      }
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	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.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Error("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.Method != "POST" {
+		t.Error("config.Alerting.Custom.Method should've been POST")
+	}
+	if !config.Alerting.Custom.Insecure {
+		t.Error("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidSecurityConfig(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+security:
+  basic:
+    username: "admin"
+    password-sha512: "invalid-sha512-hash"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	t.Error("Function should've panicked")
+}
+
+func TestParseAndValidateConfigBytesWithValidSecurityConfig(t *testing.T) {
+	const expectedUsername = "admin"
+	const expectedPasswordHash = "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22"
+	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
+security:
+  basic:
+    username: "%s"
+    password-sha512: "%s"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`, expectedUsername, expectedPasswordHash)))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Security == nil {
+		t.Fatal("config.Security shouldn't have been nil")
+	}
+	if !config.Security.IsValid() {
+		t.Error("Security config should've been valid")
+	}
+	if config.Security.Basic == nil {
+		t.Fatal("config.Security.Basic shouldn't have been nil")
+	}
+	if config.Security.Basic.Username != expectedUsername {
+		t.Errorf("config.Security.Basic.Username should've been %s, but was %s", expectedUsername, config.Security.Basic.Username)
+	}
+	if config.Security.Basic.PasswordSha512Hash != expectedPasswordHash {
+		t.Errorf("config.Security.Basic.PasswordSha512Hash should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordSha512Hash)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithNoServicesOrAutoDiscovery(t *testing.T) {
+	_, err := parseAndValidateConfigBytes([]byte(``))
+	if err != ErrNoServiceInConfig {
+		t.Error("The error returned should have been of type ErrNoServiceInConfig")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscovery(t *testing.T) {
+	var kubernetesServices []v1.Service
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-1", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-2", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-2-canary", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-3", "kube-system", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-4", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-5", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-6", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-7", "metrics", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-7-canary", "metrics", 8080))
+	k8stest.InitializeMockedKubernetesClient(kubernetesServices)
+	config, err := parseAndValidateConfigBytes([]byte(`
+debug: true
+
+kubernetes:
+  cluster-mode: "mock"
+  auto-discover: true
+  excluded-service-suffixes:
+    - canary
+  service-template:
+    interval: 29s
+    conditions:
+      - "[STATUS] == 200"
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+    - name: tools
+      hostname-suffix: ".tools.svc.cluster.local"
+      target-path: "/health"
+      excluded-services:
+        - service-6
+    - name: metrics
+      hostname-suffix: ".metrics.svc.cluster.local"
+      target-path: "/health"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Kubernetes == nil {
+		t.Fatal("Kuberbetes config shouldn't have been nil")
+	}
+	if len(config.Services) != 5 {
+		t.Error("Expected 5 services to have been added through k8s auto discovery, got", len(config.Services))
+	}
+	for _, service := range config.Services {
+		if service.Name == "service-2-canary" || service.Name == "service-7-canary" {
+			t.Errorf("service '%s' should've been excluded because excluded-service-suffixes has 'canary'", service.Name)
+		} else if service.Name == "service-6" {
+			t.Errorf("service '%s' should've been excluded because excluded-services has 'service-6'", service.Name)
+		} else if service.Name == "service-3" {
+			t.Errorf("service '%s' should've been excluded because the namespace 'kube-system' is not configured for auto discovery", service.Name)
+		} else {
+			if service.Interval != 29*time.Second {
+				t.Errorf("service '%s' should've had an interval of 29s, because the template is configured for it", service.Name)
+			}
+			if len(service.Conditions) != 1 {
+				t.Errorf("service '%s' should've had 1 condition", service.Name)
+			}
+			if len(service.Conditions) == 1 && *service.Conditions[0] != "[STATUS] == 200" {
+				t.Errorf("service '%s' should've had the condition '[STATUS] == 200', because the template is configured for it", service.Name)
+			}
+			if !strings.HasSuffix(service.URL, ".svc.cluster.local:8080/health") {
+				t.Errorf("service '%s' should've had an URL with the suffix '.svc.cluster.local:8080/health'", service.Name)
+			}
+		}
+	}
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryButNoServiceTemplate(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+kubernetes:
+  cluster-mode: "mock"
+  auto-discover: true
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+`))
+	t.Error("Function should've panicked because providing a service-template is mandatory")
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryUsingClusterModeIn(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+kubernetes:
+  cluster-mode: "in"
+  auto-discover: true
+  service-template:
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+`))
+	// TODO: find a way to test this?
+	t.Error("Function should've panicked because testing with ClusterModeIn isn't supported")
+}

config/web.go

@@ -0,0 +1,35 @@
+package config
+
+import (
+	"fmt"
+	"math"
+)
+
+// webConfig is the structure which supports the configuration of the endpoint
+// which provides access to the web frontend
+type webConfig struct {
+	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
+	Address string `yaml:"address"`
+
+	// Port to listen on (default to 8080 specified by DefaultPort)
+	Port int `yaml:"port"`
+}
+
+// validateAndSetDefaults checks and sets the default values for fields that are not set
+func (web *webConfig) validateAndSetDefaults() {
+	// Validate the Address
+	if len(web.Address) == 0 {
+		web.Address = DefaultAddress
+	}
+	// Validate the Port
+	if web.Port == 0 {
+		web.Port = DefaultPort
+	} else if web.Port < 0 || web.Port > math.MaxUint16 {
+		panic(fmt.Sprintf("invalid port: value should be between %d and %d", 0, math.MaxUint16))
+	}
+}
+
+// SocketAddress returns the combination of the Address and the Port
+func (web *webConfig) SocketAddress() string {
+	return fmt.Sprintf("%s:%d", web.Address, web.Port)
+}

config/web_test.go

@@ -0,0 +1,15 @@
+package config
+
+import (
+	"testing"
+)
+
+func TestWebConfig_SocketAddress(t *testing.T) {
+	web := &webConfig{
+		Address: "0.0.0.0",
+		Port:    8081,
+	}
+	if web.SocketAddress() != "0.0.0.0:8081" {
+		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
+	}
+}

controller/badge.go

@@ -0,0 +1,100 @@
+package controller
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/watchdog"
+	"github.com/gorilla/mux"
+)
+
+// badgeHandler handles the automatic generation of badge based on the group name and service name passed.
+//
+// Valid values for {duration}: 7d, 24h, 1h
+// Pattern for {identifier}: <KEY>.svg
+func badgeHandler(writer http.ResponseWriter, request *http.Request) {
+	variables := mux.Vars(request)
+	duration := variables["duration"]
+	if duration != "7d" && duration != "24h" && duration != "1h" {
+		writer.WriteHeader(http.StatusBadRequest)
+		_, _ = writer.Write([]byte("Durations supported: 7d, 24h, 1h"))
+		return
+	}
+	identifier := variables["identifier"]
+	key := strings.TrimSuffix(identifier, ".svg")
+	uptime := watchdog.GetUptimeByKey(key)
+	if uptime == nil {
+		writer.WriteHeader(http.StatusNotFound)
+		_, _ = writer.Write([]byte("Requested service not found"))
+		return
+	}
+	formattedDate := time.Now().Format(http.TimeFormat)
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Date", formattedDate)
+	writer.Header().Set("Expires", formattedDate)
+	writer.Header().Set("Content-Type", "image/svg+xml")
+	_, _ = writer.Write(generateSVG(duration, uptime))
+}
+
+func generateSVG(duration string, uptime *core.Uptime) []byte {
+	var labelWidth, valueWidth, valueWidthAdjustment int
+	var color string
+	var value float64
+	switch duration {
+	case "7d":
+		labelWidth = 65
+		value = uptime.LastSevenDays
+	case "24h":
+		labelWidth = 70
+		value = uptime.LastTwentyFourHours
+	case "1h":
+		labelWidth = 65
+		value = uptime.LastHour
+	default:
+	}
+	if value >= 0.8 {
+		color = "#40cc11"
+	} else {
+		color = "#c7130a"
+	}
+	sanitizedValue := strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", value*100), "0"), ".") + "%"
+	if strings.Contains(sanitizedValue, ".") {
+		valueWidthAdjustment = -10
+	}
+	valueWidth = (len(sanitizedValue) * 11) + valueWidthAdjustment
+	width := labelWidth + valueWidth
+	labelX := labelWidth / 2
+	valueX := labelWidth + (valueWidth / 2)
+	svg := []byte(fmt.Sprintf(`<svg xmlns="http://www.w3.org/2000/svg" width="%d" height="20">
+  <linearGradient id="b" x2="0" y2="100%%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a">
+    <rect width="%d" height="20" rx="3" fill="#fff"/>
+  </mask>
+  <g mask="url(#a)">
+    <path fill="#555" d="M0 0h%dv20H0z"/>
+    <path fill="%s" d="M%d 0h%dv20H%dz"/>
+    <path fill="url(#b)" d="M0 0h%dv20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      uptime %s
+    </text>
+    <text x="%d" y="14">
+      uptime %s
+    </text>
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      %s
+    </text>
+    <text x="%d" y="14">
+      %s
+    </text>
+  </g>
+</svg>`, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue))
+	return svg
+}

controller/controller.go

@@ -0,0 +1,161 @@
+package controller
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/security"
+	"github.com/TwinProduction/gatus/watchdog"
+	"github.com/TwinProduction/gocache"
+	"github.com/gorilla/mux"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+const (
+	cacheTTL = 10 * time.Second
+)
+
+var (
+	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.LeastRecentlyUsed)
+)
+
+func init() {
+	if err := cache.StartJanitor(); err != nil {
+		log.Fatal("[controller][init] Failed to start cache janitor:", err.Error())
+	}
+}
+
+// Handle creates the router and starts the server
+func Handle() {
+	cfg := config.Get()
+	var router http.Handler = CreateRouter(cfg)
+	if os.Getenv("ENVIRONMENT") == "dev" {
+		router = developmentCorsHandler(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())
+	log.Fatal(server.ListenAndServe())
+}
+
+// CreateRouter creates the router for the http server
+func CreateRouter(cfg *config.Config) *mux.Router {
+	router := mux.NewRouter()
+	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET") // favicon needs to be always served from the root
+	router.HandleFunc("/services/{service}", spaHandler).Methods("GET")
+	router.HandleFunc("/api/v1/statuses", secureIfNecessary(cfg, serviceStatusesHandler)).Methods("GET")
+	router.HandleFunc("/api/v1/statuses/{key}", secureIfNecessary(cfg, GzipHandlerFunc(serviceStatusHandler))).Methods("GET")
+	router.HandleFunc("/api/v1/badges/uptime/{duration}/{identifier}", badgeHandler).Methods("GET")
+	router.HandleFunc("/health", healthHandler).Methods("GET")
+	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir("./web/static"))))
+	if cfg.Metrics {
+		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
+	}
+	return router
+}
+
+func secureIfNecessary(cfg *config.Config, handler http.HandlerFunc) http.HandlerFunc {
+	if cfg.Security != nil && cfg.Security.IsValid() {
+		return security.Handler(serviceStatusesHandler, cfg.Security)
+	}
+	return handler
+}
+
+// serviceStatusesHandler handles requests to retrieve all service statuses
+// Due to the size of the response, this function leverages a cache.
+// Must not be wrapped by GzipHandler
+func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
+	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("service-status-gzipped")
+	} else {
+		value, exists = cache.Get("service-status")
+	}
+	var data []byte
+	if !exists {
+		var err error
+		buffer := &bytes.Buffer{}
+		gzipWriter := gzip.NewWriter(buffer)
+		data, err = watchdog.GetServiceStatusesAsJSON()
+		if err != nil {
+			log.Printf("[controller][serviceStatusesHandler] Unable to marshal object to JSON: %s", err.Error())
+			writer.WriteHeader(http.StatusInternalServerError)
+			_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
+			return
+		}
+		_, _ = gzipWriter.Write(data)
+		_ = gzipWriter.Close()
+		gzippedData := buffer.Bytes()
+		cache.SetWithTTL("service-status", data, cacheTTL)
+		cache.SetWithTTL("service-status-gzipped", gzippedData, cacheTTL)
+		if gzipped {
+			data = gzippedData
+		}
+	} else {
+		data = value.([]byte)
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(data)
+}
+
+// serviceStatusHandler retrieves a single ServiceStatus by group name and service name
+func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	serviceStatus := watchdog.GetServiceStatusByKey(vars["key"])
+	if serviceStatus == nil {
+		log.Printf("[controller][serviceStatusHandler] Service with key=%s not found", vars["key"])
+		writer.WriteHeader(http.StatusNotFound)
+		_, _ = writer.Write([]byte("not found"))
+		return
+	}
+	data := map[string]interface{}{
+		"serviceStatus": serviceStatus,
+		// This is my lazy way of exposing events even though they're not visible from the json annotation
+		// present in ServiceStatus. We do this because creating a separate object for each endpoints
+		// would be wasteful (one with and one without Events)
+		"events": serviceStatus.Events,
+	}
+	output, err := json.Marshal(data)
+	if err != nil {
+		log.Printf("[controller][serviceStatusHandler] Unable to marshal object to JSON: %s", err.Error())
+		writer.WriteHeader(http.StatusInternalServerError)
+		_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
+		return
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(output)
+}
+
+func healthHandler(writer http.ResponseWriter, _ *http.Request) {
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write([]byte("{\"status\":\"UP\"}"))
+}
+
+// favIconHandler handles requests for /favicon.ico
+func favIconHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, "./web/static/favicon.ico")
+}
+
+// spaHandler handles requests for /favicon.ico
+func spaHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, "./web/static/index.html")
+}

controller/cors.go

@@ -0,0 +1,10 @@
+package controller
+
+import "net/http"
+
+func developmentCorsHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "http://localhost:8081")
+		next.ServeHTTP(w, r)
+	})
+}

controller/gzip.go

@@ -1,4 +1,4 @@
-package main
+package controller
 
 import (
 	"compress/gzip"
@@ -20,17 +20,30 @@ type gzipResponseWriter struct {
 	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 http.HandlerFunc(func(writer http.ResponseWriter, r *http.Request) {
+	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)
@@ -42,5 +55,5 @@ func GzipHandler(next http.Handler) http.Handler {
 		gz.Reset(writer)
 		defer gz.Close()
 		next.ServeHTTP(&gzipResponseWriter{ResponseWriter: writer, Writer: gz}, r)
-	})
+	}
 }

core/alert.go

@@ -26,14 +26,35 @@ type Alert struct {
 
 	// Triggered is used to determine whether an alert has been triggered. When an alert is resolved, this value
 	// should be set back to false. It is used to prevent the same alert from going out twice.
+	//
+	// This value should only be modified if the provider.AlertProvider's Send function does not return an error for an
+	// alert that hasn't been triggered yet. This doubles as a lazy retry. The reason why this behavior isn't also
+	// applied for alerts that are already triggered and has become "healthy" again is to prevent a case where, for
+	// some reason, the alert provider always returns errors when trying to send the resolved notification
+	// (SendOnResolved).
 	Triggered bool
 }
 
+// AlertType is the type of the alert.
+// The value will generally be the name of the alert provider
 type AlertType string
 
 const (
-	SlackAlert     AlertType = "slack"
+	// SlackAlert is the AlertType for the slack alerting provider
+	SlackAlert AlertType = "slack"
+
+	// MattermostAlert is the AlertType for the mattermost alerting provider
+	MattermostAlert AlertType = "mattermost"
+
+	// MessagebirdAlert is the AlertType for the messagebird alerting provider
+	MessagebirdAlert AlertType = "messagebird"
+
+	// PagerDutyAlert is the AlertType for the pagerduty alerting provider
 	PagerDutyAlert AlertType = "pagerduty"
-	TwilioAlert    AlertType = "twilio"
-	CustomAlert    AlertType = "custom"
+
+	// TwilioAlert is the AlertType for the twilio alerting provider
+	TwilioAlert AlertType = "twilio"
+
+	// CustomAlert is the AlertType for the custom alerting provider
+	CustomAlert AlertType = "custom"
 )

core/condition-result.go

@@ -0,0 +1,10 @@
+package core
+
+// ConditionResult result of a Condition
+type ConditionResult struct {
+	// Condition that was evaluated
+	Condition string `json:"condition"`
+
+	// Success whether the condition was met (successful) or not (failed)
+	Success bool `json:"success"`
+}

core/condition.go

@@ -2,51 +2,122 @@ package core
 
 import (
 	"fmt"
-	"github.com/TwinProduction/gatus/pattern"
-	"log"
+	"strconv"
 	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/jsonpath"
+	"github.com/TwinProduction/gatus/pattern"
 )
 
+const (
+	// StatusPlaceholder is a placeholder for a HTTP status.
+	//
+	// Values that could replace the placeholder: 200, 404, 500, ...
+	StatusPlaceholder = "[STATUS]"
+
+	// IPPlaceholder is a placeholder for an IP.
+	//
+	// Values that could replace the placeholder: 127.0.0.1, 10.0.0.1, ...
+	IPPlaceholder = "[IP]"
+
+	// DNSRCodePlaceholder is a place holder for DNS_RCODE
+	//
+	// Values that could be NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP and REFUSED
+	DNSRCodePlaceholder = "[DNS_RCODE]"
+
+	// ResponseTimePlaceholder is a placeholder for the request response time, in milliseconds.
+	//
+	// Values that could replace the placeholder: 1, 500, 1000, ...
+	ResponseTimePlaceholder = "[RESPONSE_TIME]"
+
+	// BodyPlaceholder is a placeholder for the body of the response
+	//
+	// Values that could replace the placeholder: {}, {"data":{"name":"john"}}, ...
+	BodyPlaceholder = "[BODY]"
+
+	// ConnectedPlaceholder is a placeholder for whether a connection was successfully established.
+	//
+	// Values that could replace the placeholder: true, false
+	ConnectedPlaceholder = "[CONNECTED]"
+
+	// CertificateExpirationPlaceholder is a placeholder for the duration before certificate expiration, in milliseconds.
+	//
+	// Values that could replace the placeholder: 4461677039 (~52 days)
+	CertificateExpirationPlaceholder = "[CERTIFICATE_EXPIRATION]"
+
+	// LengthFunctionPrefix is the prefix for the length function
+	//
+	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
+	LengthFunctionPrefix = "len("
+
+	// PatternFunctionPrefix is the prefix for the pattern function
+	//
+	// Usage: pat(192.168.*.*)
+	PatternFunctionPrefix = "pat("
+
+	// AnyFunctionPrefix is the prefix for the any function
+	//
+	// Usage: any(1.1.1.1, 1.0.0.1)
+	AnyFunctionPrefix = "any("
+
+	// FunctionSuffix is the suffix for all functions
+	FunctionSuffix = ")"
+
+	// InvalidConditionElementSuffix is the suffix that will be appended to an invalid condition
+	InvalidConditionElementSuffix = "(INVALID)"
+)
+
+// Condition is a condition that needs to be met in order for a Service to be considered healthy.
 type Condition string
 
 // evaluate the Condition with the Result of the health check
-func (c *Condition) evaluate(result *Result) bool {
-	condition := string(*c)
+func (c Condition) evaluate(result *Result) bool {
+	condition := string(c)
 	success := false
-	var resolvedCondition string
+	conditionToDisplay := condition
 	if strings.Contains(condition, "==") {
-		parts := sanitizeAndResolve(strings.Split(condition, "=="), result)
-		success = isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v == %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "=="), result)
+		success = isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "==")
+		}
 	} else if strings.Contains(condition, "!=") {
-		parts := sanitizeAndResolve(strings.Split(condition, "!="), result)
-		success = !isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v != %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "!="), result)
+		success = !isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "!=")
+		}
 	} else if strings.Contains(condition, "<=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
-		success = parts[0] <= parts[1]
-		resolvedCondition = fmt.Sprintf("%v <= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
+		success = resolvedParameters[0] <= resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<=")
+		}
 	} else if strings.Contains(condition, ">=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
-		success = parts[0] >= parts[1]
-		resolvedCondition = fmt.Sprintf("%v >= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
+		success = resolvedParameters[0] >= resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">=")
+		}
 	} else if strings.Contains(condition, ">") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
-		success = parts[0] > parts[1]
-		resolvedCondition = fmt.Sprintf("%v > %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
+		success = resolvedParameters[0] > resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">")
+		}
 	} else if strings.Contains(condition, "<") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
-		success = parts[0] < parts[1]
-		resolvedCondition = fmt.Sprintf("%v < %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
+		success = resolvedParameters[0] < resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<")
+		}
 	} else {
 		result.Errors = append(result.Errors, fmt.Sprintf("invalid condition '%s' has been provided", condition))
 		return false
 	}
-	conditionToDisplay := condition
-	// If the condition isn't a success, return what the resolved condition was too
 	if !success {
-		log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, resolvedCondition)
-		conditionToDisplay = fmt.Sprintf("%s (%s)", condition, resolvedCondition)
+		//log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, condition)
 	}
 	result.ConditionResults = append(result.ConditionResults, &ConditionResult{Condition: conditionToDisplay, Success: success})
 	return success
@@ -54,23 +125,151 @@ func (c *Condition) evaluate(result *Result) bool {
 
 // isEqual compares two strings.
 //
-// It also supports the pattern function. That is to say, if one of the strings starts with PatternFunctionPrefix
-// and ends with FunctionSuffix, it will be treated like a pattern.
+// Supports the pattern and the any functions.
+// i.e. if one of the parameters starts with PatternFunctionPrefix and ends with FunctionSuffix, it will be treated like
+// a pattern.
 func isEqual(first, second string) bool {
-	var isFirstPattern, isSecondPattern bool
-	if strings.HasPrefix(first, PatternFunctionPrefix) && strings.HasSuffix(first, FunctionSuffix) {
-		isFirstPattern = true
-		first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if strings.HasPrefix(second, PatternFunctionPrefix) && strings.HasSuffix(second, FunctionSuffix) {
-		isSecondPattern = true
-		second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if isFirstPattern && !isSecondPattern {
-		return pattern.Match(first, second)
-	} else if !isFirstPattern && isSecondPattern {
-		return pattern.Match(second, first)
-	} else {
-		return first == second
+	firstHasFunctionSuffix := strings.HasSuffix(first, FunctionSuffix)
+	secondHasFunctionSuffix := strings.HasSuffix(second, FunctionSuffix)
+	if firstHasFunctionSuffix || secondHasFunctionSuffix {
+		var isFirstPattern, isSecondPattern bool
+		if strings.HasPrefix(first, PatternFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstPattern = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, PatternFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondPattern = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstPattern && !isSecondPattern {
+			return pattern.Match(first, second)
+		} else if !isFirstPattern && isSecondPattern {
+			return pattern.Match(second, first)
+		}
+		var isFirstAny, isSecondAny bool
+		if strings.HasPrefix(first, AnyFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstAny = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, AnyFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondAny = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstAny && !isSecondAny {
+			options := strings.Split(first, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == second {
+					return true
+				}
+			}
+			return false
+		} else if !isFirstAny && isSecondAny {
+			options := strings.Split(second, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == first {
+					return true
+				}
+			}
+			return false
+		}
 	}
+	return first == second
+}
+
+// sanitizeAndResolve sanitizes and resolves a list of elements and returns the list of parameters as well as a list
+// of resolved parameters
+func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
+	parameters := make([]string, len(elements))
+	resolvedParameters := make([]string, len(elements))
+	body := strings.TrimSpace(string(result.Body))
+	for i, element := range elements {
+		element = strings.TrimSpace(element)
+		parameters[i] = element
+		switch strings.ToUpper(element) {
+		case StatusPlaceholder:
+			element = strconv.Itoa(result.HTTPStatus)
+		case IPPlaceholder:
+			element = result.IP
+		case ResponseTimePlaceholder:
+			element = strconv.Itoa(int(result.Duration.Milliseconds()))
+		case BodyPlaceholder:
+			element = body
+		case DNSRCodePlaceholder:
+			element = result.DNSRCode
+		case ConnectedPlaceholder:
+			element = strconv.FormatBool(result.Connected)
+		case CertificateExpirationPlaceholder:
+			element = strconv.FormatInt(result.CertificateExpiration.Milliseconds(), 10)
+		default:
+			// if contains the BodyPlaceholder, then evaluate json path
+			if strings.Contains(element, BodyPlaceholder) {
+				wantLength := false
+				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
+					wantLength = true
+					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
+				}
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(element, BodyPlaceholder+"."), result.Body)
+				if err != nil {
+					if err.Error() != "unexpected end of JSON input" {
+						result.Errors = append(result.Errors, err.Error())
+					}
+					if wantLength {
+						element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix
+					} else {
+						element = element + " " + InvalidConditionElementSuffix
+					}
+				} else {
+					if wantLength {
+						element = strconv.Itoa(resolvedElementLength)
+					} else {
+						element = resolvedElement
+					}
+				}
+			}
+		}
+		resolvedParameters[i] = element
+	}
+	return parameters, resolvedParameters
+}
+
+func sanitizeAndResolveNumerical(list []string, result *Result) (parameters []string, resolvedNumericalParameters []int64) {
+	parameters, resolvedParameters := sanitizeAndResolve(list, result)
+	for _, element := range resolvedParameters {
+		if duration, err := time.ParseDuration(element); duration != 0 && err == nil {
+			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)
+		} else {
+			resolvedNumericalParameters = append(resolvedNumericalParameters, number)
+		}
+	}
+	return parameters, resolvedNumericalParameters
+}
+
+func prettifyNumericalParameters(parameters []string, resolvedParameters []int64, operator string) string {
+	return prettify(parameters, []string{strconv.Itoa(int(resolvedParameters[0])), strconv.Itoa(int(resolvedParameters[1]))}, operator)
+}
+
+// XXX: make this configurable? i.e. show-resolved-conditions-on-failure
+func prettify(parameters []string, resolvedParameters []string, operator string) string {
+	// Since, in the event of an invalid path, the resolvedParameters also contain the condition itself,
+	// we'll return the resolvedParameters as-is.
+	if strings.HasSuffix(resolvedParameters[0], InvalidConditionElementSuffix) || strings.HasSuffix(resolvedParameters[1], InvalidConditionElementSuffix) {
+		return resolvedParameters[0] + " " + operator + " " + resolvedParameters[1]
+	}
+	// First element is a placeholder
+	if parameters[0] != resolvedParameters[0] && parameters[1] == resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1]
+	}
+	// Second element is a placeholder
+	if parameters[0] == resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Both elements are placeholders...?
+	if parameters[0] != resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Neither elements are placeholders
+	return parameters[0] + " " + operator + " " + parameters[1]
 }

core/condition_bench_test.go

@@ -0,0 +1,75 @@
+package core
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+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\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithStatus(b *testing.B) {
+	condition := Condition("[STATUS] == 200")
+	for n := 0; n < b.N; n++ {
+		result := &Result{HTTPStatus: 200}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithStatusFailure(b *testing.B) {
+	condition := Condition("[STATUS] == 200")
+	for n := 0; n < b.N; n++ {
+		result := &Result{HTTPStatus: 400}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}

core/condition_test.go

@@ -1,13 +1,15 @@
 package core
 
 import (
+	"fmt"
+	"strconv"
 	"testing"
 	"time"
 )
 
-func TestCondition_evaluateWithIp(t *testing.T) {
+func TestCondition_evaluateWithIP(t *testing.T) {
 	condition := Condition("[IP] == 127.0.0.1")
-	result := &Result{Ip: "127.0.0.1"}
+	result := &Result{IP: "127.0.0.1"}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
@@ -16,38 +18,53 @@ func TestCondition_evaluateWithIp(t *testing.T) {
 
 func TestCondition_evaluateWithStatus(t *testing.T) {
 	condition := Condition("[STATUS] == 201")
-	result := &Result{HttpStatus: 201}
+	result := &Result{HTTPStatus: 201}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	if result.ConditionResults[0].Condition != string(condition) {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, condition, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusFailure(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
-	result := &Result{HttpStatus: 500}
+	result := &Result{HTTPStatus: 500}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (500) == 200"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusUsingLessThan(t *testing.T) {
 	condition := Condition("[STATUS] < 300")
-	result := &Result{HttpStatus: 201}
+	result := &Result{HTTPStatus: 201}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] < 300"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusFailureUsingLessThan(t *testing.T) {
 	condition := Condition("[STATUS] < 300")
-	result := &Result{HttpStatus: 404}
+	result := &Result{HTTPStatus: 404}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (404) < 300"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
@@ -57,15 +74,64 @@ func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] < 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithResponseTimeUsingLessThanDuration(t *testing.T) {
+	condition := Condition("[RESPONSE_TIME] < 1s")
+	result := &Result{Duration: time.Millisecond * 50}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] < 1s"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithResponseTimeUsingLessThanInvalid(t *testing.T) {
+	condition := Condition("[RESPONSE_TIME] < potato")
+	result := &Result{Duration: time.Millisecond * 50}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have failed because the condition has an invalid numerical value that should've automatically resolved to 0", condition)
+	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] (50) < potato (0)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingGreaterThan(t *testing.T) {
+	// Not exactly sure why you'd want to have a condition that checks if the response time is too fast,
+	// but hey, who am I to judge?
 	condition := Condition("[RESPONSE_TIME] > 500")
 	result := &Result{Duration: time.Millisecond * 750}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] > 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithResponseTimeUsingGreaterThanDuration(t *testing.T) {
+	condition := Condition("[RESPONSE_TIME] > 1s")
+	result := &Result{Duration: time.Second * 2}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] > 1s"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.T) {
@@ -75,6 +141,10 @@ func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] >= 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T) {
@@ -84,6 +154,10 @@ func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] <= 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBody(t *testing.T) {
@@ -93,96 +167,166 @@ func TestCondition_evaluateWithBody(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY] == test"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPath(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPath(t *testing.T) {
 	condition := Condition("[BODY].status == UP")
 	result := &Result{Body: []byte("{\"status\":\"UP\"}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].status == UP"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplex(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplex(t *testing.T) {
 	condition := Condition("[BODY].data.name == john")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.name == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathDoublePlaceholders(t *testing.T) {
+func TestCondition_evaluateWithInvalidBodyJSONPathComplex(t *testing.T) {
+	condition := Condition("[BODY].data.name == john")
+	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
+	}
+	expectedConditionDisplayed := "[BODY].data.name (INVALID) == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithInvalidBodyJSONPathComplexWithLengthFunction(t *testing.T) {
+	condition := Condition("len([BODY].data.name) == john")
+	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
+	}
+	expectedConditionDisplayed := "len([BODY].data.name) (INVALID) == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyJSONPathDoublePlaceholders(t *testing.T) {
 	condition := Condition("[BODY].user.firstName != [BODY].user.lastName")
 	result := &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].user.firstName != [BODY].user.lastName"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathDoublePlaceholdersFailure(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathDoublePlaceholdersFailure(t *testing.T) {
 	condition := Condition("[BODY].user.firstName == [BODY].user.lastName")
 	result := &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].user.firstName (john) == [BODY].user.lastName (doe)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathLongInt(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathLongInt(t *testing.T) {
 	condition := Condition("[BODY].data.id == 1")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id == 1"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplexInt(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplexInt(t *testing.T) {
 	condition := Condition("[BODY].data[1].id == 2")
 	result := &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data[1].id == 2"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplexIntUsingGreaterThan(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplexIntUsingGreaterThan(t *testing.T) {
 	condition := Condition("[BODY].data.id > 0")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id > 0"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplexIntFailureUsingGreaterThan(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingGreaterThan(t *testing.T) {
 	condition := Condition("[BODY].data.id > 5")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id (1) > 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplexIntUsingLessThan(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplexIntUsingLessThan(t *testing.T) {
 	condition := Condition("[BODY].data.id < 5")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 2}}")}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id < 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
-func TestCondition_evaluateWithBodyJsonPathComplexIntFailureUsingLessThan(t *testing.T) {
+func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingLessThan(t *testing.T) {
 	condition := Condition("[BODY].data.id < 5")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 10}}")}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id (10) < 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
@@ -192,6 +336,10 @@ func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "len([BODY].data) == 3"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
@@ -201,6 +349,36 @@ func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "len([BODY].name) == 8"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyPattern(t *testing.T) {
+	condition := Condition("[BODY] == pat(*john*)")
+	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[BODY] == pat(*john*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithReverseBodyPattern(t *testing.T) {
+	condition := Condition("pat(*john*) == [BODY]")
+	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "pat(*john*) == [BODY]"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringPattern(t *testing.T) {
@@ -210,6 +388,24 @@ func TestCondition_evaluateWithBodyStringPattern(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].name == pat(*ohn*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyHTMLPattern(t *testing.T) {
+	var html = `<!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>`
+	condition := Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)")
+	result := &Result{Body: []byte(html)}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[BODY] == pat(*<div id=\"user\">john.doe</div>*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringPatternFailure(t *testing.T) {
@@ -219,49 +415,248 @@ func TestCondition_evaluateWithBodyStringPatternFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
-}
-
-func TestCondition_evaluateWithBodyPatternFailure(t *testing.T) {
-	condition := Condition("[BODY] == pat(*john*)")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
+	expectedConditionDisplayed := "[BODY].name (john.doe) == pat(bob*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
 	}
 }
 
 func TestCondition_evaluateWithIPPattern(t *testing.T) {
 	condition := Condition("[IP] == pat(10.*)")
-	result := &Result{Ip: "10.0.0.0"}
+	result := &Result{IP: "10.0.0.0"}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[IP] == pat(10.*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithIPPatternFailure(t *testing.T) {
 	condition := Condition("[IP] == pat(10.*)")
-	result := &Result{Ip: "255.255.255.255"}
+	result := &Result{IP: "255.255.255.255"}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[IP] (255.255.255.255) == pat(10.*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusPattern(t *testing.T) {
 	condition := Condition("[STATUS] == pat(4*)")
-	result := &Result{HttpStatus: 404}
+	result := &Result{HTTPStatus: 404}
 	condition.evaluate(result)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] == pat(4*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusPatternFailure(t *testing.T) {
 	condition := Condition("[STATUS] != pat(4*)")
-	result := &Result{HttpStatus: 404}
+	result := &Result{HTTPStatus: 404}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (404) != pat(4*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyStringAny(t *testing.T) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	expectedConditionDisplayed := "[BODY].name == any(john.doe, jane.doe)"
+	results := []*Result{
+		{Body: []byte("{\"name\": \"john.doe\"}")},
+		{Body: []byte("{\"name\": \"jane.doe\"}")},
+	}
+	for _, result := range results {
+		success := condition.evaluate(result)
+		if !success || !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithBodyStringAnyFailure(t *testing.T) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	expectedConditionDisplayed := "[BODY].name (bob.doe) == any(john.doe, jane.doe)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithStatusAny(t *testing.T) {
+	condition := Condition("[STATUS] == any(200, 429)")
+	statuses := []int{200, 429}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		expectedConditionDisplayed := "[STATUS] == any(200, 429)"
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithReverseStatusAny(t *testing.T) {
+	condition := Condition("any(200, 429) == [STATUS]")
+	statuses := []int{200, 429}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		expectedConditionDisplayed := "any(200, 429) == [STATUS]"
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithStatusAnyFailure(t *testing.T) {
+	condition := Condition("[STATUS] == any(200, 429)")
+	statuses := []int{201, 400, 404, 500}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a failure", condition)
+		}
+		expectedConditionDisplayed := fmt.Sprintf("[STATUS] (%d) == any(200, 429)", status)
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithReverseStatusAnyFailure(t *testing.T) {
+	condition := Condition("any(200, 429) == [STATUS]")
+	statuses := []int{201, 400, 404, 500}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a failure", condition)
+		}
+		expectedConditionDisplayed := fmt.Sprintf("any(200, 429) == [STATUS] (%d)", status)
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithConnected(t *testing.T) {
+	condition := Condition("[CONNECTED] == true")
+	result := &Result{Connected: true}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[CONNECTED] == true"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithConnectedFailure(t *testing.T) {
+	condition := Condition("[CONNECTED] == true")
+	result := &Result{Connected: false}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	expectedConditionDisplayed := "[CONNECTED] (false) == true"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithUnsetCertificateExpiration(t *testing.T) {
+	condition := Condition("[CERTIFICATE_EXPIRATION] == 0")
+	result := &Result{}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] == 0"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithCertificateExpirationGreaterThanNumerical(t *testing.T) {
+	acceptable := (time.Hour * 24 * 28).Milliseconds()
+	condition := Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt(acceptable, 10))
+	result := &Result{CertificateExpiration: time.Hour * 24 * 60}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] > 2419200000"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithCertificateExpirationGreaterThanNumericalFailure(t *testing.T) {
+	acceptable := (time.Hour * 24 * 28).Milliseconds()
+	condition := Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt(acceptable, 10))
+	result := &Result{CertificateExpiration: time.Hour * 24 * 14}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] (1209600000) > 2419200000"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithCertificateExpirationGreaterThanDuration(t *testing.T) {
+	condition := Condition("[CERTIFICATE_EXPIRATION] > 12h")
+	result := &Result{CertificateExpiration: 24 * time.Hour}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] > 12h"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithCertificateExpirationGreaterThanDurationFailure(t *testing.T) {
+	condition := Condition("[CERTIFICATE_EXPIRATION] > 48h")
+	result := &Result{CertificateExpiration: 24 * time.Hour}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] (86400000) > 48h (172800000)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }

core/dns.go

@@ -0,0 +1,85 @@
+package core
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/miekg/dns"
+)
+
+var (
+	// ErrDNSWithNoQueryName is the error with which gatus will panic if a dns is configured without query name
+	ErrDNSWithNoQueryName = errors.New("you must specify a query name for DNS")
+
+	// ErrDNSWithInvalidQueryType is the error with which gatus will panic if a dns is configured with invalid query type
+	ErrDNSWithInvalidQueryType = errors.New("invalid query type")
+)
+
+const (
+	dnsPort = 53
+)
+
+// DNS is the configuration for a Service of type DNS
+type DNS struct {
+	// QueryType is the type for the DNS records like A, AAAA, CNAME...
+	QueryType string `yaml:"query-type"`
+
+	// QueryName is the query for DNS
+	QueryName string `yaml:"query-name"`
+}
+
+func (d *DNS) validateAndSetDefault() {
+	if len(d.QueryName) == 0 {
+		panic(ErrDNSWithNoQueryName)
+	}
+	if !strings.HasSuffix(d.QueryName, ".") {
+		d.QueryName += "."
+	}
+	if _, ok := dns.StringToType[d.QueryType]; !ok {
+		panic(ErrDNSWithInvalidQueryType)
+	}
+}
+
+func (d *DNS) query(url string, result *Result) {
+	if !strings.Contains(url, ":") {
+		url = fmt.Sprintf("%s:%d", url, dnsPort)
+	}
+	queryType := dns.StringToType[d.QueryType]
+	c := new(dns.Client)
+	m := new(dns.Msg)
+	m.SetQuestion(d.QueryName, queryType)
+	r, _, err := c.Exchange(m, url)
+	if err != nil {
+		result.Errors = append(result.Errors, err.Error())
+		return
+	}
+	result.Connected = true
+	result.DNSRCode = dns.RcodeToString[r.Rcode]
+	for _, rr := range r.Answer {
+		switch rr.Header().Rrtype {
+		case dns.TypeA:
+			if a, ok := rr.(*dns.A); ok {
+				result.Body = []byte(a.A.String())
+			}
+		case dns.TypeAAAA:
+			if aaaa, ok := rr.(*dns.AAAA); ok {
+				result.Body = []byte(aaaa.AAAA.String())
+			}
+		case dns.TypeCNAME:
+			if cname, ok := rr.(*dns.CNAME); ok {
+				result.Body = []byte(cname.Target)
+			}
+		case dns.TypeMX:
+			if mx, ok := rr.(*dns.MX); ok {
+				result.Body = []byte(mx.Mx)
+			}
+		case dns.TypeNS:
+			if ns, ok := rr.(*dns.NS); ok {
+				result.Body = []byte(ns.Ns)
+			}
+		default:
+			result.Body = []byte("query type is not supported yet")
+		}
+	}
+}

core/dns_test.go

@@ -0,0 +1,124 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/TwinProduction/gatus/pattern"
+)
+
+func TestIntegrationQuery(t *testing.T) {
+	tests := []struct {
+		name            string
+		inputDNS        DNS
+		inputURL        string
+		expectedDNSCode string
+		expectedBody    string
+		isErrExpected   bool
+	}{
+		{
+			name: "test DNS with type A",
+			inputDNS: DNS{
+				QueryType: "A",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "93.184.216.34",
+		},
+		{
+			name: "test DNS with type AAAA",
+			inputDNS: DNS{
+				QueryType: "AAAA",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "2606:2800:220:1:248:1893:25c8:1946",
+		},
+		{
+			name: "test DNS with type CNAME",
+			inputDNS: DNS{
+				QueryType: "CNAME",
+				QueryName: "doc.google.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "writely.l.google.com.",
+		},
+		{
+			name: "test DNS with type MX",
+			inputDNS: DNS{
+				QueryType: "MX",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    ".",
+		},
+		{
+			name: "test DNS with type NS",
+			inputDNS: DNS{
+				QueryType: "NS",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "*.iana-servers.net.",
+		},
+		{
+			name: "test DNS with fake type and retrieve error",
+			inputDNS: DNS{
+				QueryType: "B",
+				QueryName: "google",
+			},
+			inputURL:      "8.8.8.8",
+			isErrExpected: true,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			dns := test.inputDNS
+			result := &Result{}
+			dns.query(test.inputURL, result)
+			if test.isErrExpected && len(result.Errors) == 0 {
+				t.Errorf("there should be errors")
+			}
+			if result.DNSRCode != test.expectedDNSCode {
+				t.Errorf("DNSRCodePlaceholder '%s' should have been %s", result.DNSRCode, test.expectedDNSCode)
+			}
+
+			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)
+				}
+			} else {
+				if string(result.Body) != test.expectedBody {
+					t.Errorf("got %s, expected result %s,", string(result.Body), test.expectedBody)
+				}
+			}
+		})
+	}
+}
+
+func TestService_ValidateAndSetDefaultsWithNoDNSQueryName(t *testing.T) {
+	defer func() { recover() }()
+	dns := &DNS{
+		QueryType: "A",
+		QueryName: "",
+	}
+	dns.validateAndSetDefault()
+	t.Fatal("Should've panicked because service`s dns didn't have a query name, which is a mandatory field for dns")
+}
+
+func TestService_ValidateAndSetDefaultsWithInvalidDNSQueryType(t *testing.T) {
+	defer func() { recover() }()
+	dns := &DNS{
+		QueryType: "B",
+		QueryName: "example.com",
+	}
+	dns.validateAndSetDefault()
+	t.Fatal("Should've panicked because service`s dns query type is invalid, it needs to be a valid query name like A, AAAA, CNAME...")
+}

core/event.go

@@ -0,0 +1,26 @@
+package core
+
+import "time"
+
+// Event is something that happens at a specific time
+type Event struct {
+	// Type is the kind of event
+	Type EventType `json:"type"`
+
+	// Timestamp is the moment at which the event happened
+	Timestamp time.Time `json:"timestamp"`
+}
+
+// EventType is, uh, the types of events?
+type EventType string
+
+var (
+	// EventStart is a type of event that represents when a service starts being monitored
+	EventStart EventType = "START"
+
+	// EventHealthy is a type of event that represents a service passing all of its conditions
+	EventHealthy EventType = "HEALTHY"
+
+	// EventUnhealthy is a type of event that represents a service failing one or more of its conditions
+	EventUnhealthy EventType = "UNHEALTHY"
+)

core/health-status.go

@@ -0,0 +1,11 @@
+package core
+
+// HealthStatus is the status of Gatus
+type HealthStatus struct {
+	// Status is the state of Gatus (UP/DOWN)
+	Status string `json:"status"`
+
+	// Message is an accompanying description of why the status is as reported.
+	// If the Status is UP, no message will be provided
+	Message string `json:"message,omitempty"`
+}

core/result.go

@@ -0,0 +1,44 @@
+package core
+
+import (
+	"time"
+)
+
+// Result of the evaluation of a Service
+type Result struct {
+	// HTTPStatus is the HTTP response status code
+	HTTPStatus int `json:"status"`
+
+	// DNSRCode is the response code of a DNS query in a human readable format
+	DNSRCode string `json:"-"`
+
+	// Body is the response body
+	Body []byte `json:"-"`
+
+	// Hostname extracted from the Service URL
+	Hostname string `json:"hostname"`
+
+	// IP resolved from the Service URL
+	IP string `json:"-"`
+
+	// Connected whether a connection to the host was established successfully
+	Connected bool `json:"-"`
+
+	// Duration time that the request took
+	Duration time.Duration `json:"duration"`
+
+	// Errors encountered during the evaluation of the service's health
+	Errors []string `json:"errors"`
+
+	// ConditionResults results of the service's conditions
+	ConditionResults []*ConditionResult `json:"conditionResults"`
+
+	// Success whether the result signifies a success or not
+	Success bool `json:"success"`
+
+	// Timestamp when the request was sent
+	Timestamp time.Time `json:"timestamp"`
+
+	// CertificateExpiration is the duration before the certificate expires
+	CertificateExpiration time.Duration `json:"-"`
+}

core/service-status.go

@@ -0,0 +1,73 @@
+package core
+
+import (
+	"time"
+
+	"github.com/TwinProduction/gatus/util"
+)
+
+// ServiceStatus contains the evaluation Results of a Service
+type ServiceStatus struct {
+	// Name of the service
+	Name string `json:"name,omitempty"`
+
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `json:"group,omitempty"`
+
+	// Key is the key representing the ServiceStatus
+	Key string `json:"key"`
+
+	// Results is the list of service evaluation results
+	Results []*Result `json:"results"`
+
+	// Events is a list of events
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have these events.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Events []*Event `json:"-"`
+
+	// Uptime information on the service's uptime
+	Uptime *Uptime `json:"uptime"`
+}
+
+// NewServiceStatus creates a new ServiceStatus
+func NewServiceStatus(service *Service) *ServiceStatus {
+	return &ServiceStatus{
+		Name:    service.Name,
+		Group:   service.Group,
+		Key:     util.ConvertGroupAndServiceToKey(service.Group, service.Name),
+		Results: make([]*Result, 0),
+		Events: []*Event{{
+			Type:      EventStart,
+			Timestamp: time.Now(),
+		}},
+		Uptime: NewUptime(),
+	}
+}
+
+// AddResult adds a Result to ServiceStatus.Results and makes sure that there are
+// no more than 20 results in the Results slice
+func (ss *ServiceStatus) AddResult(result *Result) {
+	if len(ss.Results) > 0 {
+		// Check if there's any change since the last result
+		// OR there's only 1 event, which only happens when there's a start event
+		if ss.Results[len(ss.Results)-1].Success != result.Success || len(ss.Events) == 1 {
+			event := &Event{Timestamp: result.Timestamp}
+			if result.Success {
+				event.Type = EventHealthy
+			} else {
+				event.Type = EventUnhealthy
+			}
+			ss.Events = append(ss.Events, event)
+			if len(ss.Events) > 20 {
+				ss.Events = ss.Events[1:]
+			}
+		}
+	}
+	ss.Results = append(ss.Results, result)
+	if len(ss.Results) > 20 {
+		ss.Results = ss.Results[1:]
+	}
+	ss.Uptime.ProcessResult(result)
+}

core/service-status_test.go

@@ -0,0 +1,31 @@
+package core
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNewServiceStatus(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	if serviceStatus.Name != service.Name {
+		t.Errorf("expected %s, got %s", service.Name, serviceStatus.Name)
+	}
+	if serviceStatus.Group != service.Group {
+		t.Errorf("expected %s, got %s", service.Group, serviceStatus.Group)
+	}
+	if serviceStatus.Key != "group_name" {
+		t.Errorf("expected %s, got %s", "group_name", serviceStatus.Key)
+	}
+}
+
+func TestServiceStatus_AddResult(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	for i := 0; i < 50; i++ {
+		serviceStatus.AddResult(&Result{Timestamp: time.Now()})
+	}
+	if len(serviceStatus.Results) != 20 {
+		t.Errorf("expected serviceStatus.Results to not exceed a length of 20")
+	}
+}

core/service.go

@@ -4,17 +4,39 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"github.com/TwinProduction/gatus/client"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
+
+	"github.com/TwinProduction/gatus/client"
+)
+
+const (
+	// HostHeader is the name of the header used to specify the host
+	HostHeader = "Host"
+
+	// ContentTypeHeader is the name of the header used to specify the content type
+	ContentTypeHeader = "Content-Type"
+
+	// UserAgentHeader is the name of the header used to specify the request's user agent
+	UserAgentHeader = "User-Agent"
+
+	// GatusUserAgent is the default user agent that Gatus uses to send requests.
+	GatusUserAgent = "Gatus/1.0"
 )
 
 var (
-	ErrNoCondition = errors.New("you must specify at least one condition per service")
-	ErrNoUrl       = errors.New("you must specify an url for each service")
+	// ErrServiceWithNoCondition is the error with which Gatus will panic if a service is configured with no conditions
+	ErrServiceWithNoCondition = errors.New("you must specify at least one condition per service")
+
+	// ErrServiceWithNoURL is the error with which Gatus will panic if a service is configured with no url
+	ErrServiceWithNoURL = errors.New("you must specify an url for each service")
+
+	// ErrServiceWithNoName is the error with which Gatus will panic if a service is configured with no name
+	ErrServiceWithNoName = errors.New("you must specify a name for each service")
 )
 
 // Service is the configuration of a monitored endpoint
@@ -22,8 +44,14 @@ type Service struct {
 	// Name of the service. Can be anything.
 	Name string `yaml:"name"`
 
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `yaml:"group,omitempty"`
+
 	// URL to send the request to
-	Url string `yaml:"url"`
+	URL string `yaml:"url"`
+
+	// DNS is the configuration of DNS monitoring
+	DNS *DNS `yaml:"dns,omitempty"`
 
 	// Method of the request made to the url of the service
 	Method string `yaml:"method,omitempty"`
@@ -46,7 +74,13 @@ type Service struct {
 	// Alerts is the alerting configuration for the service in case of failure
 	Alerts []*Alert `yaml:"alerts"`
 
-	NumberOfFailuresInARow  int
+	// Insecure is whether to skip verifying the server's certificate chain and host name
+	Insecure bool `yaml:"insecure,omitempty"`
+
+	// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
+	NumberOfFailuresInARow int
+
+	// NumberOfFailuresInARow is the number of successful evaluations in a row
 	NumberOfSuccessesInARow int
 }
 
@@ -62,6 +96,15 @@ func (service *Service) ValidateAndSetDefaults() {
 	if len(service.Headers) == 0 {
 		service.Headers = make(map[string]string)
 	}
+	// Automatically add user agent header if there isn't one specified in the service configuration
+	if _, userAgentHeaderExists := service.Headers[UserAgentHeader]; !userAgentHeaderExists {
+		service.Headers[UserAgentHeader] = GatusUserAgent
+	}
+	// Automatically add "Content-Type: application/json" header if there's no Content-Type set
+	// and service.GraphQL is set to true
+	if _, contentTypeHeaderExists := service.Headers[ContentTypeHeader]; !contentTypeHeaderExists && service.GraphQL {
+		service.Headers[ContentTypeHeader] = "application/json"
+	}
 	for _, alert := range service.Alerts {
 		if alert.FailureThreshold <= 0 {
 			alert.FailureThreshold = 3
@@ -70,15 +113,21 @@ func (service *Service) ValidateAndSetDefaults() {
 			alert.SuccessThreshold = 2
 		}
 	}
-	if len(service.Url) == 0 {
-		panic(ErrNoUrl)
+	if len(service.Name) == 0 {
+		panic(ErrServiceWithNoName)
+	}
+	if len(service.URL) == 0 {
+		panic(ErrServiceWithNoURL)
 	}
 	if len(service.Conditions) == 0 {
-		panic(ErrNoCondition)
+		panic(ErrServiceWithNoCondition)
+	}
+	if service.DNS != nil {
+		service.DNS.validateAndSetDefault()
+		return
 	}
-
 	// Make sure that the request can be created
-	_, err := http.NewRequest(service.Method, service.Url, bytes.NewBuffer([]byte(service.Body)))
+	_, err := http.NewRequest(service.Method, service.URL, bytes.NewBuffer([]byte(service.Body)))
 	if err != nil {
 		panic(err)
 	}
@@ -87,7 +136,7 @@ func (service *Service) ValidateAndSetDefaults() {
 // EvaluateHealth sends a request to the service's URL and evaluates the conditions of the service.
 func (service *Service) EvaluateHealth() *Result {
 	result := &Result{Success: true, Errors: []string{}}
-	service.getIp(result)
+	service.getIP(result)
 	if len(result.Errors) == 0 {
 		service.call(result)
 	} else {
@@ -103,6 +152,7 @@ func (service *Service) EvaluateHealth() *Result {
 	return result
 }
 
+// GetAlertsTriggered returns a slice of alerts that have been triggered
 func (service *Service) GetAlertsTriggered() []Alert {
 	var alerts []Alert
 	if service.NumberOfFailuresInARow == 0 {
@@ -117,39 +167,66 @@ func (service *Service) GetAlertsTriggered() []Alert {
 	return alerts
 }
 
-func (service *Service) getIp(result *Result) {
-	urlObject, err := url.Parse(service.Url)
+func (service *Service) getIP(result *Result) {
+	if service.DNS != nil {
+		result.Hostname = strings.TrimSuffix(service.URL, ":53")
+	} else {
+		urlObject, err := url.Parse(service.URL)
+		if err != nil {
+			result.Errors = append(result.Errors, err.Error())
+			return
+		}
+		result.Hostname = urlObject.Hostname()
+	}
+	ips, err := net.LookupIP(result.Hostname)
 	if err != nil {
 		result.Errors = append(result.Errors, err.Error())
 		return
 	}
-	result.Hostname = urlObject.Hostname()
-	ips, err := net.LookupIP(urlObject.Hostname())
-	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
-		return
-	}
-	result.Ip = ips[0].String()
+	result.IP = ips[0].String()
 }
 
 func (service *Service) call(result *Result) {
-	request := service.buildRequest()
-	startTime := time.Now()
-	response, err := client.GetHttpClient().Do(request)
-	if err != nil {
-		result.Duration = time.Since(startTime)
-		result.Errors = append(result.Errors, err.Error())
-		return
+	var request *http.Request
+	var response *http.Response
+	var err error
+	isServiceDNS := service.DNS != nil
+	isServiceTCP := strings.HasPrefix(service.URL, "tcp://")
+	isServiceICMP := strings.HasPrefix(service.URL, "icmp://")
+	isServiceHTTP := !isServiceDNS && !isServiceTCP && !isServiceICMP
+	if isServiceHTTP {
+		request = service.buildHTTPRequest()
 	}
-	result.Duration = time.Since(startTime)
-	result.HttpStatus = response.StatusCode
-	result.Body, err = ioutil.ReadAll(response.Body)
-	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+	startTime := time.Now()
+	if isServiceDNS {
+		service.DNS.query(service.URL, result)
+		result.Duration = time.Since(startTime)
+	} else if isServiceTCP {
+		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(service.URL, "tcp://"))
+		result.Duration = time.Since(startTime)
+	} else if isServiceICMP {
+		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(service.URL, "icmp://"))
+	} else {
+		response, err = client.GetHTTPClient(service.Insecure).Do(request)
+		result.Duration = time.Since(startTime)
+		if err != nil {
+			result.Errors = append(result.Errors, err.Error())
+			return
+		}
+		if response.TLS != nil && len(response.TLS.PeerCertificates) > 0 {
+			certificate := response.TLS.PeerCertificates[0]
+			result.CertificateExpiration = certificate.NotAfter.Sub(time.Now())
+		}
+		result.HTTPStatus = response.StatusCode
+		result.Connected = response.StatusCode > 0
+		result.Body, err = ioutil.ReadAll(response.Body)
+		if err != nil {
+			result.Errors = append(result.Errors, err.Error())
+		}
 	}
 }
 
-func (service *Service) buildRequest() *http.Request {
+func (service *Service) buildHTTPRequest() *http.Request {
 	var bodyBuffer *bytes.Buffer
 	if service.GraphQL {
 		graphQlBody := map[string]string{
@@ -160,9 +237,12 @@ func (service *Service) buildRequest() *http.Request {
 	} else {
 		bodyBuffer = bytes.NewBuffer([]byte(service.Body))
 	}
-	request, _ := http.NewRequest(service.Method, service.Url, bodyBuffer)
+	request, _ := http.NewRequest(service.Method, service.URL, bodyBuffer)
 	for k, v := range service.Headers {
 		request.Header.Set(k, v)
+		if k == HostHeader {
+			request.Host = v
+		}
 	}
 	return request
 }

core/service_test.go

@@ -1,20 +1,229 @@
 package core
 
 import (
+	"io/ioutil"
+	"strings"
 	"testing"
+	"time"
 )
 
+func TestService_ValidateAndSetDefaults(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Alerts:     []*Alert{{Type: PagerDutyAlert}},
+	}
+	service.ValidateAndSetDefaults()
+	if service.Method != "GET" {
+		t.Error("Service method should've defaulted to GET")
+	}
+	if service.Interval != time.Minute {
+		t.Error("Service interval should've defaulted to 1 minute")
+	}
+	if service.Headers == nil {
+		t.Error("Service headers should've defaulted to an empty map")
+	}
+	if len(service.Alerts) != 1 {
+		t.Error("Service should've had 1 alert")
+	}
+	if service.Alerts[0].Enabled {
+		t.Error("Service alert should've defaulted to disabled")
+	}
+	if service.Alerts[0].SuccessThreshold != 2 {
+		t.Error("Service alert should've defaulted to a success threshold of 2")
+	}
+	if service.Alerts[0].FailureThreshold != 3 {
+		t.Error("Service alert should've defaulted to a failure threshold of 3")
+	}
+}
+
+func TestService_ValidateAndSetDefaultsWithNoName(t *testing.T) {
+	defer func() { recover() }()
+	condition := Condition("[STATUS] == 200")
+	service := &Service{
+		Name:       "",
+		URL:        "http://example.com",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have a name, which is a mandatory field")
+}
+
+func TestService_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
+	defer func() { recover() }()
+	condition := Condition("[STATUS] == 200")
+	service := &Service{
+		Name:       "example",
+		URL:        "",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have an url, which is a mandatory field")
+}
+
+func TestService_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
+	defer func() { recover() }()
+	service := &Service{
+		Name:       "example",
+		URL:        "http://example.com",
+		Conditions: nil,
+	}
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have at least 1 condition")
+}
+
+func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
+	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
+	service := &Service{
+		Name: "dns-test",
+		URL:  "http://example.com",
+		DNS: &DNS{
+			QueryType: "A",
+			QueryName: "example.com",
+		},
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	service.ValidateAndSetDefaults()
+	if service.DNS.QueryName != "example.com." {
+		t.Error("Service.dns.query-name should be formatted with . suffix")
+	}
+}
+
+func TestService_GetAlertsTriggered(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Alerts:     []*Alert{{Type: PagerDutyAlert, Enabled: true}},
+	}
+	service.ValidateAndSetDefaults()
+	if service.NumberOfFailuresInARow != 0 {
+		t.Error("Service.NumberOfFailuresInARow should start with 0")
+	}
+	if service.NumberOfSuccessesInARow != 0 {
+		t.Error("Service.NumberOfSuccessesInARow should start with 0")
+	}
+	if len(service.GetAlertsTriggered()) > 0 {
+		t.Error("No alerts should've been triggered, because service.NumberOfFailuresInARow is 0, which is below the failure threshold")
+	}
+	service.NumberOfFailuresInARow = service.Alerts[0].FailureThreshold
+	if len(service.GetAlertsTriggered()) != 1 {
+		t.Error("Alert should've been triggered")
+	}
+}
+
+func TestService_buildHTTPRequest(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
+	}
+	if request.Host != "twinnation.org" {
+		t.Error("request.Host should've been twinnation.org, but was", request.Host)
+	}
+	if userAgent := request.Header.Get("User-Agent"); userAgent != GatusUserAgent {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", GatusUserAgent, userAgent)
+	}
+}
+
+func TestService_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"User-Agent": "Test/2.0",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
+	}
+	if request.Host != "twinnation.org" {
+		t.Error("request.Host should've been twinnation.org, but was", request.Host)
+	}
+	if userAgent := request.Header.Get("User-Agent"); userAgent != "Test/2.0" {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", "Test/2.0", userAgent)
+	}
+}
+
+func TestService_buildHTTPRequestWithHostHeader(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/health",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"Host": "example.com",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if request.Host != "example.com" {
+		t.Error("request.Host should've been example.com, but was", request.Host)
+	}
+}
+
+func TestService_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "TwiNNatioN",
+		URL:        "https://twinnation.org/graphql",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		GraphQL:    true,
+		Body: `{
+  user(gender: "female") {
+    id
+    name
+    gender
+    avatar
+  }
+}`,
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if contentType := request.Header.Get(ContentTypeHeader); contentType != "application/json" {
+		t.Error("request.Header.Content-Type should've been application/json, but was", contentType)
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if !strings.HasPrefix(string(body), "{\"query\":") {
+		t.Error("request.Body should've started with '{\"query\":', but it didn't:", string(body))
+	}
+}
+
 func TestIntegrationEvaluateHealth(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
 		Name:       "TwiNNatioN",
-		Url:        "https://twinnation.org/health",
+		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
 	if !result.Success {
 		t.Error("Because all conditions passed, this should have been a success")
 	}
@@ -24,14 +233,74 @@ func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 	condition := Condition("[STATUS] == 500")
 	service := Service{
 		Name:       "TwiNNatioN",
-		Url:        "https://twinnation.org/health",
+		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
 	result := service.EvaluateHealth()
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
 	if result.Success {
 		t.Error("Because one of the conditions failed, success should have been false")
 	}
 }
+
+func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
+	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
+	conditionBody := Condition("[BODY] == 93.184.216.34")
+	service := Service{
+		Name: "TwiNNatioN",
+		URL:  "8.8.8.8",
+		DNS: &DNS{
+			QueryType: "A",
+			QueryName: "example.com.",
+		},
+		Conditions: []*Condition{&conditionSuccess, &conditionBody},
+	}
+	result := service.EvaluateHealth()
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Conditions '%s' and %s should have been a success", conditionSuccess, conditionBody)
+	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
+	if !result.Success {
+		t.Error("Because all conditions passed, this should have been a success")
+	}
+}
+
+func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
+	service := Service{
+		Name:       "ICMP test",
+		URL:        "icmp://127.0.0.1",
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	result := service.EvaluateHealth()
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Conditions '%s' should have been a success", conditionSuccess)
+	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
+	if !result.Success {
+		t.Error("Because all conditions passed, this should have been a success")
+	}
+}
+
+func TestService_getIP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
+	service := Service{
+		Name:       "Invalid URL test",
+		URL:        "",
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	result := &Result{}
+	service.getIP(result)
+	if len(result.Errors) == 0 {
+		t.Error("service.getIP(result) should've thrown an error because the URL is invalid, thus cannot be parsed")
+	}
+}

core/types.go

@@ -1,27 +0,0 @@
-package core
-
-import (
-	"time"
-)
-
-type HealthStatus struct {
-	Status  string `json:"status"`
-	Message string `json:"message,omitempty"`
-}
-
-type Result struct {
-	HttpStatus       int                `json:"status"`
-	Body             []byte             `json:"-"`
-	Hostname         string             `json:"hostname"`
-	Ip               string             `json:"-"`
-	Duration         time.Duration      `json:"duration"`
-	Errors           []string           `json:"errors"`
-	ConditionResults []*ConditionResult `json:"condition-results"`
-	Success          bool               `json:"success"`
-	Timestamp        time.Time          `json:"timestamp"`
-}
-
-type ConditionResult struct {
-	Condition string `json:"condition"`
-	Success   bool   `json:"success"`
-}

core/uptime.go

@@ -0,0 +1,114 @@
+package core
+
+import (
+	"log"
+	"time"
+)
+
+const (
+	// RFC3339WithoutMinutesAndSeconds is the format defined by RFC3339 (see time.RFC3339) but with the minutes
+	// and seconds hardcoded to 0.
+	RFC3339WithoutMinutesAndSeconds = "2006-01-02T15:00:00Z07:00"
+
+	numberOfHoursInTenDays = 10 * 24
+	sevenDays              = 7 * 24 * time.Hour
+)
+
+// Uptime is the struct that contains the relevant data for calculating the uptime as well as the uptime itself
+type Uptime struct {
+	// LastSevenDays is the uptime percentage over the past 7 days
+	LastSevenDays float64 `json:"7d"`
+
+	// LastTwentyFourHours is the uptime percentage over the past 24 hours
+	LastTwentyFourHours float64 `json:"24h"`
+
+	// LastHour is the uptime percentage over the past hour
+	LastHour float64 `json:"1h"`
+
+	successCountPerHour map[string]uint64
+	totalCountPerHour   map[string]uint64
+}
+
+// NewUptime creates a new Uptime
+func NewUptime() *Uptime {
+	return &Uptime{
+		successCountPerHour: make(map[string]uint64),
+		totalCountPerHour:   make(map[string]uint64),
+	}
+}
+
+// ProcessResult processes the result by extracting the relevant from the result and recalculating the uptime
+// if necessary
+func (uptime *Uptime) ProcessResult(result *Result) {
+	timestampDateWithHour := result.Timestamp.Format(RFC3339WithoutMinutesAndSeconds)
+	if result.Success {
+		uptime.successCountPerHour[timestampDateWithHour]++
+	}
+	uptime.totalCountPerHour[timestampDateWithHour]++
+	// Clean up only when we're starting to have too many useless keys
+	// Note that this is only triggered when there are more entries than there should be after
+	// 10 days, despite the fact that we are deleting everything that's older than 7 days.
+	// This is to prevent re-iterating on every `ProcessResult` as soon as the uptime has been logged for 7 days.
+	if len(uptime.totalCountPerHour) > numberOfHoursInTenDays {
+		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour))
+		for k := range uptime.totalCountPerHour {
+			dateWithHour, err := time.Parse(time.RFC3339, k)
+			if err != nil {
+				// This shouldn't happen, but we'll log it in case it does happen
+				log.Println("[uptime][ProcessResult] Failed to parse programmatically generated timestamp:", err.Error())
+				continue
+			}
+			if sevenDaysAgo.Unix() > dateWithHour.Unix() {
+				delete(uptime.totalCountPerHour, k)
+				delete(uptime.successCountPerHour, k)
+			}
+		}
+	}
+	if result.Success {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 100%
+		// If they're all 100%, then recalculating the uptime would be useless unless
+		// the result added was a failure (!result.Success)
+		if uptime.LastSevenDays != 1 || uptime.LastTwentyFourHours != 1 || uptime.LastHour != 1 {
+			uptime.recalculate()
+		}
+	} else {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 0%
+		// If they're all 0%, then recalculating the uptime would be useless unless
+		// the result added was a success (result.Success)
+		if uptime.LastSevenDays != 0 || uptime.LastTwentyFourHours != 0 || uptime.LastHour != 0 {
+			uptime.recalculate()
+		}
+	}
+}
+
+func (uptime *Uptime) recalculate() {
+	uptimeBrackets := make(map[string]uint64)
+	now := time.Now()
+	// The oldest uptime bracket starts 7 days ago, so we'll start from there
+	timestamp := now.Add(-sevenDays)
+	for now.Sub(timestamp) >= 0 {
+		timestampDateWithHour := timestamp.Format(RFC3339WithoutMinutesAndSeconds)
+		successCountForTimestamp := uptime.successCountPerHour[timestampDateWithHour]
+		totalCountForTimestamp := uptime.totalCountPerHour[timestampDateWithHour]
+		uptimeBrackets["7d_success"] += successCountForTimestamp
+		uptimeBrackets["7d_total"] += totalCountForTimestamp
+		if now.Sub(timestamp) <= 24*time.Hour {
+			uptimeBrackets["24h_success"] += successCountForTimestamp
+			uptimeBrackets["24h_total"] += totalCountForTimestamp
+		}
+		if now.Sub(timestamp) <= time.Hour {
+			uptimeBrackets["1h_success"] += successCountForTimestamp
+			uptimeBrackets["1h_total"] += totalCountForTimestamp
+		}
+		timestamp = timestamp.Add(time.Hour)
+	}
+	if uptimeBrackets["7d_total"] > 0 {
+		uptime.LastSevenDays = float64(uptimeBrackets["7d_success"]) / float64(uptimeBrackets["7d_total"])
+	}
+	if uptimeBrackets["24h_total"] > 0 {
+		uptime.LastTwentyFourHours = float64(uptimeBrackets["24h_success"]) / float64(uptimeBrackets["24h_total"])
+	}
+	if uptimeBrackets["1h_total"] > 0 {
+		uptime.LastHour = float64(uptimeBrackets["1h_success"]) / float64(uptimeBrackets["1h_total"])
+	}
+}

core/uptime_test.go

@@ -0,0 +1,79 @@
+package core
+
+import (
+	"testing"
+	"time"
+)
+
+func TestUptime_ProcessResult(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	uptime := serviceStatus.Uptime
+
+	checkUptimes(t, serviceStatus, 0.00, 0.00, 0.00)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-7 * 24 * time.Hour), Success: true})
+	checkUptimes(t, serviceStatus, 1.00, 0.00, 0.00)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-6 * 24 * time.Hour), Success: false})
+	checkUptimes(t, serviceStatus, 0.50, 0.00, 0.00)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-8 * 24 * time.Hour), Success: true})
+	checkUptimes(t, serviceStatus, 0.50, 0.00, 0.00)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-24 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-12 * time.Hour), Success: true})
+	checkUptimes(t, serviceStatus, 0.75, 1.00, 0.00)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-1 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-30 * time.Minute), Success: false})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-15 * time.Minute), Success: false})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-10 * time.Minute), Success: false})
+	checkUptimes(t, serviceStatus, 0.50, 0.50, 0.25)
+
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-120 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-119 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-118 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-117 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-10 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-8 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-30 * time.Minute), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-25 * time.Minute), Success: true})
+	checkUptimes(t, serviceStatus, 0.75, 0.70, 0.50)
+}
+
+func TestServiceStatus_AddResultUptimeIsCleaningUpAfterItself(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	now := time.Now()
+	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
+	// Start 12 days ago
+	timestamp := now.Add(-12 * 24 * time.Hour)
+	for timestamp.Unix() <= now.Unix() {
+		serviceStatus.AddResult(&Result{Timestamp: timestamp, Success: true})
+		if len(serviceStatus.Uptime.successCountPerHour) > numberOfHoursInTenDays {
+			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.successCountPerHour", numberOfHoursInTenDays)
+		}
+		//fmt.Printf("timestamp=%s; uptimeDuringLastHour=%f; timeAgo=%s\n", timestamp.Format(time.RFC3339), serviceStatus.UptimeDuringLastHour, time.Since(timestamp))
+		if now.Sub(timestamp) > time.Hour && serviceStatus.Uptime.LastHour != 0 {
+			t.Error("most recent timestamp > 1h ago, expected serviceStatus.Uptime.LastHour to be 0, got", serviceStatus.Uptime.LastHour)
+		}
+		if now.Sub(timestamp) < time.Hour && serviceStatus.Uptime.LastHour == 0 {
+			t.Error("most recent timestamp < 1h ago, expected serviceStatus.Uptime.LastHour to NOT be 0, got", serviceStatus.Uptime.LastHour)
+		}
+		// Simulate service with an interval of 1 minute
+		timestamp = timestamp.Add(3 * time.Minute)
+	}
+}
+
+func checkUptimes(t *testing.T, status *ServiceStatus, expectedUptimeDuringLastSevenDays, expectedUptimeDuringLastTwentyFourHours, expectedUptimeDuringLastHour float64) {
+	if status.Uptime.LastSevenDays != expectedUptimeDuringLastSevenDays {
+		t.Errorf("expected status.Uptime.LastSevenDays to be %f, got %f", expectedUptimeDuringLastHour, status.Uptime.LastSevenDays)
+	}
+	if status.Uptime.LastTwentyFourHours != expectedUptimeDuringLastTwentyFourHours {
+		t.Errorf("expected status.Uptime.LastTwentyFourHours to be %f, got %f", expectedUptimeDuringLastTwentyFourHours, status.Uptime.LastTwentyFourHours)
+	}
+	if status.Uptime.LastHour != expectedUptimeDuringLastHour {
+		t.Errorf("expected status.Uptime.LastHour to be %f, got %f", expectedUptimeDuringLastHour, status.Uptime.LastHour)
+	}
+}

core/util.go

@@ -1,76 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"github.com/TwinProduction/gatus/jsonpath"
-	"strconv"
-	"strings"
-)
-
-const (
-	StatusPlaceholder       = "[STATUS]"
-	IPPlaceHolder           = "[IP]"
-	ResponseTimePlaceHolder = "[RESPONSE_TIME]"
-	BodyPlaceHolder         = "[BODY]"
-
-	LengthFunctionPrefix  = "len("
-	PatternFunctionPrefix = "pat("
-	FunctionSuffix        = ")"
-
-	InvalidConditionElementSuffix = "(INVALID)"
-)
-
-// sanitizeAndResolve sanitizes and resolves a list of element and returns the list of resolved elements
-func sanitizeAndResolve(list []string, result *Result) []string {
-	var sanitizedList []string
-	body := strings.TrimSpace(string(result.Body))
-	for _, element := range list {
-		element = strings.TrimSpace(element)
-		switch strings.ToUpper(element) {
-		case StatusPlaceholder:
-			element = strconv.Itoa(result.HttpStatus)
-		case IPPlaceHolder:
-			element = result.Ip
-		case ResponseTimePlaceHolder:
-			element = strconv.Itoa(int(result.Duration.Milliseconds()))
-		case BodyPlaceHolder:
-			element = body
-		default:
-			// if contains the BodyPlaceHolder, then evaluate json path
-			if strings.Contains(element, BodyPlaceHolder) {
-				wantLength := false
-				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
-					wantLength = true
-					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
-				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.Replace(element, fmt.Sprintf("%s.", BodyPlaceHolder), "", 1), result.Body)
-				if err != nil {
-					result.Errors = append(result.Errors, err.Error())
-					element = fmt.Sprintf("%s %s", element, InvalidConditionElementSuffix)
-				} else {
-					if wantLength {
-						element = fmt.Sprintf("%d", resolvedElementLength)
-					} else {
-						element = resolvedElement
-					}
-				}
-			}
-		}
-		sanitizedList = append(sanitizedList, element)
-	}
-	return sanitizedList
-}
-
-func sanitizeAndResolveNumerical(list []string, result *Result) []int {
-	var sanitizedNumbers []int
-	sanitizedList := sanitizeAndResolve(list, result)
-	for _, element := range sanitizedList {
-		if number, err := strconv.Atoi(element); err != nil {
-			// Default to 0 if the string couldn't be converted to an integer
-			sanitizedNumbers = append(sanitizedNumbers, 0)
-		} else {
-			sanitizedNumbers = append(sanitizedNumbers, number)
-		}
-	}
-	return sanitizedNumbers
-}

example/docker-compose-mattermost/config.yaml

@@ -0,0 +1,16 @@
+alerting:
+  mattermost:
+    webhook-url: "http://mattermost:8065/hooks/tokengoeshere"
+    insecure: true
+
+services:
+  - name: example
+    url: http://example.org
+    interval: 1m
+    alerts:
+      - type: mattermost
+        enabled: true
+        description: "healthcheck failed 3 times in a row"
+        send-on-resolved: true
+    conditions:
+      - "[STATUS] == 200"

example/docker-compose-mattermost/docker-compose.yml

@@ -0,0 +1,24 @@
+version: "3.8"
+
+services:
+  gatus:
+    container_name: gatus
+    image: twinproduction/gatus:latest
+    ports:
+      - 8080:8080
+    volumes:
+      - ./config.yaml:/config/config.yaml
+    networks:
+      - default
+
+  mattermost:
+    container_name: mattermost
+    image: mattermost/mattermost-preview:5.26.0
+    ports:
+      - 8065:8065
+    networks:
+      - default
+
+networks:
+  default:
+    driver: bridge

example/kubernetes-with-auto-discovery/gatus.yaml

@@ -0,0 +1,109 @@
+apiVersion: v1
+data:
+  config.yaml: |
+    kubernetes:
+      cluster-mode: "in"
+      auto-discover: true
+      excluded-service-suffixes:
+        - canary
+      service-template:
+        interval: 30s
+        conditions:
+          - "[STATUS] == 200"
+      namespaces:
+        - name: default
+          hostname-suffix: ".default.svc.cluster.local"
+          target-path: "/health"
+          excluded-services:
+            - gatus
+kind: ConfigMap
+metadata:
+  name: gatus
+  namespace: kube-system
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: gatus
+rules:
+  - apiGroups:
+      - ""
+    resources:
+      - services
+    verbs:
+      - list
+      - get
+---
+apiVersion: v1
+automountServiceAccountToken: true
+kind: ServiceAccount
+metadata:
+  name: gatus
+  namespace: kube-system
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: gatus
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: gatus
+subjects:
+  - kind: ServiceAccount
+    name: gatus
+    namespace: kube-system
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gatus
+  namespace: kube-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      k8s-app: gatus
+  template:
+    metadata:
+      labels:
+        k8s-app: gatus
+      name: gatus
+      namespace: kube-system
+    spec:
+      containers:
+        - image: twinproduction/gatus
+          imagePullPolicy: IfNotPresent
+          name: gatus
+          ports:
+            - containerPort: 8080
+              name: http
+              protocol: TCP
+          resources:
+            limits:
+              cpu: 200m
+              memory: 50M
+            requests:
+              cpu: 50m
+              memory: 20M
+          volumeMounts:
+            - mountPath: /config
+              name: gatus-config
+      volumes:
+        - configMap:
+            name: gatus
+          name: gatus-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: gatus
+  namespace: kube-system
+spec:
+  ports:
+    - name: http
+      port: 8080
+      protocol: TCP
+      targetPort: 8080
+  selector:
+    k8s-app: gatus

example/kubernetes/gatus.yaml

@@ -13,6 +13,16 @@ data:
         interval: 5m
         conditions:
           - "[STATUS] == 200"
+      - name: cat-fact
+        url: "https://cat-fact.herokuapp.com/facts/random"
+        interval: 5m
+        conditions:
+          - "[STATUS] == 200"
+          - "[BODY].deleted == false"
+          - "len([BODY].text) > 0"
+          - "[BODY].text == pat(*cat*)"
+          - "[STATUS] == pat(2*)"
+          - "[CONNECTED] == true"
       - name: Example
         url: https://example.com/
         conditions:

go.mod

@@ -3,9 +3,23 @@ module github.com/TwinProduction/gatus
 go 1.15
 
 require (
-	github.com/prometheus/client_golang v1.7.1
-	github.com/prometheus/common v0.13.0 // indirect
-	golang.org/x/sys v0.0.0-20200916084744-dbad9cb7cb7a // indirect
-	google.golang.org/protobuf v1.25.0 // indirect
-	gopkg.in/yaml.v2 v2.3.0
+	cloud.google.com/go v0.74.0 // indirect
+	github.com/TwinProduction/gocache v1.1.0
+	github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663
+	github.com/google/gofuzz v1.2.0 // indirect
+	github.com/gorilla/mux v1.8.0
+	github.com/imdario/mergo v0.3.11 // indirect
+	github.com/miekg/dns v1.1.35
+	github.com/prometheus/client_golang v1.9.0
+	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
+	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
+	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
+	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
+	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
+	gopkg.in/yaml.v2 v2.4.0
+	k8s.io/api v0.18.14
+	k8s.io/apimachinery v0.18.14
+	k8s.io/client-go v0.18.14
 )
+
+replace k8s.io/client-go => k8s.io/client-go v0.18.14

go.sum

@@ -1,9 +1,57 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
 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 h1:kpgPA77kSSbjSs+fWHkPTxQ6J5Z2Qkruo5jfXEkHxNQ=
+cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI=
+github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0=
+github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
+github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
+github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk=
 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/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
+github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
+github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
+github.com/TwinProduction/gocache v1.1.0 h1:mibBUyccd8kGHlm5dXhTMDOvWBK4mjNqGyOOkG8mib8=
+github.com/TwinProduction/gocache v1.1.0/go.mod h1:+qH57V/K4oAcX9C7CvgJTwUX4lzfIUXQC/6XaRSOS1Y=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
@@ -25,13 +73,20 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 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/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
 github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
 github.com/cespare/xxhash/v2 v2.1.1/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/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
 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/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
 github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
@@ -40,41 +95,77 @@ github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfc
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
+github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
+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/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 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/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
 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-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
+github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
+github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg=
+github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc=
+github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I=
+github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663 h1:jI2GiiRh+pPbey52EVmbU6kuLiXqwy4CXZ4gwUBj8Y0=
+github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663/go.mod h1:35JbSyV/BYqHwwRA6Zr1uVDm1637YlNOU61wI797NPI=
+github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 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 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 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=
@@ -83,6 +174,8 @@ github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvq
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/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=
@@ -90,16 +183,49 @@ github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5a
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
 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.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.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/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/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/googleapis/gnostic v0.1.0 h1:rVsPeBmXbYv4If/cumu1AzZPwV58q433hvONV1UEZoI=
+github.com/googleapis/gnostic v0.1.0/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw=
 github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
@@ -125,6 +251,11 @@ github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2p
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
+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/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
+github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
@@ -133,11 +264,15 @@ github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+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/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 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/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 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=
@@ -150,6 +285,7 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
 github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
 github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
+github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
@@ -157,6 +293,8 @@ github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp
 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.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.35 h1:oTfOaDH+mZkdcgdIjH6yBajRGtIwcwcaR+rt23ZSrJs=
+github.com/miekg/dns v1.1.35/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
@@ -165,11 +303,15 @@ github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0Qu
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 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 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 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/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
 github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
 github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
 github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
@@ -177,12 +319,22 @@ github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzE
 github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
 github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
 github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
 github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.1/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
 github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
 github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
@@ -196,12 +348,14 @@ github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIw
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
+github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
 github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 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/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
+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/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
@@ -210,6 +364,8 @@ github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5Fsn
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
 github.com/prometheus/client_golang v1.7.1 h1:NTGy1Ja9pByO+xAeH/qiWnLrKtr3hJPNjaVUwnjpdpA=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.9.0 h1:Rrch9mh17XcxvEu9D9DEpb4isxjGBtcevQjKvxPRQIU=
+github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -223,14 +379,16 @@ github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y8
 github.com/prometheus/common v0.7.0 h1:L+1lyG48J1zAQXA3RBX/nG/B3gjlHq0zTt2tlbJLyCY=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
-github.com/prometheus/common v0.13.0 h1:vJlpe9wPgDRM1Z+7Wj3zUUjY1nr6/1jNKyl7llliccg=
-github.com/prometheus/common v0.13.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
+github.com/prometheus/common v0.15.0 h1:4fgOnadei3EZvgRwxJ7RMpG1k1pOZth5Pc13tyspaKM=
+github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3 h1:F0+tqvhOksq22sc6iCHF5WGlWjdwj92p0udFh1VFBS8=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4=
+github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
@@ -246,8 +404,13 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
@@ -255,16 +418,29 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 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 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/tidwall/redcon v1.3.2/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+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=
 go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+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.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
@@ -274,19 +450,51 @@ go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad h1:DN0cp81fZ3njFcrLCytUHRSUkqBjfTo4Tx9RJTWs0EY=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
 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/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 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-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -299,19 +507,60 @@ golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/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-20200520004742-59133d7f0dd7/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 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
 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-20200904194848-62affa334b73/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-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b h1:iFwSg7t5GZmB/Q5TjiEAsdoLDrdJRC1RiF2WhuV29Qw=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421 h1:Wo7BWFiOk0QRFMLYMqJGFMd9CgUAcGx7V+qEg/h5IBI=
 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 h1:Lm4OryKCca1vehdsWogr9N4t7NfZxLbJoc/H0w4K4S4=
+golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 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 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 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=
@@ -320,60 +569,216 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191022100944-742c48ecaeb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/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-20200519105757-fe76b779f299/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-20200916084744-dbad9cb7cb7a h1:chkwkn8HYWVtTE5DCQNKYlkyptadXYY0+PuyaVdyMo4=
-golang.org/x/sys v0.0.0-20200916084744-dbad9cb7cb7a/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 h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
+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-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201223074533-0d417f636930 h1:vRgIt+nup/B/BwIS0g2oC0haq0iqbV3ZA+u6+0TlNCo=
+golang.org/x/sys v0.0.0-20201223074533-0d417f636930/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf h1:MZ2shdL+ZM/XzY3ZGOnh4Nlpnxz5GSOhOmtHo3iPU6M=
+golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 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 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
+golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+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 h1:/5xXl8Y5W96D+TtHSlonuFqGHIWVuyCkGJLwGh9JJFs=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 h1:Hir2P/De0WpUhtrKGGjvSb2YxUgyZ7EFOSLIcSSpiwE=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/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-20190328211700-ab21143f2384/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-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/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-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+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-20200103221440-774c71fcf114 h1:DnSr2mCsxyCE6ZgIkmcWUQY2R5cH/6wL7eIxEmQOMSE=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/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/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+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/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
 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-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/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/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.23.1/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.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
 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=
@@ -383,6 +788,7 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
 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 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
@@ -395,6 +801,8 @@ gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qS
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
@@ -404,11 +812,41 @@ gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 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=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 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=
+k8s.io/api v0.18.14 h1:tKRYsRhfL7Hfs60rFm8sNdhWydDuk7vnBqnt8uy+i/Q=
+k8s.io/api v0.18.14/go.mod h1:rMEP0KbqUY9Bm/nbQBXtUizL9r7XvD7IV1XhnGSHsy4=
+k8s.io/apimachinery v0.18.14 h1:wH0doJJajeG0qIuQD1/yo5JrBDAsZ3olqlNXZBiauVw=
+k8s.io/apimachinery v0.18.14/go.mod h1:PF5taHbXgTEJLU+xMypMmYTXTWPJ5LaW8bfsisxnEXk=
+k8s.io/client-go v0.18.14 h1:9dWb5D0dBsuc2umLPuWVE07rPDmBNsggW3vvctDyJII=
+k8s.io/client-go v0.18.14/go.mod h1:fpZHBter1MB6bs+GISolsmIRsGlBEJyd0mllE0H9f2Y=
+k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
+k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
+k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
+k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E=
+k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89 h1:d4vVOjXm687F1iLSP2q3lyPPuyvTUt3aVoBpi2DqRsU=
+k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
+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=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0 h1:dOmIZBMfhcHS09XZkMyUgkq5trg3/jRyJYFZUiaOp8E=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
+sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
 sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=

k8s/client.go

@@ -0,0 +1,86 @@
+package k8s
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/TwinProduction/gatus/k8stest"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+// KubernetesClientApi is a minimal interface for interacting with Kubernetes
+// Created mostly to make mocking the Kubernetes client easier
+type KubernetesClientApi interface {
+	GetServices(namespace string) ([]v1.Service, error)
+}
+
+// KubernetesClient is a working implementation of KubernetesClientApi
+type KubernetesClient struct {
+	client *kubernetes.Clientset
+}
+
+// GetServices returns a list of services for a given namespace
+func (k *KubernetesClient) GetServices(namespace string) ([]v1.Service, error) {
+	services, err := k.client.CoreV1().Services(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		return nil, err
+	}
+	return services.Items, nil
+}
+
+// NewKubernetesClient creates a KubernetesClient
+func NewKubernetesClient(client *kubernetes.Clientset) *KubernetesClient {
+	return &KubernetesClient{
+		client: client,
+	}
+}
+
+// NewClient creates a Kubernetes client for the given ClusterMode
+func NewClient(clusterMode ClusterMode) (KubernetesClientApi, error) {
+	var kubeConfig *rest.Config
+	var err error
+	switch clusterMode {
+	case ClusterModeIn:
+		kubeConfig, err = rest.InClusterConfig()
+	case ClusterModeOut:
+		kubeConfig, err = getOutClusterConfig()
+	case ClusterModeMock:
+		return k8stest.GetMockedKubernetesClient(), nil
+	default:
+		return nil, fmt.Errorf("invalid cluster mode, try '%s' or '%s'", ClusterModeIn, ClusterModeOut)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("unable to get cluster config for mode '%s': %s", clusterMode, err.Error())
+	}
+	client, err := kubernetes.NewForConfig(kubeConfig)
+	if err != nil {
+		return nil, err
+	}
+	return NewKubernetesClient(client), nil
+}
+
+func homeDir() string {
+	if h := os.Getenv("HOME"); h != "" {
+		return h
+	}
+	return os.Getenv("USERPROFILE") // windows
+}
+
+func getOutClusterConfig() (*rest.Config, error) {
+	var kubeConfig *string
+	if home := homeDir(); home != "" {
+		kubeConfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
+	} else {
+		kubeConfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
+	}
+	flag.Parse()
+	return clientcmd.BuildConfigFromFlags("", *kubeConfig)
+}

k8s/config.go

@@ -0,0 +1,45 @@
+package k8s
+
+import "github.com/TwinProduction/gatus/core"
+
+// Config for Kubernetes auto-discovery
+type Config struct {
+	// AutoDiscover to discover services to monitor
+	AutoDiscover bool `yaml:"auto-discover"`
+
+	// ClusterMode is the mode to use to authenticate with Kubernetes
+	ClusterMode ClusterMode `yaml:"cluster-mode"`
+
+	// ServiceTemplate is the template for auto discovered services
+	ServiceTemplate *core.Service `yaml:"service-template"`
+
+	// ExcludedServiceSuffixes is a list of service suffixes that should be ignored
+	ExcludedServiceSuffixes []string `yaml:"excluded-service-suffixes"`
+
+	// Namespaces is a list of configurations for the namespaces from which services will be discovered
+	Namespaces []*NamespaceConfig `yaml:"namespaces"`
+}
+
+// NamespaceConfig level config
+type NamespaceConfig struct {
+	// Name of the namespace
+	Name string `yaml:"name"`
+
+	// ExcludedServices is a list of services to exclude from the auto discovery
+	ExcludedServices []string `yaml:"excluded-services"`
+
+	// HostnameSuffix is a suffix to append to each service name before calling TargetPath
+	HostnameSuffix string `yaml:"hostname-suffix"`
+
+	// TargetPath Path to append after the HostnameSuffix
+	TargetPath string `yaml:"target-path"`
+}
+
+// ClusterMode is the mode to use to authenticate to Kubernetes
+type ClusterMode string
+
+const (
+	ClusterModeIn   ClusterMode = "in"
+	ClusterModeOut  ClusterMode = "out"
+	ClusterModeMock ClusterMode = "mock"
+)

k8s/discovery.go

@@ -0,0 +1,54 @@
+package k8s
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+// DiscoverServices return discovered services
+func DiscoverServices(kubernetesConfig *Config) ([]*core.Service, error) {
+	client, err := NewClient(kubernetesConfig.ClusterMode)
+	if err != nil {
+		return nil, err
+	}
+	services := make([]*core.Service, 0)
+	for _, ns := range kubernetesConfig.Namespaces {
+		kubernetesServices, err := GetKubernetesServices(client, ns.Name)
+		if err != nil {
+			return nil, err
+		}
+	skipExcluded:
+		for _, service := range kubernetesServices {
+			for _, excludedServiceSuffix := range kubernetesConfig.ExcludedServiceSuffixes {
+				if strings.HasSuffix(service.Name, excludedServiceSuffix) {
+					continue skipExcluded
+				}
+			}
+			for _, excludedService := range ns.ExcludedServices {
+				if service.Name == excludedService {
+					continue skipExcluded
+				}
+			}
+			// XXX: try to extract health from liveness probe endpoint?
+			var url, port string
+			if len(service.Spec.Ports) > 0 && !strings.Contains(ns.HostnameSuffix, ":") && strings.HasSuffix(ns.HostnameSuffix, ".svc.cluster.local") {
+				port = fmt.Sprintf(":%d", service.Spec.Ports[0].Port)
+			}
+			// If the path starts with a / or starts with a port
+			if strings.HasPrefix(ns.TargetPath, "/") {
+				url = fmt.Sprintf("http://%s%s%s%s", service.Name, ns.HostnameSuffix, port, ns.TargetPath)
+			} else {
+				url = fmt.Sprintf("http://%s%s%s/%s", service.Name, ns.HostnameSuffix, port, ns.TargetPath)
+			}
+			services = append(services, &core.Service{
+				Name:       service.Name,
+				URL:        url,
+				Interval:   kubernetesConfig.ServiceTemplate.Interval,
+				Conditions: kubernetesConfig.ServiceTemplate.Conditions,
+			})
+		}
+	}
+	return services, nil
+}

k8s/k8s.go

@@ -0,0 +1,10 @@
+package k8s
+
+import (
+	"k8s.io/api/core/v1"
+)
+
+// GetKubernetesServices return a list of Services from the given namespace
+func GetKubernetesServices(client KubernetesClientApi, namespace string) ([]v1.Service, error) {
+	return client.GetServices(namespace)
+}

k8stest/k8stest.go

@@ -0,0 +1,55 @@
+package k8stest
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var (
+	mockedKubernetesClient *MockKubernetesClient
+)
+
+// MockKubernetesClient is a mocked implementation of k8s.KubernetesClientApi
+type MockKubernetesClient struct {
+	Services []v1.Service
+}
+
+// GetServices returns a list of services in a given namespace
+func (mock *MockKubernetesClient) GetServices(namespace string) ([]v1.Service, error) {
+	var services []v1.Service
+	for _, service := range mock.Services {
+		if service.Namespace == namespace {
+			services = append(services, service)
+		}
+	}
+	return services, nil
+}
+
+// GetMockedKubernetesClient returns a mocked implementation of k8s.KubernetesClientApi
+func GetMockedKubernetesClient() *MockKubernetesClient {
+	if mockedKubernetesClient != nil {
+		return mockedKubernetesClient
+	}
+	InitializeMockedKubernetesClient(nil)
+	return mockedKubernetesClient
+}
+
+// InitializeMockedKubernetesClient initializes a MockKubernetesClient with a given list of services
+func InitializeMockedKubernetesClient(services []v1.Service) {
+	mockedKubernetesClient = &MockKubernetesClient{
+		Services: services,
+	}
+}
+
+// CreateTestServices creates a mocked service for testing purposes
+func CreateTestServices(name, namespace string, port int32) v1.Service {
+	return v1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: v1.ServiceSpec{
+			Ports: []v1.ServicePort{{Name: "http", Protocol: v1.ProtocolTCP, Port: port}},
+		},
+	}
+}

main.go

@@ -1,37 +1,17 @@
 package main
 
 import (
-	"bytes"
-	"compress/gzip"
-	"github.com/TwinProduction/gatus/config"
-	"github.com/TwinProduction/gatus/watchdog"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"log"
-	"net/http"
 	"os"
-	"strings"
-	"time"
-)
 
-const CacheTTL = 10 * time.Second
-
-var (
-	cachedServiceResults          []byte
-	cachedServiceResultsGzipped   []byte
-	cachedServiceResultsTimestamp time.Time
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/controller"
+	"github.com/TwinProduction/gatus/watchdog"
 )
 
 func main() {
 	cfg := loadConfiguration()
-	http.HandleFunc("/api/v1/results", serviceResultsHandler)
-	http.HandleFunc("/health", healthHandler)
-	http.Handle("/", GzipHandler(http.FileServer(http.Dir("./static"))))
-	if cfg.Metrics {
-		http.Handle("/metrics", promhttp.Handler())
-	}
-	log.Println("[main][main] Listening on port 8080")
 	go watchdog.Monitor(cfg)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	controller.Handle()
 }
 
 func loadConfiguration() *config.Config {
@@ -47,38 +27,3 @@ func loadConfiguration() *config.Config {
 	}
 	return config.Get()
 }
-
-func serviceResultsHandler(writer http.ResponseWriter, r *http.Request) {
-	if isExpired := cachedServiceResultsTimestamp.IsZero() || time.Now().Sub(cachedServiceResultsTimestamp) > CacheTTL; isExpired {
-		buffer := &bytes.Buffer{}
-		gzipWriter := gzip.NewWriter(buffer)
-		data, err := watchdog.GetJsonEncodedServiceResults()
-		if err != nil {
-			log.Printf("[main][serviceResultsHandler] Unable to marshal object to JSON: %s", err.Error())
-			writer.WriteHeader(http.StatusInternalServerError)
-			_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
-			return
-		}
-		gzipWriter.Write(data)
-		gzipWriter.Close()
-		cachedServiceResults = data
-		cachedServiceResultsGzipped = buffer.Bytes()
-		cachedServiceResultsTimestamp = time.Now()
-	}
-	var data []byte
-	if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		writer.Header().Set("Content-Encoding", "gzip")
-		data = cachedServiceResultsGzipped
-	} else {
-		data = cachedServiceResults
-	}
-	writer.Header().Add("Content-type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(data)
-}
-
-func healthHandler(writer http.ResponseWriter, _ *http.Request) {
-	writer.Header().Add("Content-type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write([]byte("{\"status\":\"UP\"}"))
-}

metric/metric.go

@@ -2,12 +2,13 @@ package metric
 
 import (
 	"fmt"
+	"strconv"
+	"sync"
+
 	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"strconv"
-	"sync"
 )
 
 var (
@@ -15,19 +16,21 @@ var (
 	rwLock sync.RWMutex
 )
 
+// PublishMetricsForService publishes metrics for the given service and its result.
+// These metrics will be exposed at /metrics if the metrics are enabled
 func PublishMetricsForService(service *core.Service, result *core.Result) {
 	if config.Get().Metrics {
 		rwLock.Lock()
-		gauge, exists := gauges[fmt.Sprintf("%s_%s", service.Name, service.Url)]
+		gauge, exists := gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)]
 		if !exists {
 			gauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
 				Subsystem:   "gatus",
 				Name:        "tasks",
-				ConstLabels: prometheus.Labels{"service": service.Name, "url": service.Url},
+				ConstLabels: prometheus.Labels{"service": service.Name, "url": service.URL},
 			}, []string{"status", "success"})
-			gauges[fmt.Sprintf("%s_%s", service.Name, service.Url)] = gauge
+			gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)] = gauge
 		}
 		rwLock.Unlock()
-		gauge.WithLabelValues(strconv.Itoa(result.HttpStatus), strconv.FormatBool(result.Success)).Inc()
+		gauge.WithLabelValues(strconv.Itoa(result.HTTPStatus), strconv.FormatBool(result.Success)).Inc()
 	}
 }

pattern/pattern.go

@@ -1,12 +1,20 @@
 package pattern
 
-import "path/filepath"
+import (
+	"path/filepath"
+	"strings"
+)
 
 // Match checks whether a string matches a pattern
 func Match(pattern, s string) bool {
 	if pattern == "*" {
 		return true
 	}
+	// Separators found in the string break filepath.Match, so we'll remove all of them.
+	// This has a pretty significant impact on performance when there are separators in
+	// the strings, but at least it doesn't break filepath.Match.
+	s = strings.ReplaceAll(s, string(filepath.Separator), "")
+	pattern = strings.ReplaceAll(pattern, string(filepath.Separator), "")
 	matched, _ := filepath.Match(pattern, s)
 	return matched
 }

pattern/pattern_bench_test.go

@@ -0,0 +1,21 @@
+package pattern
+
+import "testing"
+
+func BenchmarkMatch(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		if !Match("*ing*", "livingroom") {
+			b.Error("should've matched")
+		}
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkMatchWithBackslash(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		if !Match("*ing*", "living\\room") {
+			b.Error("should've matched")
+		}
+	}
+	b.ReportAllocs()
+}

pattern/pattern_test.go

@@ -1,6 +1,9 @@
 package pattern
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
 func TestMatch(t *testing.T) {
 	testMatch(t, "*", "livingroom_123", true)
@@ -15,6 +18,7 @@ func TestMatch(t *testing.T) {
 	testMatch(t, "*vin*om*2*", "livingroom_123", true)
 	testMatch(t, "livingroom_123", "livingroom_123", true)
 	testMatch(t, "*livingroom_123*", "livingroom_123", true)
+	testMatch(t, "*test*", "\\test", true)
 	testMatch(t, "livingroom", "livingroom_123", false)
 	testMatch(t, "livingroom123", "livingroom_123", false)
 	testMatch(t, "what", "livingroom_123", false)
@@ -24,14 +28,16 @@ func TestMatch(t *testing.T) {
 }
 
 func testMatch(t *testing.T, pattern, key string, expectedToMatch bool) {
-	matched := Match(pattern, key)
-	if expectedToMatch {
-		if !matched {
-			t.Errorf("%s should've matched pattern '%s'", key, pattern)
+	t.Run(fmt.Sprintf("pattern '%s' from '%s'", pattern, key), func(t *testing.T) {
+		matched := Match(pattern, key)
+		if expectedToMatch {
+			if !matched {
+				t.Errorf("%s should've matched pattern '%s'", key, pattern)
+			}
+		} else {
+			if matched {
+				t.Errorf("%s shouldn't have matched pattern '%s'", key, pattern)
+			}
 		}
-	} else {
-		if matched {
-			t.Errorf("%s shouldn't have matched pattern '%s'", key, pattern)
-		}
-	}
+	})
 }

security/handler.go

@@ -0,0 +1,20 @@
+package security
+
+import (
+	"net/http"
+	"strings"
+)
+
+// Handler takes care of security for a given handler with the given security configuratioon
+func Handler(handler http.HandlerFunc, security *Config) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		usernameEntered, passwordEntered, ok := r.BasicAuth()
+		if !ok || usernameEntered != security.Basic.Username || Sha512(passwordEntered) != strings.ToLower(security.Basic.PasswordSha512Hash) {
+			w.Header().Set("WWW-Authenticate", "Basic")
+			w.WriteHeader(http.StatusUnauthorized)
+			_, _ = w.Write([]byte("Unauthorized"))
+			return
+		}
+		handler(w, r)
+	}
+}

security/handler_test.go

@@ -0,0 +1,58 @@
+package security
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func mockHandler(writer http.ResponseWriter, _ *http.Request) {
+	writer.WriteHeader(200)
+}
+
+func TestHandlerWhenNotAuthenticated(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusUnauthorized {
+		t.Error("Expected code to be 401, but was", responseRecorder.Code)
+	}
+}
+
+func TestHandlerWhenAuthenticated(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	request.SetBasicAuth("john.doe", "hunter2")
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("Expected code to be 200, but was", responseRecorder.Code)
+	}
+}
+
+func TestHandlerWhenAuthenticatedWithBadCredentials(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	request.SetBasicAuth("john.doe", "bad-password")
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusUnauthorized {
+		t.Error("Expected code to be 401, but was", responseRecorder.Code)
+	}
+}

security/security.go

@@ -0,0 +1,25 @@
+package security
+
+// Config is the security configuration for Gatus
+type Config struct {
+	Basic *BasicConfig `yaml:"basic"`
+}
+
+// IsValid returns whether the security configuration is valid or not
+func (c *Config) IsValid() bool {
+	return c.Basic != nil && c.Basic.IsValid()
+}
+
+// BasicConfig is the configuration for Basic authentication
+type BasicConfig struct {
+	// Username is the name which will need to be used for a successful authentication
+	Username string `yaml:"username"`
+
+	// PasswordSha512Hash is the SHA512 hash of the password which will need to be used for a successful authentication
+	PasswordSha512Hash string `yaml:"password-sha512"`
+}
+
+// IsValid returns whether the basic security configuration is valid or not
+func (c *BasicConfig) IsValid() bool {
+	return len(c.Username) > 0 && len(c.PasswordSha512Hash) == 128
+}

security/security_test.go

@@ -0,0 +1,23 @@
+package security
+
+import "testing"
+
+func TestBasicConfig_IsValid(t *testing.T) {
+	basicConfig := &BasicConfig{
+		Username:           "admin",
+		PasswordSha512Hash: Sha512("test"),
+	}
+	if !basicConfig.IsValid() {
+		t.Error("basicConfig should've been valid")
+	}
+}
+
+func TestBasicConfig_IsValidWhenPasswordIsInvalid(t *testing.T) {
+	basicConfig := &BasicConfig{
+		Username:           "admin",
+		PasswordSha512Hash: "",
+	}
+	if basicConfig.IsValid() {
+		t.Error("basicConfig shouldn't have been valid")
+	}
+}

security/sha512.go

@@ -0,0 +1,13 @@
+package security
+
+import (
+	"crypto/sha512"
+	"fmt"
+)
+
+// Sha512 hashes a provided string using SHA512 and returns the resulting hash as a string
+func Sha512(s string) string {
+	hash := sha512.New()
+	hash.Write([]byte(s))
+	return fmt.Sprintf("%x", hash.Sum(nil))
+}

security/sha512_test.go

@@ -0,0 +1,12 @@
+package security
+
+import "testing"
+
+func TestSha512(t *testing.T) {
+	input := "password"
+	expectedHash := "b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86"
+	hash := Sha512(input)
+	if hash != expectedHash {
+		t.Errorf("Expected hash to be '%s', but was '%s'", expectedHash, hash)
+	}
+}

static/index.html

@@ -1,300 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-	<title>Health Dashboard</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1" />
-	<link rel="stylesheet" href="/bootstrap.min.css" />
-	<style>
-		html, body {
-			background-color: #f7f9fb;
-		}
-		html {
-			height: 100%;
-		}
-		#results div.container:first-child {
-			border-top-left-radius: 3px;
-			border-top-right-radius: 3px;
-		}
-		#results div.container:last-child {
-			border-bottom-left-radius: 3px;
-			border-bottom-right-radius: 3px;
-			border-bottom-width: 1px;
-			border-color: #dee2e6;
-			border-style: solid;
-		}
-		.status {
-			cursor: pointer;
-			transition: all 500ms ease-in-out;
-			overflow-x: hidden;
-			padding: .25em 0;
-			color: white;
-		}
-		.title {
-			font-size: 2.5rem;
-		}
-		.status:hover {
-			opacity: 0.7;
-			transition: opacity 100ms ease-in-out;
-			color: black;
-		}
-		.status-over-time {
-			overflow: auto;
-		}
-		.status-over-time>span:not(:last-child) {
-			margin-left: 2px;
-		}
-		.status-time-ago {
-			color: #6a737d;
-			opacity: 0.5;
-			margin-top: 5px;
-		}
-		.status-min-max-ms {
-			overflow-x: hidden;
-		}
-		#tooltip {
-			position: fixed;
-			top: 0;
-			left: 0;
-			background-color: white;
-			border: 1px solid lightgray;
-			border-radius: 4px;
-			padding: 6px;
-			font-size: 13px;
-		}
-		#tooltip code {
-			color: #212529;
-			line-height: 1;
-		}
-		#tooltip .tooltip-title {
-			font-weight: bold;
-			margin-bottom: 0;
-			display: block;
-		}
-		#tooltip .tooltip-title {
-			margin-top: 8px;
-		}
-		#tooltip>.tooltip-title:first-child {
-			margin-top: 0;
-		}
-		#social {
-			position: fixed;
-			right: 5px;
-			bottom: 5px;
-			padding: 5px;
-			margin: 0;
-			z-index: 100;
-		}
-		#social img {
-			opacity: 0.3;
-		}
-		#social img:hover {
-			opacity: 1;
-		}
-	</style>
-</head>
-<body>
-	<div class="container my-3 rounded p-3 border shadow">
-		<div class="mb-2">
-			<div class="row">
-				<div class="col-8 text-left my-auto">
-					<div class="title display-4">Health Status</div>
-				</div>
-				<div class="col-4 text-right">
-					<img src="logo.png" alt="Gatus" style="position: relative; min-width: 50px; max-width: 200px; width: 20%;"/>
-				</div>
-			</div>
-		</div>
-		<div id="results"></div>
-	</div>
-
-	<div id="tooltip" style="display: none">
-		<div class="tooltip-title">Timestamp:</div>
-		<code id="tooltip-timestamp">...</code>
-		<div class="tooltip-title">Response time:</div>
-		<code id="tooltip-response-time">...</code>
-		<div class="tooltip-title">Conditions:</div>
-		<code id="tooltip-conditions">...</code>
-		<div id="tooltip-errors-container">
-			<div class="tooltip-title">Errors:</div>
-			<code id="tooltip-errors">...</code>
-		</div>
-	</div>
-
-	<script src="/jquery.min.js"></script>
-
-	<div id="social">
-		<a href="https://github.com/TwinProduction/gatus" target="_blank" title="Gatus on GitHub">
-			<img src="/github.png" alt="GitHub" width="32" height="auto" />
-		</a>
-	</div>
-
-	<script>
-		let serviceStatuses = {};
-		let timerHandler = 0;
-		let userClickedStatus = false;
-
-		function showTooltip(serviceName, index, element) {
-			userClickedStatus = false;
-			clearTimeout(timerHandler);
-			let serviceResult = serviceStatuses[serviceName][index];
-			$("#tooltip-timestamp").text(prettifyTimestamp(serviceResult.timestamp));
-			$("#tooltip-response-time").text(parseInt(serviceResult.duration/1000000) + "ms");
-			// Populate the condition section
-			let conditions = "";
-			for (let i in serviceResult['condition-results']) {
-				let conditionResult = serviceResult['condition-results'][i];
-				conditions += (conditionResult.success ? "&#10003;" : "X") + " ~ " + htmlEntities(conditionResult.condition) + "<br />";
-			}
-			$("#tooltip-conditions").html(conditions);
-			// Populate the error section only if there are errors
-			if (serviceResult.errors && serviceResult.errors.length > 0) {
-				let errors = "";
-				for (let i in serviceResult.errors) {
-					errors += "- " + htmlEntities(serviceResult.errors[i]) + "<br />";
-				}
-				$("#tooltip-errors").html(errors);
-				$("#tooltip-errors-container").show();
-			} else {
-				$("#tooltip-errors-container").hide();
-			}
-			// Position tooltip
-			$("#tooltip").css({top: "0px", left: "0px"}).show();
-			let targetTopPosition = element.getBoundingClientRect().y + 30;
-			let targetLeftPosition = element.getBoundingClientRect().x;
-			// Make adjustments if necessary
-			let tooltipBoundingClientRect = document.querySelector('#tooltip').getBoundingClientRect();
-			if (targetLeftPosition + window.scrollX + tooltipBoundingClientRect.width + 50 > document.body.getBoundingClientRect().width) {
-				targetLeftPosition = element.getBoundingClientRect().x - tooltipBoundingClientRect.width + element.getBoundingClientRect().width;
-				if (targetLeftPosition < 0) {
-					targetLeftPosition += -targetLeftPosition;
-				}
-			}
-			if (targetTopPosition + window.scrollY + tooltipBoundingClientRect.height + 50 > document.body.getBoundingClientRect().height && targetTopPosition >= 0) {
-				targetTopPosition = element.getBoundingClientRect().y - (tooltipBoundingClientRect.height + 10);
-				if (targetTopPosition < 0) {
-					targetTopPosition = element.getBoundingClientRect().y + 30;
-				}
-			}
-			$("#tooltip").css({top: targetTopPosition + "px", left: targetLeftPosition + "px"});
-		}
-
-		function fadeTooltip() {
-			if (!userClickedStatus) {
-				timerHandler = setTimeout(function () {
-					$("#tooltip").hide();
-				}, 500);
-			}
-		}
-
-		function createStatusBadge(serviceName, index, success) {
-			if (success) {
-				return "<span class='status badge badge-success' style='width: 5%' onmouseenter='showTooltip(\""+serviceName+"\", "+index+", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>&#10003;</span>";
-			}
-			return "<span class='status badge badge-danger' style='width: 5%' onmouseenter='showTooltip(\""+serviceName+"\", "+index+", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>X</span>";
-		}
-
-		function refreshResults() {
-			$.getJSON("/api/v1/results", function (data) {
-				// Update the table only if there's a change
-				if (JSON.stringify(serviceStatuses) !== JSON.stringify(data)) {
-					serviceStatuses = data;
-					buildTable();
-				}
-			});
-		}
-
-		function buildTable() {
-			let output = "";
-			for (let serviceName in serviceStatuses) {
-				let serviceStatusOverTime = "";
-				let hostname = serviceStatuses[serviceName][serviceStatuses[serviceName].length-1].hostname
-				let minResponseTime = null;
-				let maxResponseTime = null;
-				let newestTimestamp = null;
-				let oldestTimestamp = null;
-				for (let key in serviceStatuses[serviceName]) {
-					let serviceResult = serviceStatuses[serviceName][key];
-					serviceStatusOverTime = createStatusBadge(serviceName, key, serviceResult.success) + serviceStatusOverTime;
-					const responseTime = parseInt(serviceResult.duration/1000000);
-					if (minResponseTime == null || minResponseTime > responseTime) {
-						minResponseTime = responseTime;
-					}
-					if (maxResponseTime == null || maxResponseTime < responseTime) {
-						maxResponseTime = responseTime;
-					}
-					const timestamp = new Date(serviceResult.timestamp);
-					if (newestTimestamp == null || newestTimestamp < timestamp) {
-						newestTimestamp = timestamp;
-					}
-					if (oldestTimestamp == null || oldestTimestamp > timestamp) {
-						oldestTimestamp = timestamp;
-					}
-				}
-				output += ""
-					+ "<div class='container py-3 border-left border-right border-top border-black'>"
-					+ "  <div class='row mb-2'>"
-					+ "    <div class='col-md-10'>"
-					+ "      <span class='font-weight-bold'>" + serviceName + "</span> <span class='text-secondary font-weight-lighter'>- " + hostname + "</span>"
-					+ "    </div>"
-					+ "    <div class='col-md-2 text-right'>"
-					+ "      <span class='font-weight-lighter status-min-max-ms'>" + (minResponseTime === maxResponseTime ? minResponseTime : (minResponseTime + "-" + maxResponseTime)) + "ms</span>"
-					+ "    </div>"
-					+ "  </div>"
-					+ "  <div class='row'>"
-					+ "    <div class='col-12 d-flex flex-row-reverse status-over-time'>"
-					+ "      " + serviceStatusOverTime
-					+ "    </div>"
-					+ "  </div>"
-					+ "  <div class='row status-time-ago'>"
-					+ "    <div class='col-6'>"
-					+ "      " + generatePrettyTimeAgo(oldestTimestamp)
-					+ "    </div>"
-					+ "    <div class='col-6 text-right'>"
-					+ "      " + generatePrettyTimeAgo(newestTimestamp)
-					+ "    </div>"
-					+ "  </div>"
-					+ "</div>";
-			}
-			$("#results").html(output);
-		}
-
-		function prettifyTimestamp(timestamp) {
-			let date = new Date(timestamp);
-			let YYYY = date.getFullYear();
-			let MM = ((date.getMonth()+1)<10?"0":"")+""+(date.getMonth()+1);
-			let DD = ((date.getDate())<10?"0":"")+""+(date.getDate());
-			let hh = ((date.getHours())<10?"0":"")+""+(date.getHours());
-			let mm = ((date.getMinutes())<10?"0":"")+""+(date.getMinutes());
-			let ss = ((date.getSeconds())<10?"0":"")+""+(date.getSeconds());
-			return YYYY + "-" + MM + "-" + DD + " " + hh + ":" + mm + ":" + ss;
-		}
-
-		function generatePrettyTimeAgo(t) {
-			let differenceInMs = new Date().getTime() - new Date(t).getTime();
-			if (differenceInMs > 3600000) {
-				let hours = (differenceInMs/3600000).toFixed(0);
-				return hours + " hour" + (hours !== "1" ? "s" : "") + " ago";
-			}
-			if (differenceInMs > 60000) {
-				let minutes = (differenceInMs/60000).toFixed(0);
-				return minutes + " minute" + (minutes !== "1" ? "s" : "") + " ago";
-			}
-			return (differenceInMs/1000).toFixed(0) + " seconds ago";
-		}
-
-		function htmlEntities(s) {
-			return String(s)
-				.replace(/&/g, '&amp;')
-				.replace(/</g, '&lt;')
-				.replace(/>/g, '&gt;')
-				.replace(/"/g, '&quot;')
-				.replace(/'/g, '&apos;');
-		}
-
-		refreshResults();
-		setInterval(function() {
-			refreshResults();
-		}, 30000);
-	</script>
-</body>
-</html>

storage/memory.go

@@ -0,0 +1,69 @@
+package storage
+
+import (
+	"encoding/json"
+	"sync"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/util"
+)
+
+// InMemoryStore implements an in-memory store
+type InMemoryStore struct {
+	serviceStatuses     map[string]*core.ServiceStatus
+	serviceResultsMutex sync.RWMutex
+}
+
+// NewInMemoryStore returns an in-memory store. Note that the store acts as a singleton, so although new-ing
+// up in-memory stores will give you a unique reference to a struct each time, all structs returned
+// by this function will act on the same in-memory store.
+func NewInMemoryStore() *InMemoryStore {
+	return &InMemoryStore{
+		serviceStatuses: make(map[string]*core.ServiceStatus),
+	}
+}
+
+// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
+func (ims *InMemoryStore) GetAllAsJSON() ([]byte, error) {
+	ims.serviceResultsMutex.RLock()
+	serviceStatuses, err := json.Marshal(ims.serviceStatuses)
+	ims.serviceResultsMutex.RUnlock()
+	return serviceStatuses, err
+}
+
+// GetServiceStatus returns the service status for a given service name in the given group
+func (ims *InMemoryStore) GetServiceStatus(groupName, serviceName string) *core.ServiceStatus {
+	key := util.ConvertGroupAndServiceToKey(groupName, serviceName)
+	ims.serviceResultsMutex.RLock()
+	serviceStatus := ims.serviceStatuses[key]
+	ims.serviceResultsMutex.RUnlock()
+	return serviceStatus
+}
+
+// GetServiceStatusByKey returns the service status for a given key
+func (ims *InMemoryStore) GetServiceStatusByKey(key string) *core.ServiceStatus {
+	ims.serviceResultsMutex.RLock()
+	serviceStatus := ims.serviceStatuses[key]
+	ims.serviceResultsMutex.RUnlock()
+	return serviceStatus
+}
+
+// Insert inserts the observed result for the specified service into the in memory store
+func (ims *InMemoryStore) Insert(service *core.Service, result *core.Result) {
+	key := util.ConvertGroupAndServiceToKey(service.Group, service.Name)
+	ims.serviceResultsMutex.Lock()
+	serviceStatus, exists := ims.serviceStatuses[key]
+	if !exists {
+		serviceStatus = core.NewServiceStatus(service)
+		ims.serviceStatuses[key] = serviceStatus
+	}
+	serviceStatus.AddResult(result)
+	ims.serviceResultsMutex.Unlock()
+}
+
+// Clear will empty all the results from the in memory store
+func (ims *InMemoryStore) Clear() {
+	ims.serviceResultsMutex.Lock()
+	ims.serviceStatuses = make(map[string]*core.ServiceStatus)
+	ims.serviceResultsMutex.Unlock()
+}

storage/memory_test.go

@@ -0,0 +1,224 @@
+package storage
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/util"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		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,
+			},
+		},
+	}
+	testUnsuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		Success:               false,
+		Timestamp:             timestamp,
+		Duration:              750 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func TestInMemoryStore_Insert(t *testing.T) {
+	store := NewInMemoryStore()
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	if len(store.serviceStatuses) != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", len(store.serviceStatuses))
+	}
+	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
+	serviceStatus, exists := store.serviceStatuses[key]
+	if !exists {
+		t.Fatalf("Store should've had key '%s', but didn't", key)
+	}
+	if len(serviceStatus.Results) != 2 {
+		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceStatus.Name, len(serviceStatus.Results))
+	}
+	for i, r := range serviceStatus.Results {
+		expectedResult := store.GetServiceStatus(testService.Group, testService.Name).Results[i]
+		if r.HTTPStatus != expectedResult.HTTPStatus {
+			t.Errorf("Result at index %d should've had a HTTPStatus of %d, but was actually %d", i, expectedResult.HTTPStatus, r.HTTPStatus)
+		}
+		if r.DNSRCode != expectedResult.DNSRCode {
+			t.Errorf("Result at index %d should've had a DNSRCode of %s, but was actually %s", i, expectedResult.DNSRCode, r.DNSRCode)
+		}
+		if len(r.Body) != len(expectedResult.Body) {
+			t.Errorf("Result at index %d should've had a body of length %d, but was actually %d", i, len(expectedResult.Body), len(r.Body))
+		}
+		if r.Hostname != expectedResult.Hostname {
+			t.Errorf("Result at index %d should've had a Hostname of %s, but was actually %s", i, expectedResult.Hostname, r.Hostname)
+		}
+		if r.IP != expectedResult.IP {
+			t.Errorf("Result at index %d should've had a IP of %s, but was actually %s", i, expectedResult.IP, r.IP)
+		}
+		if r.Connected != expectedResult.Connected {
+			t.Errorf("Result at index %d should've had a Connected value of %t, but was actually %t", i, expectedResult.Connected, r.Connected)
+		}
+		if r.Duration != expectedResult.Duration {
+			t.Errorf("Result at index %d should've had a Duration of %s, but was actually %s", i, expectedResult.Duration.String(), r.Duration.String())
+		}
+		if len(r.Errors) != len(expectedResult.Errors) {
+			t.Errorf("Result at index %d should've had %d errors, but actually had %d errors", i, len(expectedResult.Errors), len(r.Errors))
+		}
+		if len(r.ConditionResults) != len(expectedResult.ConditionResults) {
+			t.Errorf("Result at index %d should've had %d ConditionResults, but actually had %d ConditionResults", i, len(expectedResult.ConditionResults), len(r.ConditionResults))
+		}
+		if r.Success != expectedResult.Success {
+			t.Errorf("Result at index %d should've had a Success of %t, but was actually %t", i, expectedResult.Success, r.Success)
+		}
+		if r.Timestamp != expectedResult.Timestamp {
+			t.Errorf("Result at index %d should've had a Timestamp of %s, but was actually %s", i, expectedResult.Timestamp.String(), r.Timestamp.String())
+		}
+		if r.CertificateExpiration != expectedResult.CertificateExpiration {
+			t.Errorf("Result at index %d should've had a CertificateExpiration of %s, but was actually %s", i, expectedResult.CertificateExpiration.String(), r.CertificateExpiration.String())
+		}
+	}
+}
+
+func TestInMemoryStore_GetServiceStatus(t *testing.T) {
+	store := NewInMemoryStore()
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	serviceStatus := store.GetServiceStatus(testService.Group, testService.Name)
+	if serviceStatus == nil {
+		t.Fatalf("serviceStatus shouldn't have been nil")
+	}
+	if serviceStatus.Uptime == nil {
+		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
+	}
+	if serviceStatus.Uptime.LastHour != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastSevenDays != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
+	}
+}
+
+func TestInMemoryStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
+	store := NewInMemoryStore()
+	store.Insert(&testService, &testSuccessfulResult)
+
+	serviceStatus := store.GetServiceStatus("nonexistantgroup", "nonexistantname")
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, testService.Name)
+	}
+	serviceStatus = store.GetServiceStatus(testService.Group, "nonexistantname")
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, "nonexistantname")
+	}
+	serviceStatus = store.GetServiceStatus("nonexistantgroup", testService.Name)
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", "nonexistantgroup", testService.Name)
+	}
+}
+
+func TestInMemoryStore_GetServiceStatusByKey(t *testing.T) {
+	store := NewInMemoryStore()
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	serviceStatus := store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(testService.Group, testService.Name))
+	if serviceStatus == nil {
+		t.Fatalf("serviceStatus shouldn't have been nil")
+	}
+	if serviceStatus.Uptime == nil {
+		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
+	}
+	if serviceStatus.Uptime.LastHour != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastSevenDays != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
+	}
+}
+
+func TestInMemoryStore_GetAllAsJSON(t *testing.T) {
+	store := NewInMemoryStore()
+	firstResult := &testSuccessfulResult
+	secondResult := &testUnsuccessfulResult
+	store.Insert(&testService, firstResult)
+	store.Insert(&testService, secondResult)
+	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
+	firstResult.Timestamp = time.Time{}
+	secondResult.Timestamp = time.Time{}
+	output, err := store.GetAllAsJSON()
+	if err != nil {
+		t.Fatal("shouldn't have returned an error, got", err.Error())
+	}
+	expectedOutput := `{"group_name":{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"uptime":{"7d":0.5,"24h":0.5,"1h":0.5}}}`
+	if string(output) != expectedOutput {
+		t.Errorf("expected:\n %s\n\ngot:\n %s", expectedOutput, string(output))
+	}
+}

util/key.go

@@ -0,0 +1,18 @@
+package util
+
+import "strings"
+
+// ConvertGroupAndServiceToKey converts a group and a service to a key
+func ConvertGroupAndServiceToKey(group, service string) string {
+	return sanitize(group) + "_" + sanitize(service)
+}
+
+func sanitize(s string) string {
+	s = strings.TrimSpace(strings.ToLower(s))
+	s = strings.ReplaceAll(s, "/", "-")
+	s = strings.ReplaceAll(s, "_", "-")
+	s = strings.ReplaceAll(s, ".", "-")
+	s = strings.ReplaceAll(s, ",", "-")
+	s = strings.ReplaceAll(s, " ", "-")
+	return s
+}

util/key_test.go

@@ -0,0 +1,36 @@
+package util
+
+import "testing"
+
+func TestConvertGroupAndServiceToKey(t *testing.T) {
+	type Scenario struct {
+		GroupName      string
+		ServiceName    string
+		ExpectedOutput string
+	}
+	scenarios := []Scenario{
+		{
+			GroupName:      "Core",
+			ServiceName:    "Front End",
+			ExpectedOutput: "core_front-end",
+		},
+		{
+			GroupName:      "Load balancers",
+			ServiceName:    "us-west-2",
+			ExpectedOutput: "load-balancers_us-west-2",
+		},
+		{
+			GroupName:      "a/b test",
+			ServiceName:    "a",
+			ExpectedOutput: "a-b-test_a",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.ExpectedOutput, func(t *testing.T) {
+			output := ConvertGroupAndServiceToKey(scenario.GroupName, scenario.ServiceName)
+			if output != scenario.ExpectedOutput {
+				t.Errorf("Expected '%s', got '%s'", scenario.ExpectedOutput, output)
+			}
+		})
+	}
+}

vendor/cloud.google.com/go/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/cloud.google.com/go/compute/metadata/metadata.go

@@ -0,0 +1,519 @@
+// Copyright 2014 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package metadata provides access to Google Compute Engine (GCE)
+// metadata and API service accounts.
+//
+// This package is a wrapper around the GCE metadata service,
+// as documented at https://developers.google.com/compute/docs/metadata.
+package metadata // import "cloud.google.com/go/compute/metadata"
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	// metadataIP is the documented metadata server IP address.
+	metadataIP = "169.254.169.254"
+
+	// metadataHostEnv is the environment variable specifying the
+	// GCE metadata hostname.  If empty, the default value of
+	// metadataIP ("169.254.169.254") is used instead.
+	// This is variable name is not defined by any spec, as far as
+	// I know; it was made up for the Go package.
+	metadataHostEnv = "GCE_METADATA_HOST"
+
+	userAgent = "gcloud-golang/0.1"
+)
+
+type cachedValue struct {
+	k    string
+	trim bool
+	mu   sync.Mutex
+	v    string
+}
+
+var (
+	projID  = &cachedValue{k: "project/project-id", trim: true}
+	projNum = &cachedValue{k: "project/numeric-project-id", trim: true}
+	instID  = &cachedValue{k: "instance/id", trim: true}
+)
+
+var defaultClient = &Client{hc: &http.Client{
+	Transport: &http.Transport{
+		Dial: (&net.Dialer{
+			Timeout:   2 * time.Second,
+			KeepAlive: 30 * time.Second,
+		}).Dial,
+	},
+}}
+
+// NotDefinedError is returned when requested metadata is not defined.
+//
+// The underlying string is the suffix after "/computeMetadata/v1/".
+//
+// This error is not returned if the value is defined to be the empty
+// string.
+type NotDefinedError string
+
+func (suffix NotDefinedError) Error() string {
+	return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))
+}
+
+func (c *cachedValue) get(cl *Client) (v string, err error) {
+	defer c.mu.Unlock()
+	c.mu.Lock()
+	if c.v != "" {
+		return c.v, nil
+	}
+	if c.trim {
+		v, err = cl.getTrimmed(c.k)
+	} else {
+		v, err = cl.Get(c.k)
+	}
+	if err == nil {
+		c.v = v
+	}
+	return
+}
+
+var (
+	onGCEOnce sync.Once
+	onGCE     bool
+)
+
+// OnGCE reports whether this process is running on Google Compute Engine.
+func OnGCE() bool {
+	onGCEOnce.Do(initOnGCE)
+	return onGCE
+}
+
+func initOnGCE() {
+	onGCE = testOnGCE()
+}
+
+func testOnGCE() bool {
+	// The user explicitly said they're on GCE, so trust them.
+	if os.Getenv(metadataHostEnv) != "" {
+		return true
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	resc := make(chan bool, 2)
+
+	// Try two strategies in parallel.
+	// See https://github.com/googleapis/google-cloud-go/issues/194
+	go func() {
+		req, _ := http.NewRequest("GET", "http://"+metadataIP, nil)
+		req.Header.Set("User-Agent", userAgent)
+		res, err := defaultClient.hc.Do(req.WithContext(ctx))
+		if err != nil {
+			resc <- false
+			return
+		}
+		defer res.Body.Close()
+		resc <- res.Header.Get("Metadata-Flavor") == "Google"
+	}()
+
+	go func() {
+		addrs, err := net.DefaultResolver.LookupHost(ctx, "metadata.google.internal")
+		if err != nil || len(addrs) == 0 {
+			resc <- false
+			return
+		}
+		resc <- strsContains(addrs, metadataIP)
+	}()
+
+	tryHarder := systemInfoSuggestsGCE()
+	if tryHarder {
+		res := <-resc
+		if res {
+			// The first strategy succeeded, so let's use it.
+			return true
+		}
+		// Wait for either the DNS or metadata server probe to
+		// contradict the other one and say we are running on
+		// GCE. Give it a lot of time to do so, since the system
+		// info already suggests we're running on a GCE BIOS.
+		timer := time.NewTimer(5 * time.Second)
+		defer timer.Stop()
+		select {
+		case res = <-resc:
+			return res
+		case <-timer.C:
+			// Too slow. Who knows what this system is.
+			return false
+		}
+	}
+
+	// There's no hint from the system info that we're running on
+	// GCE, so use the first probe's result as truth, whether it's
+	// true or false. The goal here is to optimize for speed for
+	// users who are NOT running on GCE. We can't assume that
+	// either a DNS lookup or an HTTP request to a blackholed IP
+	// address is fast. Worst case this should return when the
+	// metaClient's Transport.ResponseHeaderTimeout or
+	// Transport.Dial.Timeout fires (in two seconds).
+	return <-resc
+}
+
+// systemInfoSuggestsGCE reports whether the local system (without
+// doing network requests) suggests that we're running on GCE. If this
+// returns true, testOnGCE tries a bit harder to reach its metadata
+// server.
+func systemInfoSuggestsGCE() bool {
+	if runtime.GOOS != "linux" {
+		// We don't have any non-Linux clues available, at least yet.
+		return false
+	}
+	slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name")
+	name := strings.TrimSpace(string(slurp))
+	return name == "Google" || name == "Google Compute Engine"
+}
+
+// Subscribe calls Client.Subscribe on the default client.
+func Subscribe(suffix string, fn func(v string, ok bool) error) error {
+	return defaultClient.Subscribe(suffix, fn)
+}
+
+// Get calls Client.Get on the default client.
+func Get(suffix string) (string, error) { return defaultClient.Get(suffix) }
+
+// ProjectID returns the current instance's project ID string.
+func ProjectID() (string, error) { return defaultClient.ProjectID() }
+
+// NumericProjectID returns the current instance's numeric project ID.
+func NumericProjectID() (string, error) { return defaultClient.NumericProjectID() }
+
+// InternalIP returns the instance's primary internal IP address.
+func InternalIP() (string, error) { return defaultClient.InternalIP() }
+
+// ExternalIP returns the instance's primary external (public) IP address.
+func ExternalIP() (string, error) { return defaultClient.ExternalIP() }
+
+// Email calls Client.Email on the default client.
+func Email(serviceAccount string) (string, error) { return defaultClient.Email(serviceAccount) }
+
+// Hostname returns the instance's hostname. This will be of the form
+// "<instanceID>.c.<projID>.internal".
+func Hostname() (string, error) { return defaultClient.Hostname() }
+
+// InstanceTags returns the list of user-defined instance tags,
+// assigned when initially creating a GCE instance.
+func InstanceTags() ([]string, error) { return defaultClient.InstanceTags() }
+
+// InstanceID returns the current VM's numeric instance ID.
+func InstanceID() (string, error) { return defaultClient.InstanceID() }
+
+// InstanceName returns the current VM's instance ID string.
+func InstanceName() (string, error) { return defaultClient.InstanceName() }
+
+// Zone returns the current VM's zone, such as "us-central1-b".
+func Zone() (string, error) { return defaultClient.Zone() }
+
+// InstanceAttributes calls Client.InstanceAttributes on the default client.
+func InstanceAttributes() ([]string, error) { return defaultClient.InstanceAttributes() }
+
+// ProjectAttributes calls Client.ProjectAttributes on the default client.
+func ProjectAttributes() ([]string, error) { return defaultClient.ProjectAttributes() }
+
+// InstanceAttributeValue calls Client.InstanceAttributeValue on the default client.
+func InstanceAttributeValue(attr string) (string, error) {
+	return defaultClient.InstanceAttributeValue(attr)
+}
+
+// ProjectAttributeValue calls Client.ProjectAttributeValue on the default client.
+func ProjectAttributeValue(attr string) (string, error) {
+	return defaultClient.ProjectAttributeValue(attr)
+}
+
+// Scopes calls Client.Scopes on the default client.
+func Scopes(serviceAccount string) ([]string, error) { return defaultClient.Scopes(serviceAccount) }
+
+func strsContains(ss []string, s string) bool {
+	for _, v := range ss {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
+
+// A Client provides metadata.
+type Client struct {
+	hc *http.Client
+}
+
+// NewClient returns a Client that can be used to fetch metadata.
+// Returns the client that uses the specified http.Client for HTTP requests.
+// If nil is specified, returns the default client.
+func NewClient(c *http.Client) *Client {
+	if c == nil {
+		return defaultClient
+	}
+
+	return &Client{hc: c}
+}
+
+// getETag returns a value from the metadata service as well as the associated ETag.
+// This func is otherwise equivalent to Get.
+func (c *Client) getETag(suffix string) (value, etag string, err error) {
+	// Using a fixed IP makes it very difficult to spoof the metadata service in
+	// a container, which is an important use-case for local testing of cloud
+	// deployments. To enable spoofing of the metadata service, the environment
+	// variable GCE_METADATA_HOST is first inspected to decide where metadata
+	// requests shall go.
+	host := os.Getenv(metadataHostEnv)
+	if host == "" {
+		// Using 169.254.169.254 instead of "metadata" here because Go
+		// binaries built with the "netgo" tag and without cgo won't
+		// know the search suffix for "metadata" is
+		// ".google.internal", and this IP address is documented as
+		// being stable anyway.
+		host = metadataIP
+	}
+	suffix = strings.TrimLeft(suffix, "/")
+	u := "http://" + host + "/computeMetadata/v1/" + suffix
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return "", "", err
+	}
+	req.Header.Set("Metadata-Flavor", "Google")
+	req.Header.Set("User-Agent", userAgent)
+	res, err := c.hc.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode == http.StatusNotFound {
+		return "", "", NotDefinedError(suffix)
+	}
+	all, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", "", err
+	}
+	if res.StatusCode != 200 {
+		return "", "", &Error{Code: res.StatusCode, Message: string(all)}
+	}
+	return string(all), res.Header.Get("Etag"), nil
+}
+
+// Get returns a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+//
+// If the GCE_METADATA_HOST environment variable is not defined, a default of
+// 169.254.169.254 will be used instead.
+//
+// If the requested metadata is not defined, the returned error will
+// be of type NotDefinedError.
+func (c *Client) Get(suffix string) (string, error) {
+	val, _, err := c.getETag(suffix)
+	return val, err
+}
+
+func (c *Client) getTrimmed(suffix string) (s string, err error) {
+	s, err = c.Get(suffix)
+	s = strings.TrimSpace(s)
+	return
+}
+
+func (c *Client) lines(suffix string) ([]string, error) {
+	j, err := c.Get(suffix)
+	if err != nil {
+		return nil, err
+	}
+	s := strings.Split(strings.TrimSpace(j), "\n")
+	for i := range s {
+		s[i] = strings.TrimSpace(s[i])
+	}
+	return s, nil
+}
+
+// ProjectID returns the current instance's project ID string.
+func (c *Client) ProjectID() (string, error) { return projID.get(c) }
+
+// NumericProjectID returns the current instance's numeric project ID.
+func (c *Client) NumericProjectID() (string, error) { return projNum.get(c) }
+
+// InstanceID returns the current VM's numeric instance ID.
+func (c *Client) InstanceID() (string, error) { return instID.get(c) }
+
+// InternalIP returns the instance's primary internal IP address.
+func (c *Client) InternalIP() (string, error) {
+	return c.getTrimmed("instance/network-interfaces/0/ip")
+}
+
+// Email returns the email address associated with the service account.
+// The account may be empty or the string "default" to use the instance's
+// main account.
+func (c *Client) Email(serviceAccount string) (string, error) {
+	if serviceAccount == "" {
+		serviceAccount = "default"
+	}
+	return c.getTrimmed("instance/service-accounts/" + serviceAccount + "/email")
+}
+
+// ExternalIP returns the instance's primary external (public) IP address.
+func (c *Client) ExternalIP() (string, error) {
+	return c.getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")
+}
+
+// Hostname returns the instance's hostname. This will be of the form
+// "<instanceID>.c.<projID>.internal".
+func (c *Client) Hostname() (string, error) {
+	return c.getTrimmed("instance/hostname")
+}
+
+// InstanceTags returns the list of user-defined instance tags,
+// assigned when initially creating a GCE instance.
+func (c *Client) InstanceTags() ([]string, error) {
+	var s []string
+	j, err := c.Get("instance/tags")
+	if err != nil {
+		return nil, err
+	}
+	if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// InstanceName returns the current VM's instance ID string.
+func (c *Client) InstanceName() (string, error) {
+	return c.getTrimmed("instance/name")
+}
+
+// Zone returns the current VM's zone, such as "us-central1-b".
+func (c *Client) Zone() (string, error) {
+	zone, err := c.getTrimmed("instance/zone")
+	// zone is of the form "projects/<projNum>/zones/<zoneName>".
+	if err != nil {
+		return "", err
+	}
+	return zone[strings.LastIndex(zone, "/")+1:], nil
+}
+
+// InstanceAttributes returns the list of user-defined attributes,
+// assigned when initially creating a GCE VM instance. The value of an
+// attribute can be obtained with InstanceAttributeValue.
+func (c *Client) InstanceAttributes() ([]string, error) { return c.lines("instance/attributes/") }
+
+// ProjectAttributes returns the list of user-defined attributes
+// applying to the project as a whole, not just this VM.  The value of
+// an attribute can be obtained with ProjectAttributeValue.
+func (c *Client) ProjectAttributes() ([]string, error) { return c.lines("project/attributes/") }
+
+// InstanceAttributeValue returns the value of the provided VM
+// instance attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// InstanceAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func (c *Client) InstanceAttributeValue(attr string) (string, error) {
+	return c.Get("instance/attributes/" + attr)
+}
+
+// ProjectAttributeValue returns the value of the provided
+// project attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// ProjectAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func (c *Client) ProjectAttributeValue(attr string) (string, error) {
+	return c.Get("project/attributes/" + attr)
+}
+
+// Scopes returns the service account scopes for the given account.
+// The account may be empty or the string "default" to use the instance's
+// main account.
+func (c *Client) Scopes(serviceAccount string) ([]string, error) {
+	if serviceAccount == "" {
+		serviceAccount = "default"
+	}
+	return c.lines("instance/service-accounts/" + serviceAccount + "/scopes")
+}
+
+// Subscribe subscribes to a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+// The suffix may contain query parameters.
+//
+// Subscribe calls fn with the latest metadata value indicated by the provided
+// suffix. If the metadata value is deleted, fn is called with the empty string
+// and ok false. Subscribe blocks until fn returns a non-nil error or the value
+// is deleted. Subscribe returns the error value returned from the last call to
+// fn, which may be nil when ok == false.
+func (c *Client) Subscribe(suffix string, fn func(v string, ok bool) error) error {
+	const failedSubscribeSleep = time.Second * 5
+
+	// First check to see if the metadata value exists at all.
+	val, lastETag, err := c.getETag(suffix)
+	if err != nil {
+		return err
+	}
+
+	if err := fn(val, true); err != nil {
+		return err
+	}
+
+	ok := true
+	if strings.ContainsRune(suffix, '?') {
+		suffix += "&wait_for_change=true&last_etag="
+	} else {
+		suffix += "?wait_for_change=true&last_etag="
+	}
+	for {
+		val, etag, err := c.getETag(suffix + url.QueryEscape(lastETag))
+		if err != nil {
+			if _, deleted := err.(NotDefinedError); !deleted {
+				time.Sleep(failedSubscribeSleep)
+				continue // Retry on other errors.
+			}
+			ok = false
+		}
+		lastETag = etag
+
+		if err := fn(val, ok); err != nil || !ok {
+			return err
+		}
+	}
+}
+
+// Error contains an error response from the server.
+type Error struct {
+	// Code is the HTTP response status code.
+	Code int
+	// Message is the server response message.
+	Message string
+}
+
+func (e *Error) Error() string {
+	return fmt.Sprintf("compute: Received %d `%s`", e.Code, e.Message)
+}

vendor/github.com/TwinProduction/gocache/.gitattributes

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

vendor/github.com/TwinProduction/gocache/.gitignore

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

vendor/github.com/TwinProduction/gocache/Dockerfile

@@ -0,0 +1,20 @@
+# Build the go application into a binary
+FROM golang:alpine as builder
+WORKDIR /app
+ADD . ./
+RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o bin/gocache-server ./gocacheserver/main
+RUN apk --update add --no-cache ca-certificates
+
+FROM scratch
+ENV APP_HOME=/app
+ENV APP_DATA=/app/data
+ENV PORT=6379
+ENV MAX_CACHE_SIZE=100000
+ENV MAX_MEMORY_USAGE=0
+ENV AUTOSAVE="false"
+VOLUME ${APP_DATA}
+WORKDIR ${APP_HOME}
+COPY --from=builder /app/bin/gocache-server ./bin/gocache-server
+COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
+EXPOSE ${PORT}
+ENTRYPOINT ["/app/bin/gocache-server"]

vendor/github.com/TwinProduction/gocache/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2020 TwinProduction
+
+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/TwinProduction/gocache/Makefile

@@ -0,0 +1,24 @@
+db: docker-build
+dr: docker-run
+drmem: docker-run-max-memory-usage
+
+docker-build:
+	docker build --tag=gocache-server .
+
+docker-run:
+	docker run -p 6666:6379 -e AUTOSAVE=true -e MAX_CACHE_SIZE=0 --name gocache-server -d gocache-server
+
+docker-run-max-memory-usage:
+	docker run -p 6666:6379 -e AUTOSAVE=true -e MAX_CACHE_SIZE=0 -e MAX_MEMORY_USAGE=524288000 --name gocache-server -d gocache-server
+
+run:
+	PORT=6666 go run gocacheserver/main/server.go
+
+start-redis:
+	docker run -p 6379:6379 --name redis -d redis
+
+redis-benchmark:
+	redis-benchmark -p 6666 -t set,get -n 10000000 -r 200000 -q -P 512 -c 512
+
+memtier-benchmark:
+	memtier_benchmark --port 6666 --hide-histogram --key-maximum 100000 --ratio 1:1 --expiry-range 1-100 --key-pattern R:R --randomize -n 100000

vendor/github.com/TwinProduction/gocache/README.md

@@ -0,0 +1,452 @@
+# gocache
+
+![build](https://github.com/TwinProduction/gocache/workflows/build/badge.svg?branch=master) 
+[![Go Report Card](https://goreportcard.com/badge/github.com/TwinProduction/gocache)](https://goreportcard.com/report/github.com/TwinProduction/gocache)
+[![codecov](https://codecov.io/gh/TwinProduction/gocache/branch/master/graph/badge.svg)](https://codecov.io/gh/TwinProduction/gocache)
+[![Go version](https://img.shields.io/github/go-mod/go-version/TwinProduction/gocache.svg)](https://github.com/TwinProduction/gocache)
+[![Go Reference](https://pkg.go.dev/badge/github.com/TwinProduction/gocache.svg)](https://pkg.go.dev/github.com/TwinProduction/gocache)
+
+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 persistence to file.
+
+
+## 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)
+  - [Limitations](#limitations)
+- [Eviction](#eviction)
+  - [MaxSize](#maxsize)
+  - [MaxMemoryUsage](#maxmemoryusage)
+- [Expiration](#expiration)
+- [Server](#server)
+- [Running the server with Docker](#running-the-server-with-docker)
+- [Performance](#performance)
+  - [Summary](#summary)
+  - [Results](#results)
+- [FAQ](#faq)
+  - [Why does the memory usage not go down?](#why-does-the-memory-usage-not-go-down)
+
+
+## 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 bulk operations, persistence and patterns.
+
+While meant to be used as a library, there's a Redis-compatible cache server included. 
+See the [Server](#server) section. 
+It may also serve as a good reference to use in order to implement gocache in your own applications.
+
+
+## Usage
+```
+go get -u github.com/TwinProduction/gocache
+```
+
+### 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).
+| 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 with no expiration (`gocache.NoExpiration`)
+| SetAll                            | Same as `Set`, but in bulk
+| 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 
+| 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.
+| 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.
+| SaveToFile                        | Stores the content of the cache to a file so that it can be read using `ReadFromFile`. See [persistence](#persistence).
+| ReadFromFile                      | Populates the cache using a file created using `SaveToFile`. See [persistence](#persistence).
+
+For further documentation, please refer to [Go Reference](https://pkg.go.dev/github.com/TwinProduction/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/TwinProduction/gocache"
+)
+
+func main() {
+	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(10000)
+	cache.StartJanitor() // Passively manages expired entries
+
+	cache.Set("key", "value")
+	cache.SetWithTTL("key-with-ttl", "value", 60*time.Minute)
+	cache.SetAll(map[string]interface{}{"k1": "v1", "k2": "v2", "k3": "v3"})
+
+	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] key=%s\n", key)
+	}
+
+	fmt.Println("Cache size before persisting cache to file:", cache.Count())
+	err := cache.SaveToFile("cache.bak")
+	if err != nil {
+		panic(fmt.Sprintf("failed to persist cache to file: %s", err.Error()))
+	}
+
+	cache.Expire("key", time.Hour)
+	time.Sleep(500*time.Millisecond)
+	timeUntilExpiration, _ := cache.TTL("key")
+	fmt.Println("Number of minutes before 'key' expires:", int(timeUntilExpiration.Seconds()))
+
+	cache.Delete("key")
+	cache.DeleteAll([]string{"k1", "k2", "k3"})
+
+	fmt.Println("Cache size before restoring cache from file:", cache.Count())
+	_, err = cache.ReadFromFile("cache.bak")
+	if err != nil {
+		panic(fmt.Sprintf("failed to restore cache from file: %s", err.Error()))
+	}
+
+	fmt.Println("Cache size after restoring cache from file:", cache.Count())
+	cache.Clear()
+	fmt.Println("Cache size after clearing the cache:", cache.Count())
+}
+```
+
+<details>
+  <summary>Output</summary>
+
+```
+[Get] key=key; value=value; exists=true
+[GetByKeys] key=k2; value=v2
+[GetByKeys] key=k3; value=v3
+[GetByKeys] key=k1; value=v1
+[GetKeysByPattern] key=key
+[GetKeysByPattern] key=key-with-ttl
+Cache size before persisting cache to file: 5
+Number of minutes before 'key' expires: 3599
+Cache size before restoring cache from file: 1
+Cache size after restoring cache from file: 5
+Cache size after clearing the cache: 0
+```
+</details>
+
+
+## Persistence
+While gocache is an in-memory cache, you can still save the content of the cache in a file
+and vice versa.
+
+To save the content of the cache to a file:
+```go
+err := cache.SaveToFile(TestCacheFile)
+```
+
+To retrieve the content of the cache from a file:
+```go
+numberOfEntriesEvicted, err := newCache.ReadFromFile(TestCacheFile)
+```
+The `numberOfEntriesEvicted` will be non-zero only if the number of entries 
+in the file is higher than the cache's configured `MaxSize`.
+
+### Limitations
+While you can cache structs in memory out of the box, persisting structs to a file requires you to 
+**register the custom interfaces that your application uses with the `gob` package**.
+
+```go
+type YourCustomStruct struct {
+	A string
+	B int
+}
+
+// ...
+cache.Set("key", YourCustomStruct{A: "test", B: 123})
+```
+To persist your custom struct properly:
+```go
+gob.Register(YourCustomStruct{})
+cache.SaveToFile("gocache.bak")
+``` 
+The same applies for restoring the cache from a file:
+```go
+cache := NewCache()
+gob.Register(YourCustomStruct{})
+cache.ReadFromFile(TestCacheFile)
+value, _ := cache.Get("key")
+fmt.Println(value.(YourCustomStruct))
+```
+You only need to persist the struct once, so adding the following function in a file would suffice:
+```go
+func init() {
+    gob.Register(YourCustomStruct{})
+}
+```
+
+Failure to register your custom structs will prevent gocache from persisting and/or parsing the value of each keys that 
+use said custom structs.
+
+That being said, assuming that you're using gocache as a cache, this shouldn't create any bugs on your end, because
+every key that cannot be parsed are not populated into the cache by `ReadFromFile`.
+
+In other words, if you're falling back to a database or something similar when the cache doesn't have the key requested,
+you'll be fine.
+
+
+## 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.
+
+
+## Server
+For the sake of convenience, a ready-to-go cache server is available 
+through the `gocacheserver` package. 
+
+The reason why the server is in a different package is because `gocache` does not use 
+any external dependencies, but rather than re-inventing the wheel, the server 
+implementation uses redcon, which is a Redis server framework for Go.
+
+That way, those who desire to use gocache without the server will not add any extra dependencies
+as long as they don't import the `gocacheserver` package. 
+
+```go
+package main
+
+import (
+	"github.com/TwinProduction/gocache"
+	"github.com/TwinProduction/gocache/gocacheserver"
+)
+
+func main() {
+	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(100000)
+	server := gocacheserver.NewServer(cache)
+	server.Start()
+}
+```
+
+Any Redis client should be able to interact with the server, though only the following instructions are supported:
+- [X] GET
+- [X] SET
+- [X] DEL
+- [X] PING
+- [X] QUIT
+- [X] INFO
+- [X] EXPIRE
+- [X] SETEX
+- [X] TTL
+- [X] FLUSHDB
+- [X] EXISTS
+- [X] ECHO
+- [X] MGET
+- [X] MSET
+- [X] SCAN (kind of - cursor is not currently supported)
+- [ ] KEYS
+
+
+## Running the server with Docker
+[![Docker pulls](https://img.shields.io/docker/pulls/twinproduction/gocache-server.svg)](https://cloud.docker.com/repository/docker/twinproduction/gocache-server)
+
+To build it locally, refer to the Makefile's `docker-build` and `docker-run` steps.
+
+Note that the server version of gocache is still under development.
+
+```
+docker run --name gocache-server -p 6379:6379 twinproduction/gocache-server
+```
+
+
+## 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 |
+
+```
+BenchmarkMap_Get-8                                                         	95936680	      26.3 ns/op
+BenchmarkMap_SetSmallValue-8                                               	 7738132	       424 ns/op
+BenchmarkMap_SetMediumValue-8                                              	 7766346	       424 ns/op
+BenchmarkMap_SetLargeValue-8                                               	 7947063	       435 ns/op
+BenchmarkCache_Get-8                                                       	54549049	      45.7 ns/op
+BenchmarkCache_SetSmallValue-8                                             	35225013	      69.2 ns/op
+BenchmarkCache_SetMediumValue-8                                            	 5952064	       412 ns/op
+BenchmarkCache_SetLargeValue-8                                             	 5969121	       411 ns/op
+BenchmarkCache_GetUsingLRU-8                                               	54545949	      45.6 ns/op
+BenchmarkCache_SetSmallValueUsingLRU-8                                     	 5909504	       419 ns/op
+BenchmarkCache_SetMediumValueUsingLRU-8                                    	 5910885	       418 ns/op
+BenchmarkCache_SetLargeValueUsingLRU-8                                     	 5867544	       419 ns/op
+BenchmarkCache_SetSmallValueWhenUsingMaxMemoryUsage-8                      	 5477178	       462 ns/op
+BenchmarkCache_SetMediumValueWhenUsingMaxMemoryUsage-8                     	 5417595	       475 ns/op
+BenchmarkCache_SetLargeValueWhenUsingMaxMemoryUsage-8                      	 5215263	       479 ns/op
+BenchmarkCache_SetSmallValueWithMaxSize10-8                                	10115574	       236 ns/op
+BenchmarkCache_SetMediumValueWithMaxSize10-8                               	10242792	       241 ns/op
+BenchmarkCache_SetLargeValueWithMaxSize10-8                                	10201894	       241 ns/op
+BenchmarkCache_SetSmallValueWithMaxSize1000-8                              	 9637113	       253 ns/op
+BenchmarkCache_SetMediumValueWithMaxSize1000-8                             	 9635175	       253 ns/op
+BenchmarkCache_SetLargeValueWithMaxSize1000-8                              	 9598982	       260 ns/op
+BenchmarkCache_SetSmallValueWithMaxSize100000-8                            	 7642584	       337 ns/op
+BenchmarkCache_SetMediumValueWithMaxSize100000-8                           	 7407571	       344 ns/op
+BenchmarkCache_SetLargeValueWithMaxSize100000-8                            	 7071360	       345 ns/op
+BenchmarkCache_SetSmallValueWithMaxSize100000AndLRU-8                      	 7544194	       332 ns/op
+BenchmarkCache_SetMediumValueWithMaxSize100000AndLRU-8                     	 7667004	       344 ns/op
+BenchmarkCache_SetLargeValueWithMaxSize100000AndLRU-8                      	 7357642	       338 ns/op
+BenchmarkCache_GetAndSetMultipleConcurrently-8                             	 1442306	      1684 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndLRU-8                 	 5117271	       477 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndFIFO-8                	 5228412	       475 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndLRU-8    	 5139195	       529 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndFIFO-8   	 5251639	       511 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndLRU-8          	 7384626	       334 ns/op
+BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndFIFO-8         	 7361985	       332 ns/op
+BenchmarkCache_GetConcurrentlyWithLRU-8                                    	 3370784	       726 ns/op
+BenchmarkCache_GetConcurrentlyWithFIFO-8                                   	 3749994	       681 ns/op
+BenchmarkCache_GetKeysThatDoNotExistConcurrently-8                         	17647344	       143 ns/op
+```
+
+
+## FAQ
+
+### Why does the memory usage not go down?
+
+> **NOTE**: As of Go 1.16, this will no longer apply. See [golang/go#42330](https://github.com/golang/go/issues/42330)
+
+By default, Go uses `MADV_FREE` if the kernel supports it to release memory, which is significantly more efficient 
+than using `MADV_DONTNEED`. Unfortunately, this means that RSS doesn't go down unless the OS actually needs the 
+memory. 
+
+Technically, the memory _is_ available to the kernel, even if it shows a high memory usage, but the OS will only
+use that memory if it needs to. In the case that the OS does need the freed memory, the RSS will go down and you'll
+notice the memory usage lowering.
+
+[reference](https://github.com/golang/go/issues/33376#issuecomment-666455792)
+
+You can reproduce this by following the steps below:
+- Start gocacheserver
+- Note the memory usage
+- Create 500k keys
+- Note the memory usage
+- Flush the cache
+- Note that the memory usage has not decreased, despite the cache being empty.
+
+**Substituting gocache for a normal map will yield the same result.**
+
+If the released memory still appearing as used is a problem for you, 
+you can set the environment variable `GODEBUG` to `madvdontneed=1`.

vendor/github.com/TwinProduction/gocache/entry.go

@@ -0,0 +1,108 @@
+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 interface{}
+
+	// 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 interface{}) 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 []interface{}:
+		size := 0
+		for _, v := range value.([]interface{}) {
+			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/TwinProduction/gocache/go.mod

@@ -0,0 +1,11 @@
+module github.com/TwinProduction/gocache
+
+go 1.15
+
+require (
+	github.com/boltdb/bolt v1.3.1
+	github.com/go-redis/redis v6.15.9+incompatible
+	github.com/onsi/ginkgo v1.14.1 // indirect
+	github.com/onsi/gomega v1.10.2 // indirect
+	github.com/tidwall/redcon v1.3.2
+)

vendor/github.com/TwinProduction/gocache/go.sum

@@ -0,0 +1,66 @@
+github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg=
+github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+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.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+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 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.1 h1:jMU0WaQrP0a/YAEq8eJmJKjBoMs+pClEr1vDMlM/Do4=
+github.com/onsi/ginkgo v1.14.1/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.10.2 h1:aY/nuoWlKJud2J6U0E3NWsjlg+0GtwXxgEqthRdzlcs=
+github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/tidwall/redcon v1.3.2 h1:8INx/Nm3VSUbDUT16TH1rMgYQsbXNqy9xcX70edHXbo=
+github.com/tidwall/redcon v1.3.2/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7 h1:AeiKBIuRw3UomYXSbLy0Mc2dDLfdtbT/IVn4keq83P0=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+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.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/github.com/TwinProduction/gocache/gocache.go

@@ -0,0 +1,559 @@
+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")
+	ErrKeyHasNoExpiration    = errors.New("key has no expiration")
+	ErrJanitorAlreadyRunning = errors.New("janitor is already running")
+)
+
+// Cache is the core struct of gocache which contains the data as well as all relevant configuration fields
+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
+
+	// 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
+}
+
+// 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:
+//     cache := gocache.NewCache().WithForceNilInterfaceOnNilPointer(true)
+//     cache.Set("key", (*Struct)(nil))
+//     value, _ := cache.Get("key")
+//     // the following returns true, because the interface{} was forcefully set to nil
+//     if value == nil {}
+//     // the following will panic, because the value has been casted to its type
+//     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{} returned has a non-nil type (*Struct)
+//     if value == nil {}
+//     // the following returns true, because the value has been casted 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
+// 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,
+		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 interface{}) {
+	cache.SetWithTTL(key, value, NoExpiration)
+}
+
+// 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 interface{}, ttl time.Duration) {
+	// An interface is only nil if both its value and its type are nil, however, passing a pointer
+	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(),
+			previous:          cache.head,
+		}
+		if cache.head == nil {
+			cache.tail = entry
+		} else {
+			cache.head.next = 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 {
+			// Substract 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]interface{}) {
+	for key, value := range entries {
+		cache.SetWithTTL(key, value, NoExpiration)
+	}
+}
+
+// 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) (interface{}, bool) {
+	cache.mutex.Lock()
+	entry, ok := cache.get(key)
+	if !ok {
+		cache.mutex.Unlock()
+		cache.stats.Misses++
+		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
+}
+
+// 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]interface{} {
+	entries := make(map[string]interface{})
+	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]interface{} {
+	entries := make(map[string]interface{})
+	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, the latter
+// only applying if the cache uses the LeastRecentlyUsed eviction policy.
+// 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
+}
+
+// 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.previous = cache.head
+		entry.next = nil
+		if cache.head != nil {
+			cache.head.next = 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.next
+	} else if cache.head == entry {
+		cache.head = cache.head.previous
+	}
+	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/TwinProduction/gocache/janitor.go

@@ -0,0 +1,140 @@
+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
+	JanitorMaxIterationsPerShift = 1000
+
+	// JanitorMinShiftBackOff is the minimum interval between each iteration of steps
+	// defined by JanitorMaxIterationsPerShift
+	JanitorMinShiftBackOff = time.Millisecond * 50
+
+	// JanitorMaxShiftBackOff is the maximum interval between each iteration of steps
+	// defined by JanitorMaxIterationsPerShift
+	JanitorMaxShiftBackOff = time.Millisecond * 500
+)
+
+// 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 next 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 {
+						var next *Entry
+						steps++
+						if current.Expired() {
+							expiredEntriesFound++
+							// Because delete will remove the next reference from the entry, we need to store the
+							// next reference before we delete it
+							next = current.next
+							cache.delete(current.Key)
+							cache.stats.ExpiredKeys++
+						}
+						if current == cache.head {
+							lastTraversedNode = nil
+							break
+						}
+						// Travel to the current node's next node only if no specific next node has been specified
+						if next != nil {
+							current = next
+						} else {
+							current = current.next
+						}
+						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 in which setting cache.stopJanitor
+		// to nil
+		cache.stopJanitor <- true
+		<-cache.stopJanitor
+		cache.stopJanitor = nil
+	}
+}

vendor/github.com/TwinProduction/gocache/pattern.go

@@ -0,0 +1,12 @@
+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
+}