Merge pull request #162 from skamboj/update-golang

Update golang to 1.25 and update all dependencies

.dockerignore

@@ -1 +1,3 @@
 .git/
+bin/
+vendor/

.github/workflows/helm-publish.yaml

@@ -0,0 +1,33 @@
+name: Helm Publish
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  helm_publish:
+    # depending on default permission settings for your org (contents being read-only or read-write for workloads), you will have to add permissions
+    # see: https://docs.github.com/en/actions/security-guides/automatic-token-authentication#modifying-the-permissions-for-the-github_token
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Configure Git
+        run: |
+          git config user.name "$GITHUB_ACTOR"
+          git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
+
+      - name: Install Helm
+        uses: azure/setup-helm@v4
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+
+      - name: Run chart-releaser
+        uses: helm/chart-releaser-action@v1.7.0
+        env:
+          CR_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/helm-test.yaml

@@ -0,0 +1,74 @@
+name: Helm Test
+on:
+  pull_request:
+jobs:
+  helm_test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v6
+
+    - name: Install Go
+      uses: actions/setup-go@v6
+      with:
+        go-version-file: 'go.mod'
+
+    - name: Install Tools
+      shell: bash
+      id: tool-versions
+      env:
+        TILT_TOOL_CTLPTL_VERSION: "0.8.28"
+        TILT_TOOL_KIND_VERSION: "0.23.0"
+        TILT_TOOL_KUBECTL_VERSION: "1.30.0"
+        TILT_TOOL_HELM_VERSION: "3.14.4"
+        TILT_TOOL_TILT_VERSION: "0.33.13"
+      run: |
+
+        # Create Tools Directory
+        TOOLS_DIR=/opt/helm_tools
+        mkdir -p "${TOOLS_DIR}"
+
+        # Download ctlptl
+        echo "Downloading ctlptl"
+        curl -fsSL https://github.com/tilt-dev/ctlptl/releases/download/v${TILT_TOOL_CTLPTL_VERSION}/ctlptl.${TILT_TOOL_CTLPTL_VERSION}.linux.x86_64.tar.gz | sudo tar -xzv -C "${TOOLS_DIR}" ctlptl
+
+        # Download kind
+        echo "Downloading kind"
+        curl -fsSL https://kind.sigs.k8s.io/dl/v${TILT_TOOL_KIND_VERSION}/kind-linux-amd64 -o "${TOOLS_DIR}/kind"
+
+        # Download kubectl
+        echo "Downloading kubectl"
+        curl -fsSL https://dl.k8s.io/release/v${TILT_TOOL_KUBECTL_VERSION}/bin/linux/amd64/kubectl -o "${TOOLS_DIR}/kubectl"
+
+        # Download helm
+        echo "Downloading helm"
+        curl -fsSL https://get.helm.sh/helm-v${TILT_TOOL_HELM_VERSION}-linux-amd64.tar.gz | tar -xzv -C "${TOOLS_DIR}" --strip-components=1 linux-amd64/helm
+
+        # Download tilt
+        echo "Downloading tilt"
+        curl -fsSL https://github.com/tilt-dev/tilt/releases/download/v${TILT_TOOL_TILT_VERSION}/tilt.${TILT_TOOL_TILT_VERSION}.linux.x86_64.tar.gz | tar -xzv -C "${TOOLS_DIR}" tilt
+
+        # Make the binaries runnable
+        echo "Making binaries executable"
+        sudo chmod -R +x "${TOOLS_DIR}"
+
+        # Add tools to path
+        echo "PATH=${PATH}:${TOOLS_DIR}" >> $GITHUB_ENV
+
+    - name: Start Kind Cluster
+      shell: bash
+      run: |
+        ctlptl apply -f kind.yaml
+
+    - name: Run Tilt Tests
+      shell: bash
+      run: |
+        tilt ci --debug --output-snapshot-on-exit=/tmp/tilt-snapshot.json
+
+    - name: Upload Tilt Snapshot
+      if: success() || failure()
+      uses: actions/upload-artifact@v6
+      with:
+        name: tilt-snapshot
+        path: |
+          /tmp/tilt-snapshot.json

.github/workflows/main.yml

@@ -0,0 +1,82 @@
+name: CI
+on:
+  push:
+    branches: [ main, master ]
+    tags:
+      - v*
+  pull_request:
+    branches: [ main, master ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    permissions:
+      contents: write
+      packages: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: 'go.mod'
+
+      # local build
+      - name: Compile the binary
+        run: |
+          make bin/goldpinger
+          ./bin/goldpinger -h
+
+      # simple Docker build
+      - name: Build the Docker image
+        run: |
+          make build
+          docker run `make version` --help
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          username: ${{ secrets.DOCKERHUB_USER }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      # multi-arch build
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          bake-target: docker-metadata-action
+          images: |
+            ${{ github.repository_owner }}/goldpinger
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+          labels: |
+            org.opencontainers.image.title=${{ github.repository }}
+            org.opencontainers.image.description=Goldpinger makes calls between its instances to monitor your networking. It runs as a DaemonSet on Kubernetes and produces Prometheus metrics that can be scraped, visualised and alerted on.
+            org.opencontainers.image.vendor=${{ github.repository_owner }}
+
+      - name: Build regular image
+        uses: docker/bake-action@v6
+        with:
+          targets: ci
+          push: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }}
+          files: |
+            ./docker-bake.hcl
+            cwd://${{ steps.meta.outputs.bake-file }}
+
+      # https://github.com/docker/buildx/issues/2105
+      - name: Create manifest
+        if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+        run: |
+          set -xe
+          for image in $images; do
+            docker buildx imagetools create -t "${image}" "${image}-linux" "${image}-windows-ltsc2019" "${image}-windows-ltsc2022"
+          done
+        env:
+          images: "${{ join( steps.meta.outputs.tags, ' ') }}"

.gitignore

@@ -91,3 +91,4 @@ ENV/
 # Rope project settings
 .ropeproject
 
+.secrets

.travis.yml

@@ -1,38 +0,0 @@
-language: go
-
-services:
-  - docker
-
-go:
-  - "1.14.x"
-  - master
-
-script:
-  - docker --version
-
-  # build locally and run locally
-  - make clean && make vendor && make && ./bin/goldpinger --help
-
-  # build an image and run the image
-  - make clean && make vendor && make build
-  - docker images
-  - docker run `make version` --help
-
-  # build an image using the multistage builder
-  - make clean && make build-multistage
-  - docker images
-  - docker run `make version` --help
-
-  # build an image with the vendor folder
-  - make clean && make vendor && make vendor-build
-  - docker images
-  - docker run `make version`-vendor --help
-
-deploy:
-  provider: script
-  script: bash docker_deploy.sh
-  skip_cleanup: true
-  on:
-    tags: true
-    go: "1.14.x"
-    condition: -n "$DOCKER_PASSWORD"

Dockerfile

@@ -1,23 +1,33 @@
-FROM golang:1.14-alpine as builder
+ARG WINDOWS_BASE_IMAGE=mcr.microsoft.com/windows/nanoserver:ltcs2022
 
-# Install our build tools
-
-RUN apk add --update git make bash
+FROM --platform=$BUILDPLATFORM golang:1.25 as builder
+ARG TARGETARCH
+ARG TARGETOS
 
 # Get dependencies
-
 WORKDIR /w
-COPY go.mod go.sum /w/
+COPY go.mod go.sum ./
 RUN go mod download
 
 # Build goldpinger
-
 COPY . ./
-RUN make bin/goldpinger
+RUN GOOS=$TARGETOS GOARCH=$TARGETARCH make bin/goldpinger
+# Create vendor folder
+RUN go mod vendor
 
 # Build the asset container, copy over goldpinger
-
-FROM scratch
+FROM gcr.io/distroless/static:nonroot as simple
 COPY --from=builder /w/bin/goldpinger /goldpinger
 COPY ./static /static
+COPY ./config /config
 ENTRYPOINT ["/goldpinger", "--static-file-path", "/static"]
+
+FROM $WINDOWS_BASE_IMAGE AS windows
+COPY --from=builder /w/bin/goldpinger /goldpinger.exe
+COPY ./static /static
+COPY ./config /config
+ENTRYPOINT ["/goldpinger.exe", "--static-file-path=/static"]
+
+# For vendor builds, use the simple build and add the vendor'd files
+FROM simple as vendor
+COPY --from=builder /w/vendor /goldpinger-vendor-sources

Makefile

@@ -1,15 +1,16 @@
 name ?= goldpinger
-version ?= v3.1.0
+version ?= v3.10.3
 bin ?= goldpinger
 pkg ?= "github.com/bloomberg/goldpinger"
 tag = $(name):$(version)
 goos ?= ${GOOS}
+goarch ?= ${GOARCH}
 namespace ?= "bloomberg/"
 files = $(shell find . -iname "*.go")
 
 
 bin/$(bin): $(files)
-	GOOS=${goos} PKG=${pkg} ARCH=amd64 VERSION=${version} BIN=${bin} ./build/build.sh
+	GOOS=${goos} PKG=${pkg} ARCH=${goarch} VERSION=${version} BIN=${bin} ./build/build.sh
 
 clean:
 	rm -rf ./vendor
@@ -24,34 +25,21 @@ swagger:
 	swagger generate server -t pkg -f ./swagger.yml --exclude-main -A goldpinger && \
 	swagger generate client -t pkg -f ./swagger.yml -A goldpinger
 
-build-multistage:
-	docker build -t $(tag) -f ./Dockerfile .
-
-build: GOOS=linux
-build: bin/$(bin)
-	docker build -t $(tag) -f ./build/Dockerfile-simple .
-
-tag:
-	docker tag $(tag) $(namespace)$(tag)
-
-push:
-	docker push $(namespace)$(tag)
-
 run:
 	go run ./cmd/goldpinger/main.go
 
+build:
+	docker build -t $(namespace)$(tag) --target simple -f ./Dockerfile .
+
+build-vendor:
+	docker build -t $(namespace)$(tag)-vendor --target vendor -f ./Dockerfile .
+
+build-release:
+	docker buildx build --push --platform linux/amd64,linux/arm64 --target simple -t $(namespace)$(tag) -f ./Dockerfile .
+	docker buildx build --push --platform linux/amd64,linux/arm64 --target vendor -t $(namespace)$(tag)-vendor -f ./Dockerfile .
+
 version:
-	@echo $(tag)
+	@echo $(namespace)$(tag)
 
 
-vendor-build:
-	docker build -t $(tag)-vendor --build-arg TAG=$(tag) -f ./build/Dockerfile-vendor .
-
-vendor-tag:
-	docker tag $(tag)-vendor $(namespace)$(tag)-vendor
-
-vendor-push:
-	docker push $(namespace)$(tag)-vendor
-
-
-.PHONY: clean vendor swagger build build-multistage vendor-build vendor-tag vendor-push tag push run version
+.PHONY: clean vendor swagger build build-release build-vendor run version

README.md

@@ -1,6 +1,7 @@
 # Goldpinger
 
-[![Build Status](https://travis-ci.com/bloomberg/goldpinger.svg?branch=master)](https://travis-ci.com/bloomberg/goldpinger)
+[![Publish](https://github.com/bloomberg/goldpinger/actions/workflows/publish.yml/badge.svg)](https://github.com/bloomberg/goldpinger/actions/workflows/publish.yml)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bloomberg/goldpinger)
 
 __Goldpinger__ makes calls between its instances to monitor your networking.
 It runs as a [`DaemonSet`](#example-yaml) on `Kubernetes` and produces `Prometheus` metrics that can be [scraped](#prometheus), [visualised](#grafana) and [alerted](#alert-manager) on.
@@ -68,21 +69,20 @@ The repo comes with two ways of building a `docker` image: compiling locally, an
 You will need `docker` version 17.05+ installed to support multi-stage builds.
 
 ```sh
-# step 1: launch the build
-make build-multistage
+# Build a local container without publishing
+make build
 
-# step 2: push the image somewhere
-namespace="docker.io/myhandle/" make tag
-namespace="docker.io/myhandle/" make push
+# Build & push the image somewhere
+namespace="docker.io/myhandle/" make build-release
 ```
 
 This was contributed via [@michiel](https://github.com/michiel) - kudos !
 
 ### Compiling locally
 
-In order to build `Goldpinger`, you are going to need `go` version 1.13+ and `docker`.
+In order to build `Goldpinger`, you are going to need `go` version 1.15+ and `docker`.
 
-Building from source code consists of compiling the binary and building a [Docker image](./build/Dockerfile-simple):
+Building from source code consists of compiling the binary and building a [Docker image](./Dockerfile):
 
 ```sh
 # step 0: check out the code
@@ -95,22 +95,32 @@ make bin/goldpinger
 ./bin/goldpinger --help
 
 # step 2: build the docker image containing the binary
-make build
+namespace="docker.io/myhandle/" make build
 
 # step 3: push the image somewhere
-namespace="docker.io/myhandle/" make tag
-namespace="docker.io/myhandle/" make push
+docker push $(namespace="docker.io/myhandle/" make version)
 ```
 
 ## Installation
-
 `Goldpinger` works by asking `Kubernetes` for pods with particular labels (`app=goldpinger`). While you can deploy `Goldpinger` in a variety of ways, it works very nicely as a `DaemonSet` out of the box.
 
-### Authentication with Kubernetes API
+### Helm Installation
+Goldpinger can be installed via [Helm](https://helm.sh/) using the following:
+
+```
+helm repo add goldpinger https://bloomberg.github.io/goldpinger
+helm repo update
+helm install goldpinger goldpinger/goldpinger
+```
+
+### Manual Installation
+`Goldpinger` can be installed manually via configuration similar to the following:
+
+#### Authentication with Kubernetes API
 
 `Goldpinger` supports using a `kubeconfig` (specify with `--kubeconfig-path`) or service accounts.
 
-### Example YAML
+#### Example YAML
 
 Here's an example of what you can do (using the in-cluster authentication to `Kubernetes` apiserver).
 
@@ -120,6 +130,7 @@ apiVersion: v1
 kind: ServiceAccount
 metadata:
   name: goldpinger-serviceaccount
+  namespace: default
 ---
 apiVersion: apps/v1
 kind: DaemonSet
@@ -215,7 +226,7 @@ Note, that you will also need to add an RBAC rule to allow `Goldpinger` to list
 
 ```yaml
 ---
-apiVersion: rbac.authorization.k8s.io/v1beta1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
   name: default
@@ -231,6 +242,12 @@ subjects:
 
 You can also see [an example of using `kubeconfig` in the `./extras`](./extras/example-with-kubeconfig.yaml).
 
+### Using with IPv4/IPv6 dual-stack
+
+If your cluster IPv4/IPv6 dual-stack and you want to force IPv6, you can set the `IP_VERSIONS` environment variable to "6" (default is "4") which will use the IPv6 address on the pod and host.
+
+![ipv6](./extras/screenshot-ipv6.png)
+
 ### Note on DNS
 
 Note, that on top of resolving the other pods, all instances can also try to resolve arbitrary DNS. This allows you to test your DNS setup.
@@ -252,6 +269,27 @@ and `goldpinger` should show something like this:
 
 ![screenshot-DNS-resolution](./extras/dns-screenshot.png)
 
+### TCP and HTTP checks to external targets
+
+Instances can also be configured to do simple TCP or HTTP checks on external targets. This is useful for visualizing more nuanced connectivity flows.
+
+```sh
+      --tcp-targets=             A list of external targets(<host>:<port> or <ip>:<port>) to attempt a TCP check on (space delimited) [$TCP_TARGETS]
+      --http-targets=            A  list of external targets(<http or https>://<url>) to attempt an HTTP{S} check on. A 200 HTTP code is considered successful. (space delimited) [$HTTP_TARGETS]
+      --tcp-targets-timeout=  The timeout for a tcp check on the provided tcp-targets (default: 500) [$TCP_TARGETS_TIMEOUT]
+      --dns-targets-timeout=  The timeout for a tcp check on the provided udp-targets (default: 500) [$DNS_TARGETS_TIMEOUT]
+```
+
+```yaml
+        - name: HTTP_TARGETS
+          value: http://bloomberg.com
+        - name: TCP_TARGETS
+          value: 10.34.5.141:5000 10.34.195.193:6442
+```
+
+the timeouts for the TCP, DNS and HTTP checks can be configured via `TCP_TARGETS_TIMEOUT`, `DNS_TARGETS_TIMEOUT` and `HTTP_TARGETS_TIMEOUT` respectively. 
+
+![screenshot-tcp-http-checks](./extras/tcp-checks-screenshot.png)
 
 ## Usage
 

Tiltfile

@@ -0,0 +1,30 @@
+# -*- mode: bazel-starlark -*-
+
+# Build the image
+docker_build('goldpinger-local', '.')
+
+# Deploy with Helm
+k8s_yaml(
+  helm(
+    'charts/goldpinger',
+    set = [
+      # Set the image to the one built by Tilt
+      'image.repository=goldpinger-local',
+    ],
+  )
+)
+
+# Track Goldpinger Resource
+k8s_resource(
+  'chart-goldpinger',
+  port_forwards = [8080],
+)
+
+# Validate that all 2 nodes can talk to eachother
+local_resource(
+  'check_reachability',
+  cmd='./extras/check_reachability.sh 2',
+  resource_deps = [
+    'chart-goldpinger',
+  ],
+)

build/Dockerfile-simple

@@ -1,6 +0,0 @@
-FROM scratch
-
-COPY bin/goldpinger /goldpinger
-COPY static /static
-
-ENTRYPOINT ["/goldpinger", "--static-file-path", "/static"]

build/Dockerfile-vendor

@@ -1,3 +0,0 @@
-ARG TAG
-FROM $TAG
-COPY vendor /goldpinger-vendor-sources

build/build.sh

@@ -24,18 +24,14 @@ if [ -z "${PKG}" ]; then
     echo "PKG must be set"
     exit 1
 fi
-if [ -z "${ARCH}" ]; then
-    echo "ARCH must be set"
-    exit 1
-fi
 if [ -z "${VERSION}" ]; then
     echo "VERSION must be set"
     exit 1
 fi
 
 export CGO_ENABLED=0
-export GOARCH="${ARCH}"
-export GOOS=${GOOS:-}
+export GOARCH="${ARCH:-amd64}"
+export GOOS=${GOOS:-linux}
 
 go build \
     -ldflags "-X 'main.Version=${VERSION}' -X 'main.Build=`date`'" \

charts/goldpinger/.helmignore

@@ -0,0 +1,23 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj
+
+OWNERS

charts/goldpinger/Chart.yaml

@@ -0,0 +1,8 @@
+apiVersion: v1
+name: goldpinger
+appVersion: "3.10.3"
+version: 1.0.2
+description: Goldpinger is a tool to help debug, troubleshoot and visualize network connectivity and slowness issues.
+home: https://github.com/bloomberg/goldpinger
+sources:
+  - https://github.com/bloomberg/goldpinger

charts/goldpinger/templates/_helpers.tpl

@@ -0,0 +1,62 @@
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "goldpinger.name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+If release name contains chart name it will be used as a full name.
+*/}}
+{{- define "goldpinger.fullname" -}}
+{{- if .Values.fullnameOverride }}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- $name := default .Chart.Name .Values.nameOverride }}
+{{- if contains $name .Release.Name }}
+{{- .Release.Name | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "goldpinger.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Common labels
+*/}}
+{{- define "goldpinger.labels" -}}
+helm.sh/chart: {{ include "goldpinger.chart" . }}
+{{ include "goldpinger.selectorLabels" . }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end }}
+
+{{/*
+Selector labels
+*/}}
+{{- define "goldpinger.selectorLabels" -}}
+app.kubernetes.io/name: {{ include "goldpinger.name" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- end }}
+
+{{/*
+Create the name of the service account to use
+*/}}
+{{- define "goldpinger.serviceAccountName" -}}
+{{- if .Values.serviceAccount.create }}
+{{- default (include "goldpinger.fullname" .) .Values.serviceAccount.name }}
+{{- else }}
+{{- default "default" .Values.serviceAccount.name }}
+{{- end }}
+{{- end }}

charts/goldpinger/templates/clusterrole.yaml

@@ -0,0 +1,12 @@
+{{- if and .Values.rbac.create .Values.rbac.clusterscoped }}
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: {{ include "goldpinger.fullname" . }}-clusterrole
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+rules:
+  - apiGroups: [""]
+    resources: ["pods"]
+    verbs: ["list"]
+{{- end }}

charts/goldpinger/templates/clusterrolebinding.yaml

@@ -0,0 +1,16 @@
+{{- if and .Values.rbac.create .Values.rbac.clusterscoped }}
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: {{ include "goldpinger.fullname" . }}-clusterrolebinding
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+subjects:
+  - kind: ServiceAccount
+    name: {{ include "goldpinger.serviceAccountName" . }}
+    namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: {{ include "goldpinger.fullname" . }}-clusterrole
+  apiGroup: rbac.authorization.k8s.io
+{{- end }}

charts/goldpinger/templates/configmap.yaml

@@ -0,0 +1,8 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "goldpinger.fullname" . }}-zap
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+data:
+  zap.json: {{ .Values.goldpinger.zapConfig | toJson }}

charts/goldpinger/templates/daemonset.yaml

@@ -0,0 +1,103 @@
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  name: {{ include "goldpinger.fullname" . }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+spec:
+  {{- with .Values.updateStrategy }}
+  updateStrategy:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+  selector:
+    matchLabels:
+      {{- include "goldpinger.selectorLabels" . | nindent 6 }}
+  template:
+    metadata:
+      {{- with .Values.podAnnotations }}
+      annotations:
+        {{ toYaml . | nindent 8 }}
+      {{- end }}
+      labels:
+        {{- include "goldpinger.selectorLabels" . | nindent 8 }}
+      {{- with .Values.podLabels }}
+        {{ toYaml . | nindent 8 }}
+      {{- end }}
+    spec:
+      priorityClassName: {{ .Values.priorityClassName }}
+      serviceAccountName: {{ include "goldpinger.serviceAccountName" . }}
+      {{- if .Values.image.pullSecrets }}
+      imagePullSecrets:
+        {{- range .Values.image.pullSecrets }}
+        - name: {{ . }}
+        {{- end }}
+      {{- end }}
+      containers:
+        - name: goldpinger-daemon
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          volumeMounts:
+            - name: zap
+              mountPath: /config
+          env:
+            - name: HOSTNAME
+              valueFrom:
+                fieldRef:
+                  fieldPath: spec.nodeName
+            - name: HOST
+              value: "0.0.0.0"
+            - name: PORT
+              value: "{{ .Values.goldpinger.port }}"
+            - name: LABEL_SELECTOR
+              value: "app.kubernetes.io/name={{ include "goldpinger.name" . }}"
+            {{- if .Values.extraEnv -}}
+            {{ toYaml .Values.extraEnv | nindent 12 }}
+            {{- end }}
+          {{- with .Values.containerSecurityContext }}
+          securityContext:
+            {{- toYaml . | nindent 12 }}
+          {{- end }}
+          ports:
+            - name: http
+              containerPort: {{ .Values.goldpinger.port }}
+              protocol: TCP
+              {{- range $k := .Values.extraEnv }}
+              {{- if and (eq $k.name "USE_HOST_IP") (eq $k.value "true") }}
+              hostPort: {{ $.Values.goldpinger.port }}
+              {{- end }}
+              {{- end }}
+          livenessProbe:
+            httpGet:
+              path: /
+              port: http
+          readinessProbe:
+            httpGet:
+              path: /
+              port: http
+          resources:
+            {{- toYaml .Values.resources | nindent 12 }}
+      volumes:
+        - name: zap
+          configMap:
+            name: {{ include "goldpinger.fullname" . }}-zap
+      {{- range $k := .Values.extraEnv }}
+      {{- if and (eq $k.name "USE_HOST_IP") (eq $k.value "true") }}
+      hostNetwork: true
+      {{- end }}
+      {{- end }}
+      {{- with .Values.nodeSelector }}
+      nodeSelector:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.affinity }}
+      affinity:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.tolerations }}
+      tolerations:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.podSecurityContext }}
+      securityContext:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}

charts/goldpinger/templates/ingress.yaml

@@ -0,0 +1,61 @@
+{{- if .Values.ingress.enabled -}}
+{{- $fullName := include "goldpinger.fullname" . -}}
+{{- $svcPort := .Values.service.port -}}
+{{- if and .Values.ingress.className (not (semverCompare ">=1.18-0" .Capabilities.KubeVersion.GitVersion)) }}
+  {{- if not (hasKey .Values.ingress.annotations "kubernetes.io/ingress.class") }}
+  {{- $_ := set .Values.ingress.annotations "kubernetes.io/ingress.class" .Values.ingress.className}}
+  {{- end }}
+{{- end }}
+{{- if semverCompare ">=1.19-0" .Capabilities.KubeVersion.GitVersion -}}
+apiVersion: networking.k8s.io/v1
+{{- else if semverCompare ">=1.14-0" .Capabilities.KubeVersion.GitVersion -}}
+apiVersion: networking.k8s.io/v1beta1
+{{- else -}}
+apiVersion: extensions/v1beta1
+{{- end }}
+kind: Ingress
+metadata:
+  name: {{ $fullName }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+  {{- with .Values.ingress.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+spec:
+  {{- if and .Values.ingress.className (semverCompare ">=1.18-0" .Capabilities.KubeVersion.GitVersion) }}
+  ingressClassName: {{ .Values.ingress.className }}
+  {{- end }}
+  {{- if .Values.ingress.tls }}
+  tls:
+    {{- range .Values.ingress.tls }}
+    - hosts:
+        {{- range .hosts }}
+        - {{ . | quote }}
+        {{- end }}
+      secretName: {{ .secretName }}
+    {{- end }}
+  {{- end }}
+  rules:
+    {{- range .Values.ingress.hosts }}
+    - host: {{ .host | quote }}
+      http:
+        paths:
+          {{- range .paths }}
+          - path: {{ .path }}
+            {{- if and .pathType (semverCompare ">=1.18-0" $.Capabilities.KubeVersion.GitVersion) }}
+            pathType: {{ .pathType }}
+            {{- end }}
+            backend:
+              {{- if semverCompare ">=1.19-0" $.Capabilities.KubeVersion.GitVersion }}
+              service:
+                name: {{ $fullName }}
+                port:
+                  number: {{ $svcPort }}
+              {{- else }}
+              serviceName: {{ $fullName }}
+              servicePort: {{ $svcPort }}
+              {{- end }}
+          {{- end }}
+    {{- end }}
+{{- end }}

charts/goldpinger/templates/prometheusrule.yaml

@@ -0,0 +1,19 @@
+{{- if .Values.prometheusRule.enabled }}
+apiVersion: monitoring.coreos.com/v1
+kind: PrometheusRule
+metadata:
+  name: {{ template "goldpinger.fullname" . }}
+  {{- if .Values.prometheusRule.namespace }}
+  namespace: {{ .Values.prometheusRule.namespace }}
+  {{- else }}
+  namespace: {{ .Release.Namespace | quote }}
+  {{- end }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+spec:
+  {{- with .Values.prometheusRule.rules }}
+  groups:
+    - name: {{ template "goldpinger.name" $ }}
+      rules: {{- tpl (toYaml .) $ | nindent 8 }}
+  {{- end }}
+{{- end }}

charts/goldpinger/templates/role.yaml

@@ -0,0 +1,20 @@
+{{- if or .Values.podSecurityPolicy.enabled (not .Values.rbac.clusterscoped) }}
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: {{ include "goldpinger.fullname" . }}-pod-security-policy
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+rules:
+{{- if not .Values.rbac.clusterscoped }}
+  - apiGroups: [""]
+    resources: ["pods"]
+    verbs: ["list"]
+{{- end }}
+{{- if .Values.podSecurityPolicy.enabled }}
+  - apiGroups: ["extensions"]
+    resources: ["podsecuritypolicies"]
+    resourceNames: [{{ .Values.podSecurityPolicy.policyName | quote }}]
+    verbs: ["use"]
+{{- end }}
+{{- end }}

charts/goldpinger/templates/rolebinding.yaml

@@ -0,0 +1,16 @@
+{{- if or .Values.podSecurityPolicy.enabled (not .Values.rbac.clusterscoped) }}
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: {{ include "goldpinger.fullname" . }}-pod-security-policy
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+roleRef:
+  kind: Role
+  name: {{ include "goldpinger.fullname" . }}-pod-security-policy
+  apiGroup: rbac.authorization.k8s.io
+subjects:
+  - kind: ServiceAccount
+    name: {{ include "goldpinger.serviceAccountName" . }}
+    namespace: {{ .Release.Namespace }}
+{{- end }}

charts/goldpinger/templates/service.yaml

@@ -0,0 +1,26 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "goldpinger.fullname" . }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+{{- with .Values.service.labels }}
+{{ toYaml . | indent 4 }}
+{{- end }}
+{{- with .Values.service.annotations }}
+  annotations:
+{{ toYaml . | indent 4 }}
+{{- end }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+    - port: {{ .Values.service.port }}
+      targetPort: {{ .Values.goldpinger.port }}
+      protocol: TCP
+      name: http
+  selector:
+    {{- include "goldpinger.selectorLabels" . | nindent 4 }}
+  {{- if .Values.service.loadBalancerSourceRanges }}
+  loadBalancerSourceRanges:
+    {{- toYaml .Values.service.loadBalancerSourceRanges | nindent 4 }}
+  {{- end }}

charts/goldpinger/templates/serviceaccount.yaml

@@ -0,0 +1,8 @@
+{{- if .Values.serviceAccount.create }}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: {{ include "goldpinger.serviceAccountName" . }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+{{- end }}

charts/goldpinger/templates/servicemonitor.yaml

@@ -0,0 +1,32 @@
+{{- if .Values.serviceMonitor.enabled }}
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: {{ include "goldpinger.fullname" . }}
+  {{- if .Values.serviceMonitor.namespace }}
+  namespace: {{ .Values.serviceMonitor.namespace }}
+  {{- end }}
+  labels:
+    {{- include "goldpinger.labels" . | nindent 4 }}
+    {{- range $key, $value := .Values.serviceMonitor.selector }}
+    {{ $key }}: {{ $value | quote }}
+    {{- end }}
+spec:
+  endpoints:
+    - port: http
+      interval: {{ .Values.serviceMonitor.interval }}
+      {{- if .Values.serviceMonitor.honorLabels }}
+      honorLabels: true
+      {{- end }}
+      {{- with .Values.serviceMonitor.metricRelabelings }}
+      metricRelabelings:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+  jobLabel: name
+  namespaceSelector:
+    matchNames:
+      - {{ .Release.Namespace }}
+  selector:
+    matchLabels:
+      {{- include "goldpinger.selectorLabels" . | nindent 6 }}
+{{- end -}}

charts/goldpinger/values.yaml

@@ -0,0 +1,166 @@
+# Default values for goldpinger.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+image:
+  repository: bloomberg/goldpinger
+  # Overrides the image tag whose default is the chart appVersion.
+  tag: ""
+  pullPolicy: IfNotPresent
+  ## Optionally specify an array of imagePullSecrets.
+  ## Secrets must be manually created in the namespace.
+  ## ref: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/
+  ##
+  # pullSecrets:
+  #   - myRegistryKeySecretName
+
+rbac:
+  create: true
+  clusterscoped: true
+
+serviceAccount:
+  create: true
+  name:
+
+goldpinger:
+  port: 8080
+  zapConfig: |
+    {
+      "level": "info",
+      "encoding": "json",
+      "outputPaths": [
+          "stdout"
+      ],
+      "errorOutputPaths": [
+          "stderr"
+      ],
+      "initialFields": {
+      },
+      "encoderConfig": {
+          "messageKey": "message",
+          "levelKey": "level",
+          "levelEncoder": "lowercase",
+          "timeKey": "ts",
+          "timeEncoder": "ISO8601",
+          "callerKey": "caller",
+          "callerEncoder": "Short"
+      }
+    }
+
+extraEnv: []
+
+service:
+  type: ClusterIP
+  port: 8081
+  annotations: {}
+  labels: {}
+  loadBalancerSourceRanges: {}
+
+ingress:
+  enabled: false
+  className: ""
+  annotations: {}
+    # kubernetes.io/ingress.class: nginx
+    # kubernetes.io/tls-acme: "true"
+  hosts:
+    - host: chart-example.local
+      paths:
+        - path: /
+          pathType: ImplementationSpecific
+  tls: []
+  #  - secretName: chart-example-tls
+  #    hosts:
+  #      - chart-example.local
+
+## Set a priorityClassName for the pod. If left blank a default priority will be set.
+priorityClassName:
+
+resources: {}
+  # We usually recommend not to specify default resources and to leave this as a conscious
+  # choice for the user. This also increases chances charts run on environments with little
+  # resources, such as Minikube. If you do want to specify resources, uncomment the following
+  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
+  # limits:
+  #  cpu: 100m
+  #  memory: 128Mi
+  # requests:
+  #  cpu: 100m
+  #  memory: 128Mi
+
+podAnnotations: {}
+
+podLabels: {}
+
+updateStrategy: {}
+  # type: RollingUpdate
+  # rollingUpdate:
+  #   maxUnavailable: 1
+
+## Node labels for pod assignment
+## Ref: https://kubernetes.io/docs/user-guide/node-selection/
+##
+nodeSelector: {}
+
+## Tolerations for pod assignment
+## Ref: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
+##
+tolerations: []
+
+## Affinity for pod assignment
+## Ref: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#affinity-and-anti-affinity
+##
+affinity: {}
+
+## Enable this if pod security policy enabled in your cluster
+## It will bind ServiceAccount with unrestricted podSecurityPolicy
+## Ref: https://kubernetes.io/docs/concepts/policy/pod-security-policy/
+podSecurityPolicy:
+  enabled: false
+  policyName: unrestricted-psp
+
+## Set security context of the goldpinger container
+## Ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
+containerSecurityContext:
+  capabilities:
+    drop:
+      - ALL
+  allowPrivilegeEscalation: false
+  readOnlyRootFilesystem: true
+  runAsNonRoot: true
+
+## Set security context of the pod
+## Ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
+podSecurityContext:
+  runAsNonRoot: true
+  runAsUser: 1000
+  fsGroup: 2000
+  seccompProfile:
+    type: RuntimeDefault
+
+serviceMonitor:
+  enabled: false
+  selector:
+    prometheus: "kube-prometheus"
+  # namespace: monitoring
+  interval: 30s
+  # honorLabels: true
+  metricRelabelings: []
+  # - action: drop
+  #   source_labels: [__name__]
+  #   regex: goldpinger_peers_response_time_s_bucket
+
+## Custom PrometheusRule to be defined
+## ref: https://github.com/coreos/prometheus-operator#customresourcedefinitions
+prometheusRule:
+  enabled: false
+  rules:
+    - alert: goldpinger_nodes_unhealthy
+      expr: |
+        sum(goldpinger_nodes_health_total{job="{{ template "goldpinger.fullname" . }}", status="unhealthy"})
+        BY (instance, goldpinger_instance) > 0
+      for: 5m
+      annotations:
+        description: |
+          Goldpinger instance {{ "{{ $labels.goldpinger_instance }}" }} has been reporting unhealthy nodes for at least 5 minutes.
+        summary: Instance {{ "{{ $labels.instance }}" }} down
+      labels:
+        severity: warning

cmd/goldpinger/main.go

@@ -15,14 +15,21 @@
 package main
 
 import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
 	"os"
-	"strconv"
+	"strings"
+	"time"
 
 	"github.com/go-openapi/loads"
 	"go.uber.org/zap"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/utils/net"
 
 	"github.com/bloomberg/goldpinger/v3/pkg/goldpinger"
 	"github.com/bloomberg/goldpinger/v3/pkg/restapi"
@@ -35,37 +42,32 @@ var (
 	Version, Build string
 )
 
-func getLogger() *zap.Logger {
+func getLogger(zapconfigpath string) (*zap.Logger, error) {
 	var logger *zap.Logger
 	var err error
 
-	// We haven't parsed flags at this stage and that might be error prone
-	// so just use an envvar
-	if debug, err := strconv.ParseBool(os.Getenv("DEBUG")); err == nil && debug {
-		logger, err = zap.NewDevelopment()
-	} else {
-		logger, err = zap.NewProduction()
-	}
+	zapconfigJSON, err := ioutil.ReadFile(zapconfigpath)
 	if err != nil {
-		panic(err)
+		return nil, fmt.Errorf("Could not read zap config file: %w", err)
 	}
-	zap.ReplaceGlobals(logger)
-	return logger
+
+	var cfg zap.Config
+	if err := json.Unmarshal(zapconfigJSON, &cfg); err != nil {
+		return nil, fmt.Errorf("Could not read zap config as json: %w", err)
+	}
+	logger, err = cfg.Build()
+	if err != nil {
+		return nil, fmt.Errorf("Could not build zap config: %w", err)
+	}
+
+	return logger, nil
 }
 
 func main() {
-	logger := getLogger()
-	defer logger.Sync()
-
-	undo := zap.RedirectStdLog(logger)
-	defer undo()
-
-	logger.Info("Goldpinger", zap.String("version", Version), zap.String("build", Build))
-
 	// load embedded swagger file
 	swaggerSpec, err := loads.Analyzed(restapi.SwaggerJSON, "")
 	if err != nil {
-		logger.Error("Coud not parse swagger", zap.Error(err))
+		log.Fatalf("Could not parse swagger: %v", err)
 	}
 
 	// create new service API
@@ -82,7 +84,7 @@ func main() {
 	for _, optsGroup := range api.CommandLineOptionsGroups {
 		_, err := parser.AddGroup(optsGroup.ShortDescription, optsGroup.LongDescription, optsGroup.Options)
 		if err != nil {
-			logger.Error("Coud not add flag group", zap.Error(err))
+			log.Fatalf("Could not add flag group: %v", err)
 		}
 	}
 
@@ -96,6 +98,23 @@ func main() {
 		os.Exit(code)
 	}
 
+	// Configure logger
+	logger, err := getLogger(goldpinger.GoldpingerConfig.ZapConfigPath)
+	if err != nil {
+		var errDev error
+		logger, errDev = zap.NewDevelopment()
+		if errDev != nil {
+			log.Fatalf("Could not build a development logger: %v", errDev)
+		}
+		logger.Warn("Logger could not be built, defaulting to development settings", zap.String("error", fmt.Sprintf("%v", err)))
+	}
+	defer logger.Sync()
+
+	undo := zap.RedirectStdLog(logger)
+	defer undo()
+
+	logger.Info("Goldpinger", zap.String("version", Version), zap.String("build", Build))
+
 	if goldpinger.GoldpingerConfig.Namespace == nil {
 		goldpinger.GoldpingerConfig.Namespace = &goldpinger.PodNamespace
 	} else {
@@ -114,6 +133,10 @@ func main() {
 	if err != nil {
 		logger.Fatal("Error getting config ", zap.Error(err))
 	}
+	// communicate to kube-apiserver with protobuf
+	config.AcceptContentTypes = strings.Join([]string{runtime.ContentTypeProtobuf, runtime.ContentTypeJSON}, ",")
+	config.ContentType = runtime.ContentTypeProtobuf
+
 	// create the clientset
 	clientset, err := kubernetes.NewForConfig(config)
 	if err != nil {
@@ -132,6 +155,33 @@ func main() {
 	if goldpinger.GoldpingerConfig.PingNumber == 0 {
 		logger.Info("--ping-number set to 0: pinging all pods")
 	}
+	if goldpinger.GoldpingerConfig.IPVersions == nil || len(goldpinger.GoldpingerConfig.IPVersions) == 0 {
+		logger.Info("IPVersions not set: settings to 4 (IPv4)")
+		goldpinger.GoldpingerConfig.IPVersions = []string{"4"}
+	}
+	if len(goldpinger.GoldpingerConfig.IPVersions) > 1 {
+		logger.Warn("Multiple IP versions not supported. Will use first version specified as default", zap.Strings("IPVersions", goldpinger.GoldpingerConfig.IPVersions))
+	}
+	if goldpinger.GoldpingerConfig.IPVersions[0] != string(net.IPv4) && goldpinger.GoldpingerConfig.IPVersions[0] != string(net.IPv6) {
+		logger.Error("Unknown IP version specified: expected values are 4 or 6", zap.Strings("IPVersions", goldpinger.GoldpingerConfig.IPVersions))
+	}
+
+	// Handle deprecated flags
+	if int(goldpinger.GoldpingerConfig.PingTimeout) == 0 {
+		logger.Warn("ping-timeout-ms is deprecated in favor of ping-timeout and will be removed in the future",
+			zap.Int64("ping-timeout-ms", goldpinger.GoldpingerConfig.PingTimeoutMs))
+		goldpinger.GoldpingerConfig.PingTimeout = time.Duration(goldpinger.GoldpingerConfig.PingTimeoutMs) * time.Millisecond
+	}
+	if int(goldpinger.GoldpingerConfig.CheckTimeout) == 0 {
+		logger.Warn("check-timeout-ms is deprecated in favor of check-timeout and will be removed in the future",
+			zap.Int64("check-timeout-ms", goldpinger.GoldpingerConfig.CheckTimeoutMs))
+		goldpinger.GoldpingerConfig.CheckTimeout = time.Duration(goldpinger.GoldpingerConfig.CheckTimeoutMs) * time.Millisecond
+	}
+	if int(goldpinger.GoldpingerConfig.CheckAllTimeout) == 0 {
+		logger.Warn("check-all-timeout-ms is deprecated in favor of check-all-timeout will be removed in the future",
+			zap.Int64("check-all-timeout-ms", goldpinger.GoldpingerConfig.CheckAllTimeoutMs))
+		goldpinger.GoldpingerConfig.CheckAllTimeout = time.Duration(goldpinger.GoldpingerConfig.CheckAllTimeoutMs) * time.Millisecond
+	}
 
 	server.ConfigureAPI()
 	goldpinger.StartUpdater()

config/zap.json

@@ -0,0 +1,21 @@
+{
+    "level": "info",
+    "encoding": "json",
+    "outputPaths": [
+        "stdout"
+    ],
+    "errorOutputPaths": [
+        "stderr"
+    ],
+    "initialFields": {
+    },
+    "encoderConfig": {
+        "messageKey": "message",
+        "levelKey": "level",
+        "levelEncoder": "lowercase",
+        "timeKey": "ts",
+        "timeEncoder": "ISO8601",
+        "callerKey": "caller",
+        "callerEncoder": "Short"
+    }
+}

docker-bake.hcl

@@ -0,0 +1,52 @@
+# ref: https://docs.docker.com/build/bake/reference/
+
+# ref: https://github.com/docker/metadata-action?tab=readme-ov-file#bake-definition
+target "docker-metadata-action" {
+  tags = ["goldpinger:latest"]
+}
+
+group "default" {
+  targets = ["linux-simple"]
+}
+
+group "ci" {
+  targets = ["linux-simple", "linux-vendor", "windows-nanoserver-ltsc2019", "windows-nanoserver-ltsc2022"]
+}
+
+target "linux-simple" {
+  inherits = ["docker-metadata-action"]
+  tags = "${formatlist("%s-linux", target.docker-metadata-action.tags)}"
+  platforms = ["linux/amd64", "linux/arm64"]
+  target = "simple"
+}
+
+target "linux-vendor" {
+  inherits = ["docker-metadata-action"]
+  tags = "${formatlist("%s-vendor", target.docker-metadata-action.tags)}"
+  platforms = ["linux/amd64", "linux/arm64"]
+  target = "vendor"
+}
+
+target "windows-nanoserver-ltsc2019" {
+  inherits = ["docker-metadata-action"]
+  tags = "${formatlist("%s-windows-ltsc2019", target.docker-metadata-action.tags)}"
+
+  platforms = ["windows/amd64"]
+
+  target = "windows"
+  args = {
+    WINDOWS_BASE_IMAGE = "mcr.microsoft.com/windows/nanoserver:ltsc2019"
+  }
+}
+
+target "windows-nanoserver-ltsc2022" {
+  inherits = ["docker-metadata-action"]
+  tags = "${formatlist("%s-windows-ltsc2022", target.docker-metadata-action.tags)}"
+
+  platforms = ["windows/amd64"]
+
+  target = "windows"
+  args = {
+    WINDOWS_BASE_IMAGE = "mcr.microsoft.com/windows/nanoserver:ltsc2022"
+  }
+}

docker_deploy.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD" \
-    && make tag \
-    && make push \
-    && make vendor-tag \
-    && make vendor-push
-

extras/check_reachability.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+
+# This is a simple script, used in the Tilt GitHub Action
+# to validate that all worker nodes can inter-communicate.
+
+function print_help() {
+  echo "Usage: $0 [EXPECTED_HOST_COUNT]"
+  echo "Arguments:"
+  echo "  EXPECTED_HOST_COUNT: The number of expected hosts in the Goldpinger output."
+  echo "Examples:"
+  echo "  $0 2"
+}
+
+if [ "$#" -ne 1 ]; then
+  echo "Error: Invalid number of arguments."
+  print_help
+  exit 1
+fi
+
+if ! [[ $1 =~ ^[0-9]+$ ]]; then
+  echo "Error: EXPECTED_HOST_COUNT must be a number."
+  print_help
+  exit 1
+fi
+
+expected_host_count=$1
+goldpinger_output=""
+retry_count=0
+host_count=0
+
+while :; do
+  if [ "$retry_count" -ge 20 ]; then
+    echo "Error: Failed to fetch Goldpinger output after 10 attempts."
+    exit 1
+  fi
+  
+  echo "Sleeping for 8s..."
+  let retry_count++
+  sleep 8
+
+  echo "Attempt $((retry_count)) to fetch Goldpinger output."
+  goldpinger_output=$(curl -s http://localhost:8080/check_all)
+  echo "Goldpinger output: $goldpinger_output"
+
+  if [ "$goldpinger_output" == "null" ] || [ -z "$goldpinger_output" ]; then
+    echo "Goldpinger output is null or empty, retrying..."
+    continue
+  fi
+
+  host_count=$(echo "$goldpinger_output" | jq '.hosts | length')
+  if [ "$host_count" -ne "$expected_host_count" ]; then
+    echo "Goldpinger has not identified all hosts, retrying..."
+    continue
+  fi
+
+  for host in $(echo $goldpinger_output | jq -r '.responses | keys[]'); do
+    checksForPod=$(echo "$goldpinger_output" | jq -r --arg host "$host" '.responses[$host].response.podResults | length')
+    if [ "$checksForPod" -ne "$expected_host_count" ]; then
+      echo "Check for $host is not OK, retrying..."
+      continue 2
+    fi
+  done
+
+  break
+done
+
+all_hosts_can_talk=true
+for host in $(echo $goldpinger_output | jq -r '.responses | keys[]'); do
+  for target in $(echo $goldpinger_output | jq -r --arg host $host '.responses[$host].response.podResults | keys[]'); do
+    ok=$(echo $goldpinger_output | jq -r --arg host $host --arg target $target '.responses[$host].response.podResults[$target].OK')
+    if [ "$ok" != "true" ]; then
+      all_hosts_can_talk=false
+      break 2
+    fi
+  done
+done
+
+if [[ $host_count -eq $expected_host_count ]] && [[ $all_hosts_can_talk == "true" ]]; then
+  echo "Validation successful. There are $expected_host_count hosts and they can talk to each other."
+else
+  echo "Validation failed. Expected $expected_host_count hosts but found $host_count, or not all hosts can talk to each other."
+  echo "Goldpinger Output: $goldpinger_output"
+  exit 1
+fi

extras/example-serviceaccounts.yml

@@ -102,7 +102,7 @@ rules:
   - list
 
 ---
-apiVersion: rbac.authorization.k8s.io/v1beta1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
   name: goldpinger-clusterrolebinding

go.mod

@@ -1,50 +1,97 @@
 module github.com/bloomberg/goldpinger/v3
 
-go 1.14
+go 1.25.0
 
 require (
-	github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 // indirect
 	github.com/cespare/xxhash v1.1.0
-	github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680 // indirect
-	github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8 // indirect
-	github.com/go-openapi/analysis v0.17.2 // indirect
-	github.com/go-openapi/errors v0.17.2
-	github.com/go-openapi/jsonpointer v0.17.2 // indirect
-	github.com/go-openapi/jsonreference v0.17.2 // indirect
-	github.com/go-openapi/loads v0.17.2
-	github.com/go-openapi/runtime v0.17.2
-	github.com/go-openapi/spec v0.17.2
-	github.com/go-openapi/strfmt v0.17.2
-	github.com/go-openapi/swag v0.17.2
-	github.com/go-openapi/validate v0.17.2
-	github.com/gogo/protobuf v0.0.0-20170330071051-c0656edd0d9e // indirect
-	github.com/golang/glog v0.0.0-20141105023935-44145f04b68c // indirect
-	github.com/google/btree v1.0.0 // indirect
-	github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367 // indirect
-	github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d // indirect
-	github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7 // indirect
-	github.com/imdario/mergo v0.3.5 // indirect
-	github.com/jessevdk/go-flags v1.4.0
-	github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 // indirect
-	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
-	github.com/prometheus/client_golang v0.9.1
-	github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 // indirect
-	github.com/prometheus/common v0.0.0-20181020173914-7e9e6cabbd39 // indirect
-	github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d // indirect
-	github.com/spf13/pflag v1.0.1 // indirect
+	github.com/go-openapi/errors v0.22.6
+	github.com/go-openapi/loads v0.23.2
+	github.com/go-openapi/runtime v0.29.2
+	github.com/go-openapi/spec v0.22.3
+	github.com/go-openapi/strfmt v0.25.0
+	github.com/go-openapi/swag v0.25.4
+	github.com/go-openapi/validate v0.25.1
+	github.com/jessevdk/go-flags v1.6.1
+	github.com/prometheus/client_golang v1.23.2
 	github.com/stuartnelson3/go-rendezvous v0.2.0
-	go.uber.org/zap v1.14.1
-	golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 // indirect
-	golang.org/x/image v0.0.0-20190220214146-31aff87c08e9
-	golang.org/x/net v0.0.0-20200226121028-0de0cce0169b
-	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d // indirect
-	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a // indirect
-	golang.org/x/time v0.0.0-20161028155119-f51c12702a4d // indirect
-	gopkg.in/inf.v0 v0.9.0 // indirect
-	k8s.io/api v0.0.0-20181004124137-fd83cbc87e76 // indirect
-	k8s.io/apimachinery v0.0.0-20180913025736-6dd46049f395
-	k8s.io/client-go v9.0.0+incompatible
+	go.uber.org/zap v1.27.1
+	golang.org/x/image v0.35.0
+	golang.org/x/net v0.49.0
+	k8s.io/api v0.35.0
+	k8s.io/apimachinery v0.35.0
+	k8s.io/client-go v0.35.0
+	k8s.io/utils v0.0.0-20260108192941-914a6e750570
+)
+
+require (
+	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
+	github.com/emicklei/go-restful/v3 v3.13.0 // indirect
+	github.com/fxamacker/cbor/v2 v2.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-openapi/analysis v0.24.2 // indirect
+	github.com/go-openapi/jsonpointer v0.22.4 // indirect
+	github.com/go-openapi/jsonreference v0.21.4 // indirect
+	github.com/go-openapi/swag/cmdutils v0.25.4 // indirect
+	github.com/go-openapi/swag/conv v0.25.4 // indirect
+	github.com/go-openapi/swag/fileutils v0.25.4 // indirect
+	github.com/go-openapi/swag/jsonname v0.25.4 // indirect
+	github.com/go-openapi/swag/jsonutils v0.25.4 // indirect
+	github.com/go-openapi/swag/loading v0.25.4 // indirect
+	github.com/go-openapi/swag/mangling v0.25.4 // indirect
+	github.com/go-openapi/swag/netutils v0.25.4 // indirect
+	github.com/go-openapi/swag/stringutils v0.25.4 // indirect
+	github.com/go-openapi/swag/typeutils v0.25.4 // indirect
+	github.com/go-openapi/swag/yamlutils v0.25.4 // indirect
+	github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/google/gnostic-models v0.7.1 // indirect
+	github.com/google/gofuzz v1.2.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/imdario/mergo v0.3.16 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/mailru/easyjson v0.9.1 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/oklog/ulid v1.3.1 // indirect
+	github.com/opentracing/opentracing-go v1.2.0 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/procfs v0.19.2 // indirect
+	github.com/spf13/pflag v1.0.10 // indirect
+	github.com/x448/float16 v0.8.4 // indirect
+	go.mongodb.org/mongo-driver v1.17.7 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/otel v1.39.0 // indirect
+	go.opentelemetry.io/otel/metric v1.39.0 // indirect
+	go.opentelemetry.io/otel/trace v1.39.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.3 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/oauth2 v0.34.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/term v0.39.0 // indirect
+	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
+	gopkg.in/evanphx/json-patch.v4 v4.13.0 // indirect
+	gopkg.in/inf.v0 v0.9.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	k8s.io/klog/v2 v2.130.1 // indirect
+	k8s.io/kube-openapi v0.0.0-20260127142750-a19766b6e2d4 // indirect
+	sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect
+	sigs.k8s.io/randfill v1.0.0 // indirect
+	sigs.k8s.io/structured-merge-diff/v4 v4.7.0 // indirect
+	sigs.k8s.io/structured-merge-diff/v6 v6.3.1 // indirect
+	sigs.k8s.io/yaml v1.6.0 // indirect
 )

go.sum

@@ -1,189 +1,337 @@
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/PuerkitoBio/purell v1.1.0 h1:rmGxhojJlM0tuKtfdvliR84CFHljx9ag64t2xmVkjK4=
-github.com/PuerkitoBio/purell v1.1.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
-github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf h1:eg0MeVzsP1G42dRafH3vf+al2vQIJU0YHX+1Tw87oco=
-github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
+github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/docker/go-units v0.3.3 h1:Xk8S3Xj5sLGlG5g67hJmYMmUgXv5N4PhkjJHHqrwnTk=
-github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680 h1:ZktWZesgun21uEDrwW7iEV1zPCGQldM2atlJZ3TdvVM=
-github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q=
-github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8 h1:DujepqpGd1hyOd7aW59XpK7Qymp8iy83xq74fLr21is=
-github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q=
-github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI=
-github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik=
-github.com/go-openapi/analysis v0.17.2 h1:eYp14J1o8TTSCzndHBtsNuckikV1PfZOSnx4BcBeu0c=
-github.com/go-openapi/analysis v0.17.2/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik=
-github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
-github.com/go-openapi/errors v0.17.2 h1:azEQ8Fnx0jmtFF2fxsnmd6I0x6rsweUF63qqSO1NmKk=
-github.com/go-openapi/errors v0.17.2/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
-github.com/go-openapi/jsonpointer v0.17.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M=
-github.com/go-openapi/jsonpointer v0.17.2 h1:3ekBy41gar/iJi2KSh/au/PrC2vpLr85upF/UZmm3W0=
-github.com/go-openapi/jsonpointer v0.17.2/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M=
-github.com/go-openapi/jsonreference v0.17.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I=
-github.com/go-openapi/jsonreference v0.17.2 h1:lF3z7AH8dd0IKXc1zEBi1dj0B4XgVb5cVjn39dCK3Ls=
-github.com/go-openapi/jsonreference v0.17.2/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I=
-github.com/go-openapi/loads v0.17.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU=
-github.com/go-openapi/loads v0.17.2 h1:tEXYu6Xc0pevpzzQx5ghrMN9F7IVpN/+u4iD3rkYE5o=
-github.com/go-openapi/loads v0.17.2/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU=
-github.com/go-openapi/runtime v0.0.0-20180920151709-4f900dc2ade9/go.mod h1:6v9a6LTXWQCdL8k1AO3cvqx5OtZY/Y9wKTgaoP6YRfA=
-github.com/go-openapi/runtime v0.17.2 h1:/ZK67ikFhQAMFFH/aPu2MaGH7QjP4wHBvHYOVIzDAw0=
-github.com/go-openapi/runtime v0.17.2/go.mod h1:QO936ZXeisByFmZEO1IS1Dqhtf4QV1sYYFtIq6Ld86Q=
-github.com/go-openapi/spec v0.17.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI=
-github.com/go-openapi/spec v0.17.2 h1:eb2NbuCnoe8cWAxhtK6CfMWUYmiFEZJ9Hx3Z2WRwJ5M=
-github.com/go-openapi/spec v0.17.2/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI=
-github.com/go-openapi/strfmt v0.17.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU=
-github.com/go-openapi/strfmt v0.17.2 h1:2KDns36DMHXG9/iYkOjiX+/8fKK9GCU5ELZ+J6qcRVA=
-github.com/go-openapi/strfmt v0.17.2/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU=
-github.com/go-openapi/swag v0.17.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg=
-github.com/go-openapi/swag v0.17.2 h1:K/ycE/XTUDFltNHSO32cGRUhrVGJD64o8WgAIZNyc3k=
-github.com/go-openapi/swag v0.17.2/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg=
-github.com/go-openapi/validate v0.17.0/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4=
-github.com/go-openapi/validate v0.17.2 h1:lwFfiS4sv5DvOrsYDsYq4N7UU8ghXiYtPJ+VcQnC3Xg=
-github.com/go-openapi/validate v0.17.2/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4=
-github.com/gogo/protobuf v0.0.0-20170330071051-c0656edd0d9e h1:ago6fNuQ6IhszPsXkeU7qRCyfsIX7L67WDybsAPkLl8=
-github.com/gogo/protobuf v0.0.0-20170330071051-c0656edd0d9e/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/glog v0.0.0-20141105023935-44145f04b68c h1:CbdkBQ1/PiAo0FYJhQGwASD8wrgNvTdf01g6+O9tNuA=
-github.com/golang/glog v0.0.0-20141105023935-44145f04b68c/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367 h1:ScAXWS+TR6MZKex+7Z8rneuSJH+FSDqd6ocQyl+ZHo4=
-github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d h1:7XGaL1e6bYS1yIonGp9761ExpPPV1ui0SAC59Yube9k=
-github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
-github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7 h1:6TSoaYExHper8PYsJu23GWVNOyYRCSnIFyxKgLSZ54w=
-github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
-github.com/imdario/mergo v0.3.5 h1:JboBksRwiiAJWvIYJVo46AfV+IAIKZpfrSzVKj42R4Q=
-github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
-github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
-github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3 h1:/UewZcckqhvnnS0C6r3Sher2hSEbVmM6Ogpcjen08+Y=
-github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/emicklei/go-restful/v3 v3.12.0 h1:y2DdzBAURM29NFF94q6RaY4vjIH1rtwDapwQtU84iWk=
+github.com/emicklei/go-restful/v3 v3.12.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
+github.com/emicklei/go-restful/v3 v3.13.0 h1:C4Bl2xDndpU6nJ4bc1jXd+uTmYPVUwkD6bFY/oTyCes=
+github.com/emicklei/go-restful/v3 v3.13.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
+github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
+github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-openapi/analysis v0.23.0 h1:aGday7OWupfMs+LbmLZG4k0MYXIANxcuBTYUC03zFCU=
+github.com/go-openapi/analysis v0.23.0/go.mod h1:9mz9ZWaSlV8TvjQHLl2mUW2PbZtemkE8yA5v22ohupo=
+github.com/go-openapi/analysis v0.24.2 h1:6p7WXEuKy1llDgOH8FooVeO+Uq2za9qoAOq4ZN08B50=
+github.com/go-openapi/analysis v0.24.2/go.mod h1:x27OOHKANE0lutg2ml4kzYLoHGMKgRm1Cj2ijVOjJuE=
+github.com/go-openapi/errors v0.22.0 h1:c4xY/OLxUBSTiepAg3j/MHuAv5mJhnf53LLMWFB+u/w=
+github.com/go-openapi/errors v0.22.0/go.mod h1:J3DmZScxCDufmIMsdOuDHxJbdOGC0xtUynjIx092vXE=
+github.com/go-openapi/errors v0.22.6 h1:eDxcf89O8odEnohIXwEjY1IB4ph5vmbUsBMsFNwXWPo=
+github.com/go-openapi/errors v0.22.6/go.mod h1:z9S8ASTUqx7+CP1Q8dD8ewGH/1JWFFLX/2PmAYNQLgk=
+github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
+github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
+github.com/go-openapi/jsonpointer v0.22.4 h1:dZtK82WlNpVLDW2jlA1YCiVJFVqkED1MegOUy9kR5T4=
+github.com/go-openapi/jsonpointer v0.22.4/go.mod h1:elX9+UgznpFhgBuaMQ7iu4lvvX1nvNsesQ3oxmYTw80=
+github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ=
+github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4=
+github.com/go-openapi/jsonreference v0.21.4 h1:24qaE2y9bx/q3uRK/qN+TDwbok1NhbSmGjjySRCHtC8=
+github.com/go-openapi/jsonreference v0.21.4/go.mod h1:rIENPTjDbLpzQmQWCj5kKj3ZlmEh+EFVbz3RTUh30/4=
+github.com/go-openapi/loads v0.22.0 h1:ECPGd4jX1U6NApCGG1We+uEozOAvXvJSF4nnwHZ8Aco=
+github.com/go-openapi/loads v0.22.0/go.mod h1:yLsaTCS92mnSAZX5WWoxszLj0u+Ojl+Zs5Stn1oF+rs=
+github.com/go-openapi/loads v0.23.2 h1:rJXAcP7g1+lWyBHC7iTY+WAF0rprtM+pm8Jxv1uQJp4=
+github.com/go-openapi/loads v0.23.2/go.mod h1:IEVw1GfRt/P2Pplkelxzj9BYFajiWOtY2nHZNj4UnWY=
+github.com/go-openapi/runtime v0.28.0 h1:gpPPmWSNGo214l6n8hzdXYhPuJcGtziTOgUpvsFWGIQ=
+github.com/go-openapi/runtime v0.28.0/go.mod h1:QN7OzcS+XuYmkQLw05akXk0jRH/eZ3kb18+1KwW9gyc=
+github.com/go-openapi/runtime v0.29.2 h1:UmwSGWNmWQqKm1c2MGgXVpC2FTGwPDQeUsBMufc5Yj0=
+github.com/go-openapi/runtime v0.29.2/go.mod h1:biq5kJXRJKBJxTDJXAa00DOTa/anflQPhT0/wmjuy+0=
+github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY=
+github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk=
+github.com/go-openapi/spec v0.22.3 h1:qRSmj6Smz2rEBxMnLRBMeBWxbbOvuOoElvSvObIgwQc=
+github.com/go-openapi/spec v0.22.3/go.mod h1:iIImLODL2loCh3Vnox8TY2YWYJZjMAKYyLH2Mu8lOZs=
+github.com/go-openapi/strfmt v0.23.0 h1:nlUS6BCqcnAk0pyhi9Y+kdDVZdZMHfEKQiS4HaMgO/c=
+github.com/go-openapi/strfmt v0.23.0/go.mod h1:NrtIpfKtWIygRkKVsxh7XQMDQW5HKQl6S5ik2elW+K4=
+github.com/go-openapi/strfmt v0.25.0 h1:7R0RX7mbKLa9EYCTHRcCuIPcaqlyQiWNPTXwClK0saQ=
+github.com/go-openapi/strfmt v0.25.0/go.mod h1:nNXct7OzbwrMY9+5tLX4I21pzcmE6ccMGXl3jFdPfn8=
+github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
+github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
+github.com/go-openapi/swag v0.25.4 h1:OyUPUFYDPDBMkqyxOTkqDYFnrhuhi9NR6QVUvIochMU=
+github.com/go-openapi/swag v0.25.4/go.mod h1:zNfJ9WZABGHCFg2RnY0S4IOkAcVTzJ6z2Bi+Q4i6qFQ=
+github.com/go-openapi/swag/cmdutils v0.25.4 h1:8rYhB5n6WawR192/BfUu2iVlxqVR9aRgGJP6WaBoW+4=
+github.com/go-openapi/swag/cmdutils v0.25.4/go.mod h1:pdae/AFo6WxLl5L0rq87eRzVPm/XRHM3MoYgRMvG4A0=
+github.com/go-openapi/swag/conv v0.25.4 h1:/Dd7p0LZXczgUcC/Ikm1+YqVzkEeCc9LnOWjfkpkfe4=
+github.com/go-openapi/swag/conv v0.25.4/go.mod h1:3LXfie/lwoAv0NHoEuY1hjoFAYkvlqI/Bn5EQDD3PPU=
+github.com/go-openapi/swag/fileutils v0.25.4 h1:2oI0XNW5y6UWZTC7vAxC8hmsK/tOkWXHJQH4lKjqw+Y=
+github.com/go-openapi/swag/fileutils v0.25.4/go.mod h1:cdOT/PKbwcysVQ9Tpr0q20lQKH7MGhOEb6EwmHOirUk=
+github.com/go-openapi/swag/jsonname v0.25.4 h1:bZH0+MsS03MbnwBXYhuTttMOqk+5KcQ9869Vye1bNHI=
+github.com/go-openapi/swag/jsonname v0.25.4/go.mod h1:GPVEk9CWVhNvWhZgrnvRA6utbAltopbKwDu8mXNUMag=
+github.com/go-openapi/swag/jsonutils v0.25.4 h1:VSchfbGhD4UTf4vCdR2F4TLBdLwHyUDTd1/q4i+jGZA=
+github.com/go-openapi/swag/jsonutils v0.25.4/go.mod h1:7OYGXpvVFPn4PpaSdPHJBtF0iGnbEaTk8AvBkoWnaAY=
+github.com/go-openapi/swag/loading v0.25.4 h1:jN4MvLj0X6yhCDduRsxDDw1aHe+ZWoLjW+9ZQWIKn2s=
+github.com/go-openapi/swag/loading v0.25.4/go.mod h1:rpUM1ZiyEP9+mNLIQUdMiD7dCETXvkkC30z53i+ftTE=
+github.com/go-openapi/swag/mangling v0.25.4 h1:2b9kBJk9JvPgxr36V23FxJLdwBrpijI26Bx5JH4Hp48=
+github.com/go-openapi/swag/mangling v0.25.4/go.mod h1:6dxwu6QyORHpIIApsdZgb6wBk/DPU15MdyYj/ikn0Hg=
+github.com/go-openapi/swag/netutils v0.25.4 h1:Gqe6K71bGRb3ZQLusdI8p/y1KLgV4M/k+/HzVSqT8H0=
+github.com/go-openapi/swag/netutils v0.25.4/go.mod h1:m2W8dtdaoX7oj9rEttLyTeEFFEBvnAx9qHd5nJEBzYg=
+github.com/go-openapi/swag/stringutils v0.25.4 h1:O6dU1Rd8bej4HPA3/CLPciNBBDwZj9HiEpdVsb8B5A8=
+github.com/go-openapi/swag/stringutils v0.25.4/go.mod h1:GTsRvhJW5xM5gkgiFe0fV3PUlFm0dr8vki6/VSRaZK0=
+github.com/go-openapi/swag/typeutils v0.25.4 h1:1/fbZOUN472NTc39zpa+YGHn3jzHWhv42wAJSN91wRw=
+github.com/go-openapi/swag/typeutils v0.25.4/go.mod h1:Ou7g//Wx8tTLS9vG0UmzfCsjZjKhpjxayRKTHXf2pTE=
+github.com/go-openapi/swag/yamlutils v0.25.4 h1:6jdaeSItEUb7ioS9lFoCZ65Cne1/RZtPBZ9A56h92Sw=
+github.com/go-openapi/swag/yamlutils v0.25.4/go.mod h1:MNzq1ulQu+yd8Kl7wPOut/YHAAU/H6hL91fF+E2RFwc=
+github.com/go-openapi/validate v0.24.0 h1:LdfDKwNbpB6Vn40xhTdNZAnfLECL81w+VX3BumrGD58=
+github.com/go-openapi/validate v0.24.0/go.mod h1:iyeX1sEufmv3nPbBdX3ieNviWnOZaJ1+zquzJEf2BAQ=
+github.com/go-openapi/validate v0.25.1 h1:sSACUI6Jcnbo5IWqbYHgjibrhhmt3vR6lCzKZnmAgBw=
+github.com/go-openapi/validate v0.25.1/go.mod h1:RMVyVFYte0gbSTaZ0N4KmTn6u/kClvAFp+mAVfS/DQc=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=
+github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I=
+github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U=
+github.com/google/gnostic-models v0.7.1 h1:SisTfuFKJSKM5CPZkffwi6coztzzeYUhc3v4yxLWH8c=
+github.com/google/gnostic-models v0.7.1/go.mod h1:whL5G0m6dmc5cPxKc5bdKdEN3UjI7OUGxBlw57miDrQ=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v1.0.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/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJYCmNdQXq6neHJOYx3V6jnqNEec=
+github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4=
+github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
+github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc=
+github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
+github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4=
+github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329 h1:2gxZ0XQIU/5z3Z3bUBu+FXuk2pFbkN6tcwi/pjyaDic=
-github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-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/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mailru/easyjson v0.9.1 h1:LbtsOm5WAswyWbvTEOqhypdPeZzHavpZx96/n553mR8=
+github.com/mailru/easyjson v0.9.1/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+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 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/pborman/uuid v1.2.0 h1:J7Q5mO4ysT1dv8hyrUGHb9+ooztCXu1D8MY8DZYsu3g=
-github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
-github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
-github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8=
+github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/onsi/ginkgo/v2 v2.13.0 h1:0jY9lJquiL8fcf3M4LAXN5aMlS/b2BV86HFFPCPMgE4=
+github.com/onsi/ginkgo/v2 v2.13.0/go.mod h1:TE309ZR8s5FsKKpuB1YAQYBzCaAfUgatB/xlT/ETL/o=
+github.com/onsi/ginkgo/v2 v2.27.2 h1:LzwLj0b89qtIy6SSASkzlNvX6WktqurSHwkk2ipF/Ns=
+github.com/onsi/gomega v1.29.0 h1:KIA/t2t5UBzoirT4H9tsML45GEbo3ouUnBHsCfD2tVg=
+github.com/onsi/gomega v1.29.0/go.mod h1:9sxs+SwGrKI0+PWe4Fxa9tFQQBG5xSsSbMXOI8PPpoQ=
+github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
+github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1 h1:K47Rk0v/fkEfwfQet2KWhscE0cJzjgCCDBG2KHZoVno=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/common v0.0.0-20181020173914-7e9e6cabbd39 h1:Cto4X6SVMWRPBkJ/3YHn1iDGDGc/Z+sW+AEMKHMVvN4=
-github.com/prometheus/common v0.0.0-20181020173914-7e9e6cabbd39/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d h1:GoAlyOgbOEIFdaDqxJVlbOQ1DtGmZWs/Qau0hIlk+WQ=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
+github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
+github.com/prometheus/common v0.52.3 h1:5f8uj6ZwHSscOGNdIQg6OiZv/ybiK2CO2q2drVZAQSA=
+github.com/prometheus/common v0.52.3/go.mod h1:BrxBKv3FWBIGXw89Mg1AeBq7FSyRzXWI3l3e7W3RN5U=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
+github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
+github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws=
+github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-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/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-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.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/stuartnelson3/go-rendezvous v0.2.0 h1:H5IexrsptBzCMQEjTRrNH20MVXGqpFf1JUCPglaxd6I=
 github.com/stuartnelson3/go-rendezvous v0.2.0/go.mod h1:njfgP6zISyRnZ3iQN13NSEILfSNLN4ysxBoGxHs5PJ0=
-go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk=
-go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A=
-go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.14.1 h1:nYDKopTbvAPq/NrUVZwT15y2lpROBiLLyoRTbXOYWOo=
-go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUSLc=
+go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
+go.mongodb.org/mongo-driver v1.17.7 h1:a9w+U3Vt67eYzcfq3k/OAv284/uUUkL0uP75VE5rCOU=
+go.mongodb.org/mongo-driver v1.17.7/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/otel v1.25.0 h1:gldB5FfhRl7OJQbUHt/8s0a7cE8fbsPAtdpRaApKy4k=
+go.opentelemetry.io/otel v1.25.0/go.mod h1:Wa2ds5NOXEMkCmUou1WA7ZBfLTHWIsp034OVD7AO+Vg=
+go.opentelemetry.io/otel v1.39.0 h1:8yPrr/S0ND9QEfTfdP9V+SiwT4E0G7Y5MO7p85nis48=
+go.opentelemetry.io/otel v1.39.0/go.mod h1:kLlFTywNWrFyEdH0oj2xK0bFYZtHRYUdv1NklR/tgc8=
+go.opentelemetry.io/otel/metric v1.25.0 h1:LUKbS7ArpFL/I2jJHdJcqMGxkRdxpPHE0VU/D4NuEwA=
+go.opentelemetry.io/otel/metric v1.25.0/go.mod h1:rkDLUSd2lC5lq2dFNrX9LGAbINP5B7WBkC78RXCpH5s=
+go.opentelemetry.io/otel/metric v1.39.0 h1:d1UzonvEZriVfpNKEVmHXbdf909uGTOQjA0HF0Ls5Q0=
+go.opentelemetry.io/otel/metric v1.39.0/go.mod h1:jrZSWL33sD7bBxg1xjrqyDjnuzTUB0x1nBERXd7Ftcs=
+go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
+go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg=
+go.opentelemetry.io/otel/trace v1.25.0 h1:tqukZGLwQYRIFtSQM2u2+yfMVTgGVeqRLPUYx1Dq6RM=
+go.opentelemetry.io/otel/trace v1.25.0/go.mod h1:hCCs70XM/ljO+BeQkyFnbK28SBIJ/Emuha+ccrCRT7I=
+go.opentelemetry.io/otel/trace v1.39.0 h1:2d2vfpEDmCJ5zVYz7ijaJdOF59xLomrvj7bjt6/qCJI=
+go.opentelemetry.io/otel/trace v1.39.0/go.mod h1:88w4/PnZSazkGzz/w84VHpQafiU4EtqqlVdxWy+rNOA=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc=
+go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
+go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 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-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/image v0.0.0-20190220214146-31aff87c08e9 h1:+vH8qNweCrORN49012OX3h0oWEXO3p+rRnpAGQinddk=
-golang.org/x/image v0.0.0-20190220214146-31aff87c08e9/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-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/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/image v0.21.0 h1:c5qV36ajHpdj4Qi0GnE0jUc/yuo33OLFaa0d+crTD5s=
+golang.org/x/image v0.21.0/go.mod h1:vUbsLavqK/W303ZroQQVKQ+Af3Yl6Uz1Ppu5J/cLz78=
+golang.org/x/image v0.35.0 h1:LKjiHdgMtO8z7Fh18nGY6KDcoEtVfsgLDPeLyguqb7I=
+golang.org/x/image v0.35.0/go.mod h1:MwPLTVgvxSASsxdLzKrl8BRFuyqMyGhLwmC+TO1Sybk=
+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/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b h1:0mm1VjtFUOIlE1SbDlwjYaDxZVDP2S5ou6y0gSgXHu8=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w=
+golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/oauth2 v0.19.0 h1:9+E/EZBCbTLNrbN35fHv/a/d/mOBatymz1zbtQrXpIg=
+golang.org/x/oauth2 v0.19.0/go.mod h1:vYi7skDa1x015PmRRYZ7+s1cWyPgrPiSYRe4rnsexc8=
+golang.org/x/oauth2 v0.34.0 h1:hqK/t4AKgbqWkdkcAeI8XLmbK+4m4G5YeQRrmiotGlw=
+golang.org/x/oauth2 v0.34.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a h1:WXEvlFVvvGxCJLG6REjsT03iWnKLEWinaScsxF2Vm2o=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
+golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
+golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/time v0.0.0-20161028155119-f51c12702a4d h1:TnM+PKb3ylGmZvyPXmo9m/wktg7Jn/a/fNmr33HSj8g=
-golang.org/x/time v0.0.0-20161028155119-f51c12702a4d/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5 h1:hKsoRgsbwY1NafxrwTs+k64bikrLBkAgPir1TNCj3Zs=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-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=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/inf.v0 v0.9.0 h1:3zYtXIO92bvsdS3ggAdA8Gb4Azj0YU+TVY1uGYNFA8o=
-gopkg.in/inf.v0 v0.9.0/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
-gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-k8s.io/api v0.0.0-20181004124137-fd83cbc87e76 h1:cGc6jt7tNK7a2WfgNKjxjoU/UXXr9Q7JTqvCupZ+6+Y=
-k8s.io/api v0.0.0-20181004124137-fd83cbc87e76/go.mod h1:iuAfoD4hCxJ8Onx9kaTIt30j7jUFS00AXQi6QMi99vA=
-k8s.io/apimachinery v0.0.0-20180913025736-6dd46049f395 h1:X+c9tYTDc9Pmt+Z1YSMqmUTCYf13VYe1u+ZwzjgpK0M=
-k8s.io/apimachinery v0.0.0-20180913025736-6dd46049f395/go.mod h1:ccL7Eh7zubPUSh9A3USN90/OzHNSVN6zxzde07TDCL0=
-k8s.io/client-go v9.0.0+incompatible h1:2kqW3X2xQ9SbFvWZjGEHBLlWc1LG9JIJNXWkuqwdZ3A=
-k8s.io/client-go v9.0.0+incompatible/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/evanphx/json-patch.v4 v4.13.0 h1:czT3CmqEaQ1aanPc5SdlgQrrEIb8w/wwCvWWnfEbYzo=
+gopkg.in/evanphx/json-patch.v4 v4.13.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+k8s.io/api v0.29.3 h1:2ORfZ7+bGC3YJqGpV0KSDDEVf8hdGQ6A03/50vj8pmw=
+k8s.io/api v0.29.3/go.mod h1:y2yg2NTyHUUkIoTC+phinTnEa3KFM6RZ3szxt014a80=
+k8s.io/api v0.35.0 h1:iBAU5LTyBI9vw3L5glmat1njFK34srdLmktWwLTprlY=
+k8s.io/api v0.35.0/go.mod h1:AQ0SNTzm4ZAczM03QH42c7l3bih1TbAXYo0DkF8ktnA=
+k8s.io/apimachinery v0.29.3 h1:2tbx+5L7RNvqJjn7RIuIKu9XTsIZ9Z5wX2G22XAa5EU=
+k8s.io/apimachinery v0.29.3/go.mod h1:hx/S4V2PNW4OMg3WizRrHutyB5la0iCUbZym+W0EQIU=
+k8s.io/apimachinery v0.35.0 h1:Z2L3IHvPVv/MJ7xRxHEtk6GoJElaAqDCCU0S6ncYok8=
+k8s.io/apimachinery v0.35.0/go.mod h1:jQCgFZFR1F4Ik7hvr2g84RTJSZegBc8yHgFWKn//hns=
+k8s.io/client-go v0.29.3 h1:R/zaZbEAxqComZ9FHeQwOh3Y1ZUs7FaHKZdQtIc2WZg=
+k8s.io/client-go v0.29.3/go.mod h1:tkDisCvgPfiRpxGnOORfkljmS+UrW+WtXAy2fTvXJB0=
+k8s.io/client-go v0.35.0 h1:IAW0ifFbfQQwQmga0UdoH0yvdqrbwMdq9vIFEhRpxBE=
+k8s.io/client-go v0.35.0/go.mod h1:q2E5AAyqcbeLGPdoRB+Nxe3KYTfPce1Dnu1myQdqz9o=
+k8s.io/klog/v2 v2.120.1 h1:QXU6cPEOIslTGvZaXvFWiP9VKyeet3sawzTOvdXb4Vw=
+k8s.io/klog/v2 v2.120.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=
+k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk=
+k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=
+k8s.io/kube-openapi v0.0.0-20240411171206-dc4e619f62f3 h1:SbdLaI6mM6ffDSJCadEaD4IkuPzepLDGlkd2xV0t1uA=
+k8s.io/kube-openapi v0.0.0-20240411171206-dc4e619f62f3/go.mod h1:yD4MZYeKMBwQKVht279WycxKyM84kkAx2DPrTXaeb98=
+k8s.io/kube-openapi v0.0.0-20260127142750-a19766b6e2d4 h1:HhDfevmPS+OalTjQRKbTHppRIz01AWi8s45TMXStgYY=
+k8s.io/kube-openapi v0.0.0-20260127142750-a19766b6e2d4/go.mod h1:kdmbQkyfwUagLfXIad1y2TdrjPFWp2Q89B3qkRwf/pQ=
+k8s.io/utils v0.0.0-20240310230437-4693a0247e57 h1:gbqbevonBh57eILzModw6mrkbwM0gQBEuevE/AaBsHY=
+k8s.io/utils v0.0.0-20240310230437-4693a0247e57/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
+k8s.io/utils v0.0.0-20260108192941-914a6e750570 h1:JT4W8lsdrGENg9W+YwwdLJxklIuKWdRm+BC+xt33FOY=
+k8s.io/utils v0.0.0-20260108192941-914a6e750570/go.mod h1:xDxuJ0whA3d0I4mf/C4ppKHxXynQ+fxnkmQH0vTHnuk=
+sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo=
+sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0=
+sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 h1:IpInykpT6ceI+QxKBbEflcR5EXP7sU1kvOlxwZh5txg=
+sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730/go.mod h1:mdzfpAEoE6DHQEN0uh9ZbOCuHbLK5wOm7dK4ctXE9Tg=
+sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
+sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=
+sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
+sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4=
+sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08=
+sigs.k8s.io/structured-merge-diff/v4 v4.7.0 h1:qPeWmscJcXP0snki5IYF79Z8xrl8ETFxgMd7wez1XkI=
+sigs.k8s.io/structured-merge-diff/v4 v4.7.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps=
+sigs.k8s.io/structured-merge-diff/v6 v6.3.1 h1:JrhdFMqOd/+3ByqlP2I45kTOZmTRLBUm5pvRjeheg7E=
+sigs.k8s.io/structured-merge-diff/v6 v6.3.1/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
+sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs=
+sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4=

kind.yaml

@@ -0,0 +1,17 @@
+apiVersion: ctlptl.dev/v1alpha1
+kind: Registry
+name: ctlptl-registry
+port: 20021
+---
+apiVersion: ctlptl.dev/v1alpha1
+kind: Cluster
+product: kind
+registry: ctlptl-registry
+kindV1Alpha4Cluster:
+  name: goldpinger-test
+  nodes:
+  - role: control-plane
+  - role: worker
+  - role: worker
+  networking:
+    apiServerPort: 30022

pkg/client/operations/check_all_pods_parameters.go

@@ -16,47 +16,46 @@ import (
 	"github.com/go-openapi/strfmt"
 )
 
-// NewCheckAllPodsParams creates a new CheckAllPodsParams object
-// with the default values initialized.
+// NewCheckAllPodsParams creates a new CheckAllPodsParams object,
+// with the default timeout for this client.
+//
+// Default values are not hydrated, since defaults are normally applied by the API server side.
+//
+// To enforce default values in parameter, use SetDefaults or WithDefaults.
 func NewCheckAllPodsParams() *CheckAllPodsParams {
-
 	return &CheckAllPodsParams{
-
 		timeout: cr.DefaultTimeout,
 	}
 }
 
 // NewCheckAllPodsParamsWithTimeout creates a new CheckAllPodsParams object
-// with the default values initialized, and the ability to set a timeout on a request
+// with the ability to set a timeout on a request.
 func NewCheckAllPodsParamsWithTimeout(timeout time.Duration) *CheckAllPodsParams {
-
 	return &CheckAllPodsParams{
-
 		timeout: timeout,
 	}
 }
 
 // NewCheckAllPodsParamsWithContext creates a new CheckAllPodsParams object
-// with the default values initialized, and the ability to set a context for a request
+// with the ability to set a context for a request.
 func NewCheckAllPodsParamsWithContext(ctx context.Context) *CheckAllPodsParams {
-
 	return &CheckAllPodsParams{
-
 		Context: ctx,
 	}
 }
 
 // NewCheckAllPodsParamsWithHTTPClient creates a new CheckAllPodsParams object
-// with the default values initialized, and the ability to set a custom HTTPClient for a request
+// with the ability to set a custom HTTPClient for a request.
 func NewCheckAllPodsParamsWithHTTPClient(client *http.Client) *CheckAllPodsParams {
-
 	return &CheckAllPodsParams{
 		HTTPClient: client,
 	}
 }
 
-/*CheckAllPodsParams contains all the parameters to send to the API endpoint
-for the check all pods operation typically these are written to a http.Request
+/* CheckAllPodsParams contains all the parameters to send to the API endpoint
+   for the check all pods operation.
+
+   Typically these are written to a http.Request.
 */
 type CheckAllPodsParams struct {
 	timeout    time.Duration
@@ -64,6 +63,21 @@ type CheckAllPodsParams struct {
 	HTTPClient *http.Client
 }
 
+// WithDefaults hydrates default values in the check all pods params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *CheckAllPodsParams) WithDefaults() *CheckAllPodsParams {
+	o.SetDefaults()
+	return o
+}
+
+// SetDefaults hydrates default values in the check all pods params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *CheckAllPodsParams) SetDefaults() {
+	// no default values defined for this parameter
+}
+
 // WithTimeout adds the timeout to the check all pods params
 func (o *CheckAllPodsParams) WithTimeout(timeout time.Duration) *CheckAllPodsParams {
 	o.SetTimeout(timeout)

pkg/client/operations/check_all_pods_responses.go

@@ -29,9 +29,8 @@ func (o *CheckAllPodsReader) ReadResponse(response runtime.ClientResponse, consu
 			return nil, err
 		}
 		return result, nil
-
 	default:
-		return nil, runtime.NewAPIError("unknown error", response, response.Code())
+		return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code())
 	}
 }
 
@@ -40,7 +39,7 @@ func NewCheckAllPodsOK() *CheckAllPodsOK {
 	return &CheckAllPodsOK{}
 }
 
-/*CheckAllPodsOK handles this case with default header values.
+/* CheckAllPodsOK describes a response with status code 200, with default header values.
 
 Success, return response
 */
@@ -51,7 +50,6 @@ type CheckAllPodsOK struct {
 func (o *CheckAllPodsOK) Error() string {
 	return fmt.Sprintf("[GET /check_all][%d] checkAllPodsOK  %+v", 200, o.Payload)
 }
-
 func (o *CheckAllPodsOK) GetPayload() *models.CheckAllResults {
 	return o.Payload
 }

pkg/client/operations/check_service_pods_parameters.go

@@ -16,47 +16,46 @@ import (
 	"github.com/go-openapi/strfmt"
 )
 
-// NewCheckServicePodsParams creates a new CheckServicePodsParams object
-// with the default values initialized.
+// NewCheckServicePodsParams creates a new CheckServicePodsParams object,
+// with the default timeout for this client.
+//
+// Default values are not hydrated, since defaults are normally applied by the API server side.
+//
+// To enforce default values in parameter, use SetDefaults or WithDefaults.
 func NewCheckServicePodsParams() *CheckServicePodsParams {
-
 	return &CheckServicePodsParams{
-
 		timeout: cr.DefaultTimeout,
 	}
 }
 
 // NewCheckServicePodsParamsWithTimeout creates a new CheckServicePodsParams object
-// with the default values initialized, and the ability to set a timeout on a request
+// with the ability to set a timeout on a request.
 func NewCheckServicePodsParamsWithTimeout(timeout time.Duration) *CheckServicePodsParams {
-
 	return &CheckServicePodsParams{
-
 		timeout: timeout,
 	}
 }
 
 // NewCheckServicePodsParamsWithContext creates a new CheckServicePodsParams object
-// with the default values initialized, and the ability to set a context for a request
+// with the ability to set a context for a request.
 func NewCheckServicePodsParamsWithContext(ctx context.Context) *CheckServicePodsParams {
-
 	return &CheckServicePodsParams{
-
 		Context: ctx,
 	}
 }
 
 // NewCheckServicePodsParamsWithHTTPClient creates a new CheckServicePodsParams object
-// with the default values initialized, and the ability to set a custom HTTPClient for a request
+// with the ability to set a custom HTTPClient for a request.
 func NewCheckServicePodsParamsWithHTTPClient(client *http.Client) *CheckServicePodsParams {
-
 	return &CheckServicePodsParams{
 		HTTPClient: client,
 	}
 }
 
-/*CheckServicePodsParams contains all the parameters to send to the API endpoint
-for the check service pods operation typically these are written to a http.Request
+/* CheckServicePodsParams contains all the parameters to send to the API endpoint
+   for the check service pods operation.
+
+   Typically these are written to a http.Request.
 */
 type CheckServicePodsParams struct {
 	timeout    time.Duration
@@ -64,6 +63,21 @@ type CheckServicePodsParams struct {
 	HTTPClient *http.Client
 }
 
+// WithDefaults hydrates default values in the check service pods params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *CheckServicePodsParams) WithDefaults() *CheckServicePodsParams {
+	o.SetDefaults()
+	return o
+}
+
+// SetDefaults hydrates default values in the check service pods params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *CheckServicePodsParams) SetDefaults() {
+	// no default values defined for this parameter
+}
+
 // WithTimeout adds the timeout to the check service pods params
 func (o *CheckServicePodsParams) WithTimeout(timeout time.Duration) *CheckServicePodsParams {
 	o.SetTimeout(timeout)

pkg/client/operations/check_service_pods_responses.go

@@ -29,9 +29,8 @@ func (o *CheckServicePodsReader) ReadResponse(response runtime.ClientResponse, c
 			return nil, err
 		}
 		return result, nil
-
 	default:
-		return nil, runtime.NewAPIError("unknown error", response, response.Code())
+		return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code())
 	}
 }
 
@@ -40,7 +39,7 @@ func NewCheckServicePodsOK() *CheckServicePodsOK {
 	return &CheckServicePodsOK{}
 }
 
-/*CheckServicePodsOK handles this case with default header values.
+/* CheckServicePodsOK describes a response with status code 200, with default header values.
 
 Success, return response
 */
@@ -51,7 +50,6 @@ type CheckServicePodsOK struct {
 func (o *CheckServicePodsOK) Error() string {
 	return fmt.Sprintf("[GET /check][%d] checkServicePodsOK  %+v", 200, o.Payload)
 }
-
 func (o *CheckServicePodsOK) GetPayload() *models.CheckResults {
 	return o.Payload
 }

pkg/client/operations/cluster_health_parameters.go

@@ -0,0 +1,126 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/runtime"
+	cr "github.com/go-openapi/runtime/client"
+	"github.com/go-openapi/strfmt"
+)
+
+// NewClusterHealthParams creates a new ClusterHealthParams object,
+// with the default timeout for this client.
+//
+// Default values are not hydrated, since defaults are normally applied by the API server side.
+//
+// To enforce default values in parameter, use SetDefaults or WithDefaults.
+func NewClusterHealthParams() *ClusterHealthParams {
+	return &ClusterHealthParams{
+		timeout: cr.DefaultTimeout,
+	}
+}
+
+// NewClusterHealthParamsWithTimeout creates a new ClusterHealthParams object
+// with the ability to set a timeout on a request.
+func NewClusterHealthParamsWithTimeout(timeout time.Duration) *ClusterHealthParams {
+	return &ClusterHealthParams{
+		timeout: timeout,
+	}
+}
+
+// NewClusterHealthParamsWithContext creates a new ClusterHealthParams object
+// with the ability to set a context for a request.
+func NewClusterHealthParamsWithContext(ctx context.Context) *ClusterHealthParams {
+	return &ClusterHealthParams{
+		Context: ctx,
+	}
+}
+
+// NewClusterHealthParamsWithHTTPClient creates a new ClusterHealthParams object
+// with the ability to set a custom HTTPClient for a request.
+func NewClusterHealthParamsWithHTTPClient(client *http.Client) *ClusterHealthParams {
+	return &ClusterHealthParams{
+		HTTPClient: client,
+	}
+}
+
+/* ClusterHealthParams contains all the parameters to send to the API endpoint
+   for the cluster health operation.
+
+   Typically these are written to a http.Request.
+*/
+type ClusterHealthParams struct {
+	timeout    time.Duration
+	Context    context.Context
+	HTTPClient *http.Client
+}
+
+// WithDefaults hydrates default values in the cluster health params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *ClusterHealthParams) WithDefaults() *ClusterHealthParams {
+	o.SetDefaults()
+	return o
+}
+
+// SetDefaults hydrates default values in the cluster health params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *ClusterHealthParams) SetDefaults() {
+	// no default values defined for this parameter
+}
+
+// WithTimeout adds the timeout to the cluster health params
+func (o *ClusterHealthParams) WithTimeout(timeout time.Duration) *ClusterHealthParams {
+	o.SetTimeout(timeout)
+	return o
+}
+
+// SetTimeout adds the timeout to the cluster health params
+func (o *ClusterHealthParams) SetTimeout(timeout time.Duration) {
+	o.timeout = timeout
+}
+
+// WithContext adds the context to the cluster health params
+func (o *ClusterHealthParams) WithContext(ctx context.Context) *ClusterHealthParams {
+	o.SetContext(ctx)
+	return o
+}
+
+// SetContext adds the context to the cluster health params
+func (o *ClusterHealthParams) SetContext(ctx context.Context) {
+	o.Context = ctx
+}
+
+// WithHTTPClient adds the HTTPClient to the cluster health params
+func (o *ClusterHealthParams) WithHTTPClient(client *http.Client) *ClusterHealthParams {
+	o.SetHTTPClient(client)
+	return o
+}
+
+// SetHTTPClient adds the HTTPClient to the cluster health params
+func (o *ClusterHealthParams) SetHTTPClient(client *http.Client) {
+	o.HTTPClient = client
+}
+
+// WriteToRequest writes these params to a swagger request
+func (o *ClusterHealthParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
+
+	if err := r.SetTimeout(o.timeout); err != nil {
+		return err
+	}
+	var res []error
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}

pkg/client/operations/cluster_health_responses.go

@@ -0,0 +1,105 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/go-openapi/runtime"
+	"github.com/go-openapi/strfmt"
+
+	"github.com/bloomberg/goldpinger/v3/pkg/models"
+)
+
+// ClusterHealthReader is a Reader for the ClusterHealth structure.
+type ClusterHealthReader struct {
+	formats strfmt.Registry
+}
+
+// ReadResponse reads a server response into the received o.
+func (o *ClusterHealthReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
+	switch response.Code() {
+	case 200:
+		result := NewClusterHealthOK()
+		if err := result.readResponse(response, consumer, o.formats); err != nil {
+			return nil, err
+		}
+		return result, nil
+	case 418:
+		result := NewClusterHealthIMATeapot()
+		if err := result.readResponse(response, consumer, o.formats); err != nil {
+			return nil, err
+		}
+		return nil, result
+	default:
+		return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code())
+	}
+}
+
+// NewClusterHealthOK creates a ClusterHealthOK with default headers values
+func NewClusterHealthOK() *ClusterHealthOK {
+	return &ClusterHealthOK{}
+}
+
+/* ClusterHealthOK describes a response with status code 200, with default header values.
+
+Healthy cluster
+*/
+type ClusterHealthOK struct {
+	Payload *models.ClusterHealthResults
+}
+
+func (o *ClusterHealthOK) Error() string {
+	return fmt.Sprintf("[GET /cluster_health][%d] clusterHealthOK  %+v", 200, o.Payload)
+}
+func (o *ClusterHealthOK) GetPayload() *models.ClusterHealthResults {
+	return o.Payload
+}
+
+func (o *ClusterHealthOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
+
+	o.Payload = new(models.ClusterHealthResults)
+
+	// response payload
+	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
+		return err
+	}
+
+	return nil
+}
+
+// NewClusterHealthIMATeapot creates a ClusterHealthIMATeapot with default headers values
+func NewClusterHealthIMATeapot() *ClusterHealthIMATeapot {
+	return &ClusterHealthIMATeapot{}
+}
+
+/* ClusterHealthIMATeapot describes a response with status code 418, with default header values.
+
+Unhealthy cluster
+*/
+type ClusterHealthIMATeapot struct {
+	Payload *models.ClusterHealthResults
+}
+
+func (o *ClusterHealthIMATeapot) Error() string {
+	return fmt.Sprintf("[GET /cluster_health][%d] clusterHealthIMATeapot  %+v", 418, o.Payload)
+}
+func (o *ClusterHealthIMATeapot) GetPayload() *models.ClusterHealthResults {
+	return o.Payload
+}
+
+func (o *ClusterHealthIMATeapot) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
+
+	o.Payload = new(models.ClusterHealthResults)
+
+	// response payload
+	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
+		return err
+	}
+
+	return nil
+}

pkg/client/operations/healthz_parameters.go

@@ -16,47 +16,46 @@ import (
 	"github.com/go-openapi/strfmt"
 )
 
-// NewHealthzParams creates a new HealthzParams object
-// with the default values initialized.
+// NewHealthzParams creates a new HealthzParams object,
+// with the default timeout for this client.
+//
+// Default values are not hydrated, since defaults are normally applied by the API server side.
+//
+// To enforce default values in parameter, use SetDefaults or WithDefaults.
 func NewHealthzParams() *HealthzParams {
-
 	return &HealthzParams{
-
 		timeout: cr.DefaultTimeout,
 	}
 }
 
 // NewHealthzParamsWithTimeout creates a new HealthzParams object
-// with the default values initialized, and the ability to set a timeout on a request
+// with the ability to set a timeout on a request.
 func NewHealthzParamsWithTimeout(timeout time.Duration) *HealthzParams {
-
 	return &HealthzParams{
-
 		timeout: timeout,
 	}
 }
 
 // NewHealthzParamsWithContext creates a new HealthzParams object
-// with the default values initialized, and the ability to set a context for a request
+// with the ability to set a context for a request.
 func NewHealthzParamsWithContext(ctx context.Context) *HealthzParams {
-
 	return &HealthzParams{
-
 		Context: ctx,
 	}
 }
 
 // NewHealthzParamsWithHTTPClient creates a new HealthzParams object
-// with the default values initialized, and the ability to set a custom HTTPClient for a request
+// with the ability to set a custom HTTPClient for a request.
 func NewHealthzParamsWithHTTPClient(client *http.Client) *HealthzParams {
-
 	return &HealthzParams{
 		HTTPClient: client,
 	}
 }
 
-/*HealthzParams contains all the parameters to send to the API endpoint
-for the healthz operation typically these are written to a http.Request
+/* HealthzParams contains all the parameters to send to the API endpoint
+   for the healthz operation.
+
+   Typically these are written to a http.Request.
 */
 type HealthzParams struct {
 	timeout    time.Duration
@@ -64,6 +63,21 @@ type HealthzParams struct {
 	HTTPClient *http.Client
 }
 
+// WithDefaults hydrates default values in the healthz params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *HealthzParams) WithDefaults() *HealthzParams {
+	o.SetDefaults()
+	return o
+}
+
+// SetDefaults hydrates default values in the healthz params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *HealthzParams) SetDefaults() {
+	// no default values defined for this parameter
+}
+
 // WithTimeout adds the timeout to the healthz params
 func (o *HealthzParams) WithTimeout(timeout time.Duration) *HealthzParams {
 	o.SetTimeout(timeout)

pkg/client/operations/healthz_responses.go

@@ -35,9 +35,8 @@ func (o *HealthzReader) ReadResponse(response runtime.ClientResponse, consumer r
 			return nil, err
 		}
 		return nil, result
-
 	default:
-		return nil, runtime.NewAPIError("unknown error", response, response.Code())
+		return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code())
 	}
 }
 
@@ -46,7 +45,7 @@ func NewHealthzOK() *HealthzOK {
 	return &HealthzOK{}
 }
 
-/*HealthzOK handles this case with default header values.
+/* HealthzOK describes a response with status code 200, with default header values.
 
 Health check report
 */
@@ -57,7 +56,6 @@ type HealthzOK struct {
 func (o *HealthzOK) Error() string {
 	return fmt.Sprintf("[GET /healthz][%d] healthzOK  %+v", 200, o.Payload)
 }
-
 func (o *HealthzOK) GetPayload() *models.HealthCheckResults {
 	return o.Payload
 }
@@ -79,7 +77,7 @@ func NewHealthzServiceUnavailable() *HealthzServiceUnavailable {
 	return &HealthzServiceUnavailable{}
 }
 
-/*HealthzServiceUnavailable handles this case with default header values.
+/* HealthzServiceUnavailable describes a response with status code 503, with default header values.
 
 Unhealthy service
 */
@@ -90,7 +88,6 @@ type HealthzServiceUnavailable struct {
 func (o *HealthzServiceUnavailable) Error() string {
 	return fmt.Sprintf("[GET /healthz][%d] healthzServiceUnavailable  %+v", 503, o.Payload)
 }
-
 func (o *HealthzServiceUnavailable) GetPayload() *models.HealthCheckResults {
 	return o.Payload
 }

pkg/client/operations/operations_client.go

@@ -25,15 +25,20 @@ type Client struct {
 	formats   strfmt.Registry
 }
 
+// ClientOption is the option for Client methods
+type ClientOption func(*runtime.ClientOperation)
+
 // ClientService is the interface for Client methods
 type ClientService interface {
-	CheckAllPods(params *CheckAllPodsParams) (*CheckAllPodsOK, error)
+	CheckAllPods(params *CheckAllPodsParams, opts ...ClientOption) (*CheckAllPodsOK, error)
 
-	CheckServicePods(params *CheckServicePodsParams) (*CheckServicePodsOK, error)
+	CheckServicePods(params *CheckServicePodsParams, opts ...ClientOption) (*CheckServicePodsOK, error)
 
-	Healthz(params *HealthzParams) (*HealthzOK, error)
+	ClusterHealth(params *ClusterHealthParams, opts ...ClientOption) (*ClusterHealthOK, error)
 
-	Ping(params *PingParams) (*PingOK, error)
+	Healthz(params *HealthzParams, opts ...ClientOption) (*HealthzOK, error)
+
+	Ping(params *PingParams, opts ...ClientOption) (*PingOK, error)
 
 	SetTransport(transport runtime.ClientTransport)
 }
@@ -41,13 +46,12 @@ type ClientService interface {
 /*
   CheckAllPods Queries the API server for all other pods in this service, and makes all of them query all of their neighbours, using their pods IPs. Calls their /check endpoint.
 */
-func (a *Client) CheckAllPods(params *CheckAllPodsParams) (*CheckAllPodsOK, error) {
+func (a *Client) CheckAllPods(params *CheckAllPodsParams, opts ...ClientOption) (*CheckAllPodsOK, error) {
 	// TODO: Validate the params before sending
 	if params == nil {
 		params = NewCheckAllPodsParams()
 	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
+	op := &runtime.ClientOperation{
 		ID:                 "checkAllPods",
 		Method:             "GET",
 		PathPattern:        "/check_all",
@@ -58,7 +62,12 @@ func (a *Client) CheckAllPods(params *CheckAllPodsParams) (*CheckAllPodsOK, erro
 		Reader:             &CheckAllPodsReader{formats: a.formats},
 		Context:            params.Context,
 		Client:             params.HTTPClient,
-	})
+	}
+	for _, opt := range opts {
+		opt(op)
+	}
+
+	result, err := a.transport.Submit(op)
 	if err != nil {
 		return nil, err
 	}
@@ -75,13 +84,12 @@ func (a *Client) CheckAllPods(params *CheckAllPodsParams) (*CheckAllPodsOK, erro
 /*
   CheckServicePods Queries the API server for all other pods in this service, and pings them via their pods IPs. Calls their /ping endpoint
 */
-func (a *Client) CheckServicePods(params *CheckServicePodsParams) (*CheckServicePodsOK, error) {
+func (a *Client) CheckServicePods(params *CheckServicePodsParams, opts ...ClientOption) (*CheckServicePodsOK, error) {
 	// TODO: Validate the params before sending
 	if params == nil {
 		params = NewCheckServicePodsParams()
 	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
+	op := &runtime.ClientOperation{
 		ID:                 "checkServicePods",
 		Method:             "GET",
 		PathPattern:        "/check",
@@ -92,7 +100,12 @@ func (a *Client) CheckServicePods(params *CheckServicePodsParams) (*CheckService
 		Reader:             &CheckServicePodsReader{formats: a.formats},
 		Context:            params.Context,
 		Client:             params.HTTPClient,
-	})
+	}
+	for _, opt := range opts {
+		opt(op)
+	}
+
+	result, err := a.transport.Submit(op)
 	if err != nil {
 		return nil, err
 	}
@@ -106,16 +119,53 @@ func (a *Client) CheckServicePods(params *CheckServicePodsParams) (*CheckService
 	panic(msg)
 }
 
+/*
+  ClusterHealth Checks the full graph. Returns a binary OK or not OK.
+*/
+func (a *Client) ClusterHealth(params *ClusterHealthParams, opts ...ClientOption) (*ClusterHealthOK, error) {
+	// TODO: Validate the params before sending
+	if params == nil {
+		params = NewClusterHealthParams()
+	}
+	op := &runtime.ClientOperation{
+		ID:                 "clusterHealth",
+		Method:             "GET",
+		PathPattern:        "/cluster_health",
+		ProducesMediaTypes: []string{"application/json"},
+		ConsumesMediaTypes: []string{"application/json"},
+		Schemes:            []string{"http"},
+		Params:             params,
+		Reader:             &ClusterHealthReader{formats: a.formats},
+		Context:            params.Context,
+		Client:             params.HTTPClient,
+	}
+	for _, opt := range opts {
+		opt(op)
+	}
+
+	result, err := a.transport.Submit(op)
+	if err != nil {
+		return nil, err
+	}
+	success, ok := result.(*ClusterHealthOK)
+	if ok {
+		return success, nil
+	}
+	// unexpected success response
+	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
+	msg := fmt.Sprintf("unexpected success response for clusterHealth: API contract not enforced by server. Client expected to get an error, but got: %T", result)
+	panic(msg)
+}
+
 /*
   Healthz The healthcheck endpoint provides detailed information about the health of a web service. If each of the components required by the service are healthy, then the service is considered healthy and will return a 200 OK response. If any of the components needed by the service are unhealthy, then a 503 Service Unavailable response will be provided.
 */
-func (a *Client) Healthz(params *HealthzParams) (*HealthzOK, error) {
+func (a *Client) Healthz(params *HealthzParams, opts ...ClientOption) (*HealthzOK, error) {
 	// TODO: Validate the params before sending
 	if params == nil {
 		params = NewHealthzParams()
 	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
+	op := &runtime.ClientOperation{
 		ID:                 "healthz",
 		Method:             "GET",
 		PathPattern:        "/healthz",
@@ -126,7 +176,12 @@ func (a *Client) Healthz(params *HealthzParams) (*HealthzOK, error) {
 		Reader:             &HealthzReader{formats: a.formats},
 		Context:            params.Context,
 		Client:             params.HTTPClient,
-	})
+	}
+	for _, opt := range opts {
+		opt(op)
+	}
+
+	result, err := a.transport.Submit(op)
 	if err != nil {
 		return nil, err
 	}
@@ -143,13 +198,12 @@ func (a *Client) Healthz(params *HealthzParams) (*HealthzOK, error) {
 /*
   Ping return query stats
 */
-func (a *Client) Ping(params *PingParams) (*PingOK, error) {
+func (a *Client) Ping(params *PingParams, opts ...ClientOption) (*PingOK, error) {
 	// TODO: Validate the params before sending
 	if params == nil {
 		params = NewPingParams()
 	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
+	op := &runtime.ClientOperation{
 		ID:                 "ping",
 		Method:             "GET",
 		PathPattern:        "/ping",
@@ -160,7 +214,12 @@ func (a *Client) Ping(params *PingParams) (*PingOK, error) {
 		Reader:             &PingReader{formats: a.formats},
 		Context:            params.Context,
 		Client:             params.HTTPClient,
-	})
+	}
+	for _, opt := range opts {
+		opt(op)
+	}
+
+	result, err := a.transport.Submit(op)
 	if err != nil {
 		return nil, err
 	}

pkg/client/operations/ping_parameters.go

@@ -16,47 +16,46 @@ import (
 	"github.com/go-openapi/strfmt"
 )
 
-// NewPingParams creates a new PingParams object
-// with the default values initialized.
+// NewPingParams creates a new PingParams object,
+// with the default timeout for this client.
+//
+// Default values are not hydrated, since defaults are normally applied by the API server side.
+//
+// To enforce default values in parameter, use SetDefaults or WithDefaults.
 func NewPingParams() *PingParams {
-
 	return &PingParams{
-
 		timeout: cr.DefaultTimeout,
 	}
 }
 
 // NewPingParamsWithTimeout creates a new PingParams object
-// with the default values initialized, and the ability to set a timeout on a request
+// with the ability to set a timeout on a request.
 func NewPingParamsWithTimeout(timeout time.Duration) *PingParams {
-
 	return &PingParams{
-
 		timeout: timeout,
 	}
 }
 
 // NewPingParamsWithContext creates a new PingParams object
-// with the default values initialized, and the ability to set a context for a request
+// with the ability to set a context for a request.
 func NewPingParamsWithContext(ctx context.Context) *PingParams {
-
 	return &PingParams{
-
 		Context: ctx,
 	}
 }
 
 // NewPingParamsWithHTTPClient creates a new PingParams object
-// with the default values initialized, and the ability to set a custom HTTPClient for a request
+// with the ability to set a custom HTTPClient for a request.
 func NewPingParamsWithHTTPClient(client *http.Client) *PingParams {
-
 	return &PingParams{
 		HTTPClient: client,
 	}
 }
 
-/*PingParams contains all the parameters to send to the API endpoint
-for the ping operation typically these are written to a http.Request
+/* PingParams contains all the parameters to send to the API endpoint
+   for the ping operation.
+
+   Typically these are written to a http.Request.
 */
 type PingParams struct {
 	timeout    time.Duration
@@ -64,6 +63,21 @@ type PingParams struct {
 	HTTPClient *http.Client
 }
 
+// WithDefaults hydrates default values in the ping params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *PingParams) WithDefaults() *PingParams {
+	o.SetDefaults()
+	return o
+}
+
+// SetDefaults hydrates default values in the ping params (not the query body).
+//
+// All values with no default are reset to their zero value.
+func (o *PingParams) SetDefaults() {
+	// no default values defined for this parameter
+}
+
 // WithTimeout adds the timeout to the ping params
 func (o *PingParams) WithTimeout(timeout time.Duration) *PingParams {
 	o.SetTimeout(timeout)

pkg/client/operations/ping_responses.go

@@ -29,9 +29,8 @@ func (o *PingReader) ReadResponse(response runtime.ClientResponse, consumer runt
 			return nil, err
 		}
 		return result, nil
-
 	default:
-		return nil, runtime.NewAPIError("unknown error", response, response.Code())
+		return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code())
 	}
 }
 
@@ -40,7 +39,7 @@ func NewPingOK() *PingOK {
 	return &PingOK{}
 }
 
-/*PingOK handles this case with default header values.
+/* PingOK describes a response with status code 200, with default header values.
 
 return success
 */
@@ -51,7 +50,6 @@ type PingOK struct {
 func (o *PingOK) Error() string {
 	return fmt.Sprintf("[GET /ping][%d] pingOK  %+v", 200, o.Payload)
 }
-
 func (o *PingOK) GetPayload() *models.PingResults {
 	return o.Payload
 }

pkg/goldpinger/client.go

@@ -17,8 +17,9 @@ package goldpinger
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net"
+	"sort"
+	"strconv"
 	"sync"
 	"time"
 
@@ -36,15 +37,12 @@ func CheckNeighbours(ctx context.Context) *models.CheckResults {
 	// Mux to prevent concurrent map address
 	checkResultsMux.Lock()
 	defer checkResultsMux.Unlock()
-
 	final := models.CheckResults{}
 	final.PodResults = make(map[string]models.PodResult)
 	for podName, podResult := range checkResults.PodResults {
 		final.PodResults[podName] = podResult
 	}
-	if len(GoldpingerConfig.DnsHosts) > 0 {
-		final.DNSResults = *checkDNS()
-	}
+	final.ProbeResults = checkTargets()
 	return &final
 }
 
@@ -54,6 +52,65 @@ func CheckNeighboursNeighbours(ctx context.Context) *models.CheckAllResults {
 	return CheckAllPods(ctx, SelectPods())
 }
 
+// CheckCluster does a CheckNeighboursNeighbours and analyses results to produce a binary OK or not OK
+func CheckCluster(ctx context.Context) *models.ClusterHealthResults {
+	start := time.Now()
+	output := models.ClusterHealthResults{
+		GeneratedAt: strfmt.DateTime(start),
+		OK:          true,
+	}
+	selectedPods := SelectPods()
+
+	// precompute the expected set of nodes
+	expectedNodes := []string{}
+	for _, peer := range selectedPods {
+		expectedNodes = append(expectedNodes, peer.HostIP)
+	}
+	sort.Strings(expectedNodes)
+
+	// get the response we serve for check_all
+	checkAll := CheckAllPods(ctx, selectedPods)
+
+	// we should at the very least have a response from ourselves
+	if len(checkAll.Responses) < 1 {
+		output.OK = false
+	}
+	for _, resp := range checkAll.Responses {
+		// 1. check that all nodes report OK
+		if *resp.OK {
+			output.NodesHealthy = append(output.NodesHealthy, resp.HostIP.String())
+		} else {
+			output.NodesUnhealthy = append(output.NodesUnhealthy, resp.HostIP.String())
+			output.OK = false
+		}
+		output.NodesTotal++
+		// 2. check that all nodes report the expected peers
+		// on error, there might be no response from the node
+		if resp.Response == nil {
+			output.OK = false
+			continue
+		}
+		// if we get a response, let's check we get the expected nodes
+		observedNodes := []string{}
+		for _, peer := range resp.Response.PodResults {
+			observedNodes = append(observedNodes, string(peer.HostIP))
+		}
+		sort.Strings(observedNodes)
+		if len(observedNodes) != len(expectedNodes) {
+			output.OK = false
+		}
+		for i, val := range observedNodes {
+			if val != expectedNodes[i] {
+				output.OK = false
+				break
+			}
+		}
+	}
+	output.DurationNs = time.Since(start).Nanoseconds()
+	return &output
+}
+
+// PingAllPodsResult holds results from pinging all nodes
 type PingAllPodsResult struct {
 	podName   string
 	podResult models.PodResult
@@ -67,24 +124,61 @@ func pickPodHostIP(podIP, hostIP string) string {
 	return podIP
 }
 
-func checkDNS() *models.DNSResults {
-	results := models.DNSResults{}
-	for _, host := range GoldpingerConfig.DnsHosts {
-
-		var dnsResult models.DNSResult
-
-		start := time.Now()
-		_, err := net.LookupIP(host)
-		if err != nil {
-			dnsResult.Error = err.Error()
-			CountDnsError(host)
-		}
-		dnsResult.ResponseTimeMs = time.Since(start).Nanoseconds() / int64(time.Millisecond)
-		results[host] = dnsResult
+func checkTargets() models.ProbeResults {
+	results := make(map[string][]models.ProbeResult)
+	probes := []struct {
+		protocol string
+		hosts    []string
+		probeFn  func(addr string, timeout time.Duration) error
+		statFn   func(host string)
+		timeout  time.Duration
+	}{
+		{
+			protocol: "dns",
+			hosts:    GoldpingerConfig.DnsHosts,
+			probeFn:  doDNSProbe,
+			statFn:   CountDnsError,
+			timeout:  GoldpingerConfig.DnsCheckTimeout,
+		},
+		{
+			protocol: "http",
+			hosts:    GoldpingerConfig.HTTPTargets,
+			probeFn:  doHTTPProbe,
+			statFn:   CountHttpError,
+			timeout:  GoldpingerConfig.HTTPCheckTimeout,
+		},
+		{
+			protocol: "tcp",
+			hosts:    GoldpingerConfig.TCPTargets,
+			probeFn:  doTCPProbe,
+			statFn:   CountTcpError,
+			timeout:  GoldpingerConfig.TCPCheckTimeout,
+		},
 	}
-	return &results
+
+	for _, probe := range probes {
+		for _, host := range probe.hosts {
+			if _, ok := results[host]; !ok {
+				results[host] = []models.ProbeResult{}
+			}
+
+			res := models.ProbeResult{Protocol: probe.protocol}
+			start := time.Now()
+			err := probe.probeFn(host, probe.timeout)
+			if err != nil {
+				res.Error = err.Error()
+				probe.statFn(host)
+			}
+
+			res.ResponseTimeMs = time.Since(start).Milliseconds()
+			results[host] = append(results[host], res)
+		}
+	}
+
+	return results
 }
 
+// CheckServicePodsResult results of the /check operation
 type CheckServicePodsResult struct {
 	podName           string
 	checkAllPodResult models.CheckAllPodResult
@@ -92,8 +186,8 @@ type CheckServicePodsResult struct {
 	podIPv4           strfmt.IPv4
 }
 
+// CheckAllPods calls all neighbours and returns a detailed report
 func CheckAllPods(checkAllCtx context.Context, pods map[string]*GoldpingerPod) *models.CheckAllResults {
-
 	result := models.CheckAllResults{Responses: make(map[string]models.CheckAllPodResult)}
 
 	ch := make(chan CheckServicePodsResult, len(pods))
@@ -101,9 +195,7 @@ func CheckAllPods(checkAllCtx context.Context, pods map[string]*GoldpingerPod) *
 	wg.Add(len(pods))
 
 	for _, pod := range pods {
-
 		go func(pod *GoldpingerPod) {
-
 			// logger
 			logger := zap.L().With(
 				zap.String("op", "check"),
@@ -136,7 +228,7 @@ func CheckAllPods(checkAllCtx context.Context, pods map[string]*GoldpingerPod) *
 			} else {
 				checkCtx, cancel := context.WithTimeout(
 					checkAllCtx,
-					time.Duration(GoldpingerConfig.CheckTimeoutMs)*time.Millisecond,
+					GoldpingerConfig.CheckTimeout,
 				)
 				defer cancel()
 
@@ -179,21 +271,22 @@ func CheckAllPods(checkAllCtx context.Context, pods map[string]*GoldpingerPod) *
 			PodIP:   response.podIPv4,
 		})
 		if response.checkAllPodResult.Response != nil &&
-			response.checkAllPodResult.Response.DNSResults != nil {
-			if result.DNSResults == nil {
-				result.DNSResults = make(map[string]models.DNSResults)
+			response.checkAllPodResult.Response.ProbeResults != nil {
+			if result.ProbeResults == nil {
+				result.ProbeResults = make(map[string]models.ProbeResults)
 			}
-			for host := range response.checkAllPodResult.Response.DNSResults {
-				if result.DNSResults[host] == nil {
-					result.DNSResults[host] = make(map[string]models.DNSResult)
+			for host := range response.checkAllPodResult.Response.ProbeResults {
+				if result.ProbeResults[host] == nil {
+					result.ProbeResults[host] = make(map[string][]models.ProbeResult)
 				}
-				result.DNSResults[host][response.podName] = response.checkAllPodResult.Response.DNSResults[host]
+				result.ProbeResults[host][response.podName] = response.checkAllPodResult.Response.ProbeResults[host]
 			}
 		}
 	}
 	return &result
 }
 
+// HealthCheck returns a simple 200 OK response to verify the API is up
 func HealthCheck() *models.HealthCheckResults {
 	ok := true
 	start := time.Now()
@@ -209,7 +302,7 @@ func getClient(hostIP string) (*apiclient.Goldpinger, error) {
 	if hostIP == "" {
 		return nil, errors.New("Host or pod IP empty, can't make a call")
 	}
-	host := fmt.Sprintf("%s:%d", hostIP, GoldpingerConfig.Port)
+	host := net.JoinHostPort(hostIP, strconv.Itoa(GoldpingerConfig.Port))
 	transport := httptransport.New(host, "", nil)
 	client := apiclient.New(transport, strfmt.Default)
 	apiclient.Default.SetTransport(transport)

pkg/goldpinger/config.go

@@ -15,12 +15,15 @@
 package goldpinger
 
 import (
+	"time"
+
 	"k8s.io/client-go/kubernetes"
 )
 
 // GoldpingerConfig represents the configuration for goldpinger
 var GoldpingerConfig = struct {
 	StaticFilePath   string  `long:"static-file-path" description:"Folder for serving static files" env:"STATIC_FILE_PATH"`
+	ZapConfigPath    string  `long:"zap-config" description:"Path to zap config file" env:"ZAP_CONFIG" default:"/config/zap.json"`
 	KubeConfigPath   string  `long:"kubeconfig" description:"Path to kubeconfig file" env:"KUBECONFIG"`
 	RefreshInterval  int     `long:"refresh-interval" description:"If > 0, will create a thread and collect stats every n seconds" env:"REFRESH_INTERVAL" default:"30"`
 	JitterFactor     float64 `long:"jitter-factor" description:"The amount of jitter to add while pinging clients" env:"JITTER_FACTOR" default:"0.05"`
@@ -32,12 +35,23 @@ var GoldpingerConfig = struct {
 	UseHostIP        bool    `long:"use-host-ip" description:"When making the calls, use host ip (defaults to pod ip)" env:"USE_HOST_IP"`
 	LabelSelector    string  `long:"label-selector" description:"label selector to use to discover goldpinger pods in the cluster" env:"LABEL_SELECTOR" default:"app=goldpinger"`
 	Namespace        *string `long:"namespace" description:"namespace to use to discover goldpinger pods in the cluster (empty for all). Defaults to discovering the namespace for the current pod" env:"NAMESPACE"`
+	DisplayNodeName  bool    `long:"display-nodename" description:"Display nodename other than podname in UI (defaults is podname)." env:"DISPLAY_NODENAME"`
 	KubernetesClient *kubernetes.Clientset
 
-	DnsHosts []string `long:"host-to-resolve" description:"A host to attempt dns resolve on (space delimited)" env:"HOSTS_TO_RESOLVE" env-delim:" "`
+	DnsHosts    []string `long:"host-to-resolve" description:"A host to attempt dns resolve on (space delimited)" env:"HOSTS_TO_RESOLVE" env-delim:" "`
+	TCPTargets  []string `long:"tcp-targets" description:"A list of external targets(<host>:<port> or <ip>:<port>) to attempt a TCP check on (space delimited)" env:"TCP_TARGETS" env-delim:" "`
+	HTTPTargets []string `long:"http-targets" description:"A list of external targets(<http or https>://<url>) to attempt an HTTP{S} check on. A 200 HTTP code is considered successful.(space delimited)" env:"HTTP_TARGETS" env-delim:" "`
+
+	IPVersions []string `long:"ip-versions" description:"The IP versions to use (space delimited). Possible values are 4 and 6 (defaults to 4)." env:"IP_VERSIONS" env-delim:" "`
 
 	// Timeouts
-	PingTimeoutMs     int64 `long:"ping-timeout-ms" description:"The timeout in milliseconds for a ping call to other goldpinger pods" env:"PING_TIMEOUT_MS" default:"300"`
-	CheckTimeoutMs    int64 `long:"check-timeout-ms" description:"The timeout in milliseconds for a check call to other goldpinger pods" env:"CHECK_TIMEOUT_MS" default:"1000"`
-	CheckAllTimeoutMs int64 `long:"check-all-timeout-ms" description:"The timeout in milliseconds for a check-all call to other goldpinger pods" env:"CHECK_ALL_TIMEOUT_MS" default:"5000"`
+	PingTimeoutMs     int64         `long:"ping-timeout-ms" description:"The timeout in milliseconds for a ping call to other goldpinger pods(deprecated)" env:"PING_TIMEOUT_MS" default:"300"`
+	CheckTimeoutMs    int64         `long:"check-timeout-ms" description:"The timeout in milliseconds for a check call to other goldpinger pods(deprecated)" env:"CHECK_TIMEOUT_MS" default:"1000"`
+	CheckAllTimeoutMs int64         `long:"check-all-timeout-ms" description:"The timeout in milliseconds for a check-all call to other goldpinger pods(deprecated)" env:"CHECK_ALL_TIMEOUT_MS" default:"5000"`
+	PingTimeout       time.Duration `long:"ping-timeout" description:"The timeout for a ping call to other goldpinger pods" env:"PING_TIMEOUT" default:"300ms"`
+	CheckTimeout      time.Duration `long:"check-timeout" description:"The timeout for a check call to other goldpinger pods" env:"CHECK_TIMEOUT" default:"1000ms"`
+	CheckAllTimeout   time.Duration `long:"check-all-timeout" description:"The timeout for a check-all call to other goldpinger pods" env:"CHECK_ALL_TIMEOUT" default:"5000ms"`
+	TCPCheckTimeout   time.Duration `long:"tcp-targets-timeout" description:"The timeout for a tcp check on the provided tcp-targets" env:"TCP_TARGETS_TIMEOUT" default:"500ms"`
+	DnsCheckTimeout   time.Duration `long:"dns-targets-timeout" description:"The timeout for a dns check on the provided dns-targets" env:"DNS_TARGETS_TIMEOUT" default:"500ms"`
+	HTTPCheckTimeout  time.Duration `long:"http-targets-timeout" description:"The timeout for a http check on the provided http-targets" env:"HTTP_TARGETS_TIMEOUT" default:"500ms"`
 }{}

pkg/goldpinger/heatmap.go

@@ -26,7 +26,6 @@ import (
 	"net/http"
 	"sort"
 	"strconv"
-	"time"
 
 	"go.uber.org/zap"
 	"golang.org/x/image/font"
@@ -83,7 +82,7 @@ func HeatmapHandler(w http.ResponseWriter, r *http.Request) {
 
 	ctx, cancel := context.WithTimeout(
 		r.Context(),
-		time.Duration(GoldpingerConfig.CheckAllTimeoutMs)*time.Millisecond,
+		GoldpingerConfig.CheckAllTimeout,
 	)
 	defer cancel()
 

pkg/goldpinger/k8s.go

@@ -15,12 +15,17 @@
 package goldpinger
 
 import (
+	"context"
 	"io/ioutil"
 
 	"go.uber.org/zap"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8snet "k8s.io/utils/net"
 )
 
+var nodeIPMap = make(map[string]string)
+
 // PodNamespace is the auto-detected namespace for this goldpinger pod
 var PodNamespace = getPodNamespace()
 
@@ -41,10 +46,73 @@ func getPodNamespace() string {
 	return namespace
 }
 
+// getHostIP gets the IP of the host where the pod is scheduled. If UseIPv6 is enabled then we need to check
+// the node IPs since HostIP will only list the default IP version one.
+func getHostIP(p v1.Pod) string {
+	if ipMatchesConfig(p.Status.HostIP) {
+		return p.Status.HostIP
+	}
+
+	if addr, ok := nodeIPMap[p.Spec.NodeName]; ok {
+		return addr
+	}
+
+	timer := GetLabeledKubernetesCallsTimer()
+	node, err := GoldpingerConfig.KubernetesClient.CoreV1().Nodes().Get(context.TODO(), p.Spec.NodeName, metav1.GetOptions{})
+	if err != nil {
+		zap.L().Error("error getting node", zap.Error(err))
+		CountError("kubernetes_api")
+		return p.Status.HostIP
+	} else {
+		timer.ObserveDuration()
+	}
+
+	var hostIP string
+	for _, addr := range node.Status.Addresses {
+		if (addr.Type == v1.NodeInternalIP || addr.Type == v1.NodeExternalIP) &&
+			ipMatchesConfig(addr.Address) {
+			hostIP = addr.Address
+		}
+	}
+	nodeIPMap[p.Spec.NodeName] = hostIP
+	return hostIP
+}
+
+// getPodIP will get an IPv6 IP from PodIPs if the UseIPv6 config is set, otherwise just return the object PodIP
+func getPodIP(p v1.Pod) string {
+	if ipMatchesConfig(p.Status.PodIP) {
+		return p.Status.PodIP
+	}
+
+	var podIP string
+	if p.Status.PodIPs != nil {
+		for _, ip := range p.Status.PodIPs {
+			if ipMatchesConfig(ip.IP) {
+				podIP = ip.IP
+			}
+		}
+	}
+	return podIP
+}
+
+func getPodNodeName(p v1.Pod) string {
+	if GoldpingerConfig.DisplayNodeName {
+		return p.Spec.NodeName
+	}
+
+	return p.Name
+}
+
 // GetAllPods returns a mapping from a pod name to a pointer to a GoldpingerPod(s)
 func GetAllPods() map[string]*GoldpingerPod {
 	timer := GetLabeledKubernetesCallsTimer()
-	pods, err := GoldpingerConfig.KubernetesClient.CoreV1().Pods(*GoldpingerConfig.Namespace).List(metav1.ListOptions{LabelSelector: GoldpingerConfig.LabelSelector})
+	listOpts := metav1.ListOptions{
+		ResourceVersion: "0",
+
+		LabelSelector: GoldpingerConfig.LabelSelector,
+		FieldSelector: "status.phase=Running", // only select Running pods, otherwise we will get them before they have IPs
+	}
+	pods, err := GoldpingerConfig.KubernetesClient.CoreV1().Pods(*GoldpingerConfig.Namespace).List(context.TODO(), listOpts)
 	if err != nil {
 		zap.L().Error("Error getting pods for selector", zap.String("selector", GoldpingerConfig.LabelSelector), zap.Error(err))
 		CountError("kubernetes_api")
@@ -52,13 +120,33 @@ func GetAllPods() map[string]*GoldpingerPod {
 		timer.ObserveDuration()
 	}
 
-	var podMap = make(map[string]*GoldpingerPod)
+	podMap := make(map[string]*GoldpingerPod)
 	for _, pod := range pods.Items {
 		podMap[pod.Name] = &GoldpingerPod{
-			Name:   pod.Name,
-			PodIP:  pod.Status.PodIP,
-			HostIP: pod.Status.HostIP,
+			Name:   getPodNodeName(pod),
+			PodIP:  getPodIP(pod),
+			HostIP: getHostIP(pod),
 		}
 	}
 	return podMap
 }
+
+// ipMatchesConfig checks if the input IP family matches the first entry in the IPVersions config.
+// TODO update to check all config versions to support dual-stack pinging.
+func ipMatchesConfig(ip string) bool {
+	ipFamily := getIPFamily(ip)
+	return GoldpingerConfig.IPVersions[0] == string(ipFamily)
+}
+
+// getIPFamily returns the IP family of the input IP.
+// Possible values are 4 and 6.
+func getIPFamily(ip string) k8snet.IPFamily {
+	if k8snet.IsIPv4String(ip) {
+		return k8snet.IPv4
+	}
+	if k8snet.IsIPv6String(ip) {
+		return k8snet.IPv6
+	}
+	zap.L().Error("Error determining IP family", zap.String("IP", ip))
+	return ""
+}

pkg/goldpinger/pinger.go

@@ -46,7 +46,7 @@ type Pinger struct {
 func NewPinger(pod *GoldpingerPod, resultsChan chan<- PingAllPodsResult) *Pinger {
 	p := Pinger{
 		pod:         pod,
-		timeout:     time.Duration(GoldpingerConfig.PingTimeoutMs) * time.Millisecond,
+		timeout:     GoldpingerConfig.PingTimeout,
 		resultsChan: resultsChan,
 		stopChan:    make(chan struct{}),
 

pkg/goldpinger/probes.go

@@ -0,0 +1,72 @@
+// Copyright 2018 Bloomberg Finance L.P.
+//
+// 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 goldpinger
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+func doDNSProbe(addr string, timeout time.Duration) error {
+	resolver := net.Resolver{}
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	ips, err := resolver.LookupHost(ctx, addr)
+	if len(ips) == 0 {
+		return fmt.Errorf("%s was resolved to 0 ips", addr)
+	}
+	return err
+}
+
+func doTCPProbe(addr string, timeout time.Duration) error {
+	conn, err := net.DialTimeout("tcp", addr, timeout)
+	if conn != nil {
+		defer conn.Close()
+	}
+	return err
+}
+
+func doHTTPProbe(addr string, timeout time.Duration) error {
+	client := http.Client{Timeout: timeout}
+	u, err := url.Parse(addr)
+	if err != nil {
+		return err
+	}
+	if u.Scheme != "http" && u.Scheme != "https" {
+		return fmt.Errorf("invalid url scheme: '%s' in address", u.Scheme)
+	}
+	if u.Scheme == "https" {
+		client.Transport = &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: true,
+			},
+		}
+	}
+	resp, err := client.Get(addr)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("%s returned non-200 resp: %d", addr, resp.StatusCode)
+	}
+	return err
+}

pkg/goldpinger/stats.go

@@ -48,6 +48,16 @@ var (
 		},
 	)
 
+	goldpingerClusterHealthGauge = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Name: "goldpinger_cluster_health_total",
+			Help: "1 if all check pass, 0 otherwise",
+		},
+		[]string{
+			"goldpinger_instance",
+		},
+	)
+
 	goldpingerResponseTimePeersHistogram = prometheus.NewHistogramVec(
 		prometheus.HistogramOpts{
 			Name:    "goldpinger_peers_response_time_s",
@@ -93,17 +103,39 @@ var (
 			"host",
 		},
 	)
-
+	goldPingerTcpErrorsCounter = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "goldpinger_tcp_errors_total",
+			Help: "Statistics of TCP probe errors per instance",
+		},
+		[]string{
+			"goldpinger_instance",
+			"host",
+		},
+	)
+	goldPingerHttpErrorsCounter = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "goldpinger_http_errors_total",
+			Help: "Statistics of HTTP probe errors per instance",
+		},
+		[]string{
+			"goldpinger_instance",
+			"host",
+		},
+	)
 	bootTime = time.Now()
 )
 
 func init() {
 	prometheus.MustRegister(goldpingerStatsCounter)
 	prometheus.MustRegister(goldpingerNodesHealthGauge)
+	prometheus.MustRegister(goldpingerClusterHealthGauge)
 	prometheus.MustRegister(goldpingerResponseTimePeersHistogram)
 	prometheus.MustRegister(goldpingerResponseTimeKubernetesHistogram)
 	prometheus.MustRegister(goldpingerErrorsCounter)
 	prometheus.MustRegister(goldpingerDnsErrorsCounter)
+	prometheus.MustRegister(goldPingerHttpErrorsCounter)
+	prometheus.MustRegister(goldPingerTcpErrorsCounter)
 	zap.L().Info("Metrics setup - see /metrics")
 }
 
@@ -135,6 +167,17 @@ func CountHealthyUnhealthyNodes(healthy, unhealthy float64) {
 	).Set(unhealthy)
 }
 
+// SetClusterHealth sets the cluster health gauge to 1 (healthy) or 0 (unhealthy)
+func SetClusterHealth(healthy bool) {
+	value := 1.0
+	if !healthy {
+		value = 0
+	}
+	goldpingerClusterHealthGauge.WithLabelValues(
+		GoldpingerConfig.Hostname,
+	).Set(value)
+}
+
 // counts instances of various errors
 func CountError(errorType string) {
 	goldpingerErrorsCounter.WithLabelValues(
@@ -151,6 +194,22 @@ func CountDnsError(host string) {
 	).Inc()
 }
 
+// CountTcpError counts instances of tcp errors for prober
+func CountTcpError(host string) {
+	goldPingerTcpErrorsCounter.WithLabelValues(
+		GoldpingerConfig.Hostname,
+		host,
+	).Inc()
+}
+
+// CountHttpError counts instances of tcp errors for prober
+func CountHttpError(host string) {
+	goldPingerHttpErrorsCounter.WithLabelValues(
+		GoldpingerConfig.Hostname,
+		host,
+	).Inc()
+}
+
 // returns a timer for easy observing of the durations of calls to kubernetes API
 func GetLabeledKubernetesCallsTimer() *prometheus.Timer {
 	return prometheus.NewTimer(

pkg/goldpinger/updater.go

@@ -34,8 +34,8 @@ var checkResultsMux = sync.Mutex{}
 // - there is already a pinger with the same name
 // - the pinger has the same podIP
 // - the pinger has the same hostIP
-func exists(existingPods map[string]*GoldpingerPod, new *GoldpingerPod) bool {
-	old, exists := existingPods[new.Name]
+func exists(existingPods map[string]*GoldpingerPod, podName string, new *GoldpingerPod) bool {
+	old, exists := existingPods[podName]
 	return exists && (old.PodIP == new.PodIP) && (old.HostIP == new.HostIP)
 }
 
@@ -61,7 +61,7 @@ func updatePingers(resultsChan chan<- PingAllPodsResult) {
 
 		latest := SelectPods()
 		for podName, pod := range latest {
-			if exists(existingPods, pod) {
+			if exists(existingPods, podName, pod) {
 				// This pod continues to exist in the latest iteration of the update
 				// without any changes
 				// Delete it from the set of pods that we wish to delete
@@ -153,6 +153,22 @@ func updateCounters() {
 		}
 	}
 	CountHealthyUnhealthyNodes(counterHealthy, float64(len(checkResults.PodResults))-counterHealthy)
+	// check external targets, don't block the access to checkResultsMux
+	nodesHealthy := int(counterHealthy) == len(checkResults.PodResults)
+	go func(healthySoFar bool) {
+		if healthySoFar {
+			probeResults := checkTargets()
+			for host := range probeResults {
+				for _, response := range probeResults[host] {
+					if response.Error != "" {
+						healthySoFar = false
+						break
+					}
+				}
+			}
+		}
+		SetClusterHealth(healthySoFar)
+	}(nodesHealthy)
 }
 
 // collectResults simply reads results from the results channel and saves them in a map

pkg/models/call_stats.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
 )
@@ -30,6 +32,11 @@ func (m *CallStats) Validate(formats strfmt.Registry) error {
 	return nil
 }
 
+// ContextValidate validates this call stats based on context it is used
+func (m *CallStats) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *CallStats) MarshalBinary() ([]byte, error) {
 	if m == nil {

pkg/models/check_all_pod_result.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
@@ -61,7 +63,6 @@ func (m *CheckAllPodResult) Validate(formats strfmt.Registry) error {
 }
 
 func (m *CheckAllPodResult) validateHostIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.HostIP) { // not required
 		return nil
 	}
@@ -74,7 +75,6 @@ func (m *CheckAllPodResult) validateHostIP(formats strfmt.Registry) error {
 }
 
 func (m *CheckAllPodResult) validatePodIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.PodIP) { // not required
 		return nil
 	}
@@ -87,7 +87,6 @@ func (m *CheckAllPodResult) validatePodIP(formats strfmt.Registry) error {
 }
 
 func (m *CheckAllPodResult) validateResponse(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.Response) { // not required
 		return nil
 	}
@@ -96,6 +95,38 @@ func (m *CheckAllPodResult) validateResponse(formats strfmt.Registry) error {
 		if err := m.Response.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("response")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("response")
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ContextValidate validate this check all pod result based on the context it is used
+func (m *CheckAllPodResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.contextValidateResponse(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *CheckAllPodResult) contextValidateResponse(ctx context.Context, formats strfmt.Registry) error {
+
+	if m.Response != nil {
+		if err := m.Response.ContextValidate(ctx, formats); err != nil {
+			if ve, ok := err.(*errors.Validation); ok {
+				return ve.ValidateName("response")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("response")
 			}
 			return err
 		}

pkg/models/check_all_results.go

@@ -6,6 +6,7 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
 	"strconv"
 
 	"github.com/go-openapi/errors"
@@ -22,9 +23,6 @@ type CheckAllResults struct {
 	// o k
 	OK *bool `json:"OK,omitempty"`
 
-	// dns results
-	DNSResults map[string]DNSResults `json:"dnsResults,omitempty"`
-
 	// hosts
 	Hosts []*CheckAllResultsHostsItems0 `json:"hosts"`
 
@@ -34,6 +32,9 @@ type CheckAllResults struct {
 	// hosts number
 	HostsNumber int32 `json:"hosts-number,omitempty"`
 
+	// probe results
+	ProbeResults map[string]ProbeResults `json:"probeResults,omitempty"`
+
 	// responses
 	Responses map[string]CheckAllPodResult `json:"responses,omitempty"`
 }
@@ -42,11 +43,11 @@ type CheckAllResults struct {
 func (m *CheckAllResults) Validate(formats strfmt.Registry) error {
 	var res []error
 
-	if err := m.validateDNSResults(formats); err != nil {
+	if err := m.validateHosts(formats); err != nil {
 		res = append(res, err)
 	}
 
-	if err := m.validateHosts(formats); err != nil {
+	if err := m.validateProbeResults(formats); err != nil {
 		res = append(res, err)
 	}
 
@@ -60,27 +61,7 @@ func (m *CheckAllResults) Validate(formats strfmt.Registry) error {
 	return nil
 }
 
-func (m *CheckAllResults) validateDNSResults(formats strfmt.Registry) error {
-
-	if swag.IsZero(m.DNSResults) { // not required
-		return nil
-	}
-
-	for k := range m.DNSResults {
-
-		if val, ok := m.DNSResults[k]; ok {
-			if err := val.Validate(formats); err != nil {
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}
-
 func (m *CheckAllResults) validateHosts(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.Hosts) { // not required
 		return nil
 	}
@@ -94,6 +75,8 @@ func (m *CheckAllResults) validateHosts(formats strfmt.Registry) error {
 			if err := m.Hosts[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("hosts" + "." + strconv.Itoa(i))
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName("hosts" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -104,8 +87,25 @@ func (m *CheckAllResults) validateHosts(formats strfmt.Registry) error {
 	return nil
 }
 
-func (m *CheckAllResults) validateResponses(formats strfmt.Registry) error {
+func (m *CheckAllResults) validateProbeResults(formats strfmt.Registry) error {
+	if swag.IsZero(m.ProbeResults) { // not required
+		return nil
+	}
 
+	for k := range m.ProbeResults {
+
+		if val, ok := m.ProbeResults[k]; ok {
+			if err := val.Validate(formats); err != nil {
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}
+
+func (m *CheckAllResults) validateResponses(formats strfmt.Registry) error {
 	if swag.IsZero(m.Responses) { // not required
 		return nil
 	}
@@ -117,6 +117,83 @@ func (m *CheckAllResults) validateResponses(formats strfmt.Registry) error {
 		}
 		if val, ok := m.Responses[k]; ok {
 			if err := val.Validate(formats); err != nil {
+				if ve, ok := err.(*errors.Validation); ok {
+					return ve.ValidateName("responses" + "." + k)
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName("responses" + "." + k)
+				}
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}
+
+// ContextValidate validate this check all results based on the context it is used
+func (m *CheckAllResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.contextValidateHosts(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateProbeResults(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateResponses(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *CheckAllResults) contextValidateHosts(ctx context.Context, formats strfmt.Registry) error {
+
+	for i := 0; i < len(m.Hosts); i++ {
+
+		if m.Hosts[i] != nil {
+			if err := m.Hosts[i].ContextValidate(ctx, formats); err != nil {
+				if ve, ok := err.(*errors.Validation); ok {
+					return ve.ValidateName("hosts" + "." + strconv.Itoa(i))
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName("hosts" + "." + strconv.Itoa(i))
+				}
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}
+
+func (m *CheckAllResults) contextValidateProbeResults(ctx context.Context, formats strfmt.Registry) error {
+
+	for k := range m.ProbeResults {
+
+		if val, ok := m.ProbeResults[k]; ok {
+			if err := val.ContextValidate(ctx, formats); err != nil {
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}
+
+func (m *CheckAllResults) contextValidateResponses(ctx context.Context, formats strfmt.Registry) error {
+
+	for k := range m.Responses {
+
+		if val, ok := m.Responses[k]; ok {
+			if err := val.ContextValidate(ctx, formats); err != nil {
 				return err
 			}
 		}
@@ -180,7 +257,6 @@ func (m *CheckAllResultsHostsItems0) Validate(formats strfmt.Registry) error {
 }
 
 func (m *CheckAllResultsHostsItems0) validateHostIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.HostIP) { // not required
 		return nil
 	}
@@ -193,7 +269,6 @@ func (m *CheckAllResultsHostsItems0) validateHostIP(formats strfmt.Registry) err
 }
 
 func (m *CheckAllResultsHostsItems0) validatePodIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.PodIP) { // not required
 		return nil
 	}
@@ -205,6 +280,11 @@ func (m *CheckAllResultsHostsItems0) validatePodIP(formats strfmt.Registry) erro
 	return nil
 }
 
+// ContextValidate validates this check all results hosts items0 based on context it is used
+func (m *CheckAllResultsHostsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *CheckAllResultsHostsItems0) MarshalBinary() ([]byte, error) {
 	if m == nil {

pkg/models/check_results.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
@@ -17,22 +19,22 @@ import (
 // swagger:model CheckResults
 type CheckResults struct {
 
-	// dns results
-	DNSResults DNSResults `json:"dnsResults,omitempty"`
-
 	// pod results
 	PodResults map[string]PodResult `json:"podResults,omitempty"`
+
+	// probe results
+	ProbeResults ProbeResults `json:"probeResults,omitempty"`
 }
 
 // Validate validates this check results
 func (m *CheckResults) Validate(formats strfmt.Registry) error {
 	var res []error
 
-	if err := m.validateDNSResults(formats); err != nil {
+	if err := m.validatePodResults(formats); err != nil {
 		res = append(res, err)
 	}
 
-	if err := m.validatePodResults(formats); err != nil {
+	if err := m.validateProbeResults(formats); err != nil {
 		res = append(res, err)
 	}
 
@@ -42,24 +44,7 @@ func (m *CheckResults) Validate(formats strfmt.Registry) error {
 	return nil
 }
 
-func (m *CheckResults) validateDNSResults(formats strfmt.Registry) error {
-
-	if swag.IsZero(m.DNSResults) { // not required
-		return nil
-	}
-
-	if err := m.DNSResults.Validate(formats); err != nil {
-		if ve, ok := err.(*errors.Validation); ok {
-			return ve.ValidateName("dnsResults")
-		}
-		return err
-	}
-
-	return nil
-}
-
 func (m *CheckResults) validatePodResults(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.PodResults) { // not required
 		return nil
 	}
@@ -71,6 +56,11 @@ func (m *CheckResults) validatePodResults(formats strfmt.Registry) error {
 		}
 		if val, ok := m.PodResults[k]; ok {
 			if err := val.Validate(formats); err != nil {
+				if ve, ok := err.(*errors.Validation); ok {
+					return ve.ValidateName("podResults" + "." + k)
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName("podResults" + "." + k)
+				}
 				return err
 			}
 		}
@@ -80,6 +70,72 @@ func (m *CheckResults) validatePodResults(formats strfmt.Registry) error {
 	return nil
 }
 
+func (m *CheckResults) validateProbeResults(formats strfmt.Registry) error {
+	if swag.IsZero(m.ProbeResults) { // not required
+		return nil
+	}
+
+	if m.ProbeResults != nil {
+		if err := m.ProbeResults.Validate(formats); err != nil {
+			if ve, ok := err.(*errors.Validation); ok {
+				return ve.ValidateName("probeResults")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("probeResults")
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ContextValidate validate this check results based on the context it is used
+func (m *CheckResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.contextValidatePodResults(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateProbeResults(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *CheckResults) contextValidatePodResults(ctx context.Context, formats strfmt.Registry) error {
+
+	for k := range m.PodResults {
+
+		if val, ok := m.PodResults[k]; ok {
+			if err := val.ContextValidate(ctx, formats); err != nil {
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}
+
+func (m *CheckResults) contextValidateProbeResults(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := m.ProbeResults.ContextValidate(ctx, formats); err != nil {
+		if ve, ok := err.(*errors.Validation); ok {
+			return ve.ValidateName("probeResults")
+		} else if ce, ok := err.(*errors.CompositeError); ok {
+			return ce.ValidateName("probeResults")
+		}
+		return err
+	}
+
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *CheckResults) MarshalBinary() ([]byte, error) {
 	if m == nil {

pkg/models/cluster_health_results.go

@@ -0,0 +1,103 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"context"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+	"github.com/go-openapi/validate"
+)
+
+// ClusterHealthResults cluster health results
+//
+// swagger:model ClusterHealthResults
+type ClusterHealthResults struct {
+
+	// o k
+	// Required: true
+	OK bool `json:"OK"`
+
+	// duration ns
+	DurationNs int64 `json:"duration-ns,omitempty"`
+
+	// generated at
+	// Format: date-time
+	GeneratedAt strfmt.DateTime `json:"generated-at,omitempty"`
+
+	// nodes healthy
+	NodesHealthy []string `json:"nodesHealthy"`
+
+	// nodes total
+	NodesTotal int64 `json:"nodesTotal,omitempty"`
+
+	// nodes unhealthy
+	NodesUnhealthy []string `json:"nodesUnhealthy"`
+}
+
+// Validate validates this cluster health results
+func (m *ClusterHealthResults) Validate(formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.validateOK(formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.validateGeneratedAt(formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *ClusterHealthResults) validateOK(formats strfmt.Registry) error {
+
+	if err := validate.Required("OK", "body", bool(m.OK)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *ClusterHealthResults) validateGeneratedAt(formats strfmt.Registry) error {
+	if swag.IsZero(m.GeneratedAt) { // not required
+		return nil
+	}
+
+	if err := validate.FormatOf("generated-at", "body", "date-time", m.GeneratedAt.String(), formats); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ContextValidate validates this cluster health results based on context it is used
+func (m *ClusterHealthResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
+// MarshalBinary interface implementation
+func (m *ClusterHealthResults) MarshalBinary() ([]byte, error) {
+	if m == nil {
+		return nil, nil
+	}
+	return swag.WriteJSON(m)
+}
+
+// UnmarshalBinary interface implementation
+func (m *ClusterHealthResults) UnmarshalBinary(b []byte) error {
+	var res ClusterHealthResults
+	if err := swag.ReadJSON(b, &res); err != nil {
+		return err
+	}
+	*m = res
+	return nil
+}

pkg/models/dns_result.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
 )
@@ -27,6 +29,11 @@ func (m *DNSResult) Validate(formats strfmt.Registry) error {
 	return nil
 }
 
+// ContextValidate validates this Dns result based on context it is used
+func (m *DNSResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *DNSResult) MarshalBinary() ([]byte, error) {
 	if m == nil {

pkg/models/dns_results.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/validate"
@@ -38,3 +40,23 @@ func (m DNSResults) Validate(formats strfmt.Registry) error {
 	}
 	return nil
 }
+
+// ContextValidate validate this Dns results based on the context it is used
+func (m DNSResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	for k := range m {
+
+		if val, ok := m[k]; ok {
+			if err := val.ContextValidate(ctx, formats); err != nil {
+				return err
+			}
+		}
+
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}

pkg/models/health_check_results.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
@@ -43,7 +45,6 @@ func (m *HealthCheckResults) Validate(formats strfmt.Registry) error {
 }
 
 func (m *HealthCheckResults) validateGeneratedAt(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.GeneratedAt) { // not required
 		return nil
 	}
@@ -55,6 +56,11 @@ func (m *HealthCheckResults) validateGeneratedAt(formats strfmt.Registry) error
 	return nil
 }
 
+// ContextValidate validates this health check results based on context it is used
+func (m *HealthCheckResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *HealthCheckResults) MarshalBinary() ([]byte, error) {
 	if m == nil {

pkg/models/ping_results.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
@@ -44,7 +46,6 @@ func (m *PingResults) Validate(formats strfmt.Registry) error {
 }
 
 func (m *PingResults) validateBootTime(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.BootTime) { // not required
 		return nil
 	}
@@ -57,7 +58,6 @@ func (m *PingResults) validateBootTime(formats strfmt.Registry) error {
 }
 
 func (m *PingResults) validateReceived(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.Received) { // not required
 		return nil
 	}
@@ -66,6 +66,38 @@ func (m *PingResults) validateReceived(formats strfmt.Registry) error {
 		if err := m.Received.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("received")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("received")
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ContextValidate validate this ping results based on the context it is used
+func (m *PingResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.contextValidateReceived(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *PingResults) contextValidateReceived(ctx context.Context, formats strfmt.Registry) error {
+
+	if m.Received != nil {
+		if err := m.Received.ContextValidate(ctx, formats); err != nil {
+			if ve, ok := err.(*errors.Validation); ok {
+				return ve.ValidateName("received")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("received")
 			}
 			return err
 		}

pkg/models/pod_result.go

@@ -6,6 +6,8 @@ package models
 // Editing this file might prove futile when you re-run the swagger generate command
 
 import (
+	"context"
+
 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
@@ -72,7 +74,6 @@ func (m *PodResult) Validate(formats strfmt.Registry) error {
 }
 
 func (m *PodResult) validateHostIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.HostIP) { // not required
 		return nil
 	}
@@ -85,7 +86,6 @@ func (m *PodResult) validateHostIP(formats strfmt.Registry) error {
 }
 
 func (m *PodResult) validatePingTime(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.PingTime) { // not required
 		return nil
 	}
@@ -98,7 +98,6 @@ func (m *PodResult) validatePingTime(formats strfmt.Registry) error {
 }
 
 func (m *PodResult) validatePodIP(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.PodIP) { // not required
 		return nil
 	}
@@ -111,7 +110,6 @@ func (m *PodResult) validatePodIP(formats strfmt.Registry) error {
 }
 
 func (m *PodResult) validateResponse(formats strfmt.Registry) error {
-
 	if swag.IsZero(m.Response) { // not required
 		return nil
 	}
@@ -120,6 +118,38 @@ func (m *PodResult) validateResponse(formats strfmt.Registry) error {
 		if err := m.Response.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("response")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("response")
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ContextValidate validate this pod result based on the context it is used
+func (m *PodResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	if err := m.contextValidateResponse(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+func (m *PodResult) contextValidateResponse(ctx context.Context, formats strfmt.Registry) error {
+
+	if m.Response != nil {
+		if err := m.Response.ContextValidate(ctx, formats); err != nil {
+			if ve, ok := err.(*errors.Validation); ok {
+				return ve.ValidateName("response")
+			} else if ce, ok := err.(*errors.CompositeError); ok {
+				return ce.ValidateName("response")
 			}
 			return err
 		}

pkg/models/probe_result.go

@@ -0,0 +1,56 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"context"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// ProbeResult probe result
+//
+// swagger:model ProbeResult
+type ProbeResult struct {
+
+	// error
+	Error string `json:"error,omitempty"`
+
+	// protocol
+	Protocol string `json:"protocol,omitempty"`
+
+	// response time ms
+	ResponseTimeMs int64 `json:"response-time-ms,omitempty"`
+}
+
+// Validate validates this probe result
+func (m *ProbeResult) Validate(formats strfmt.Registry) error {
+	return nil
+}
+
+// ContextValidate validates this probe result based on context it is used
+func (m *ProbeResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	return nil
+}
+
+// MarshalBinary interface implementation
+func (m *ProbeResult) MarshalBinary() ([]byte, error) {
+	if m == nil {
+		return nil, nil
+	}
+	return swag.WriteJSON(m)
+}
+
+// UnmarshalBinary interface implementation
+func (m *ProbeResult) UnmarshalBinary(b []byte) error {
+	var res ProbeResult
+	if err := swag.ReadJSON(b, &res); err != nil {
+		return err
+	}
+	*m = res
+	return nil
+}

pkg/models/probe_results.go

@@ -0,0 +1,78 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/validate"
+)
+
+// ProbeResults probe results
+//
+// swagger:model ProbeResults
+type ProbeResults map[string][]ProbeResult
+
+// Validate validates this probe results
+func (m ProbeResults) Validate(formats strfmt.Registry) error {
+	var res []error
+
+	for k := range m {
+
+		if err := validate.Required(k, "body", m[k]); err != nil {
+			return err
+		}
+
+		for i := 0; i < len(m[k]); i++ {
+
+			if err := m[k][i].Validate(formats); err != nil {
+				if ve, ok := err.(*errors.Validation); ok {
+					return ve.ValidateName(k + "." + strconv.Itoa(i))
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName(k + "." + strconv.Itoa(i))
+				}
+				return err
+			}
+
+		}
+
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// ContextValidate validate this probe results based on the context it is used
+func (m ProbeResults) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
+	var res []error
+
+	for k := range m {
+
+		for i := 0; i < len(m[k]); i++ {
+
+			if err := m[k][i].ContextValidate(ctx, formats); err != nil {
+				if ve, ok := err.(*errors.Validation); ok {
+					return ve.ValidateName(k + "." + strconv.Itoa(i))
+				} else if ce, ok := err.(*errors.CompositeError); ok {
+					return ce.ValidateName(k + "." + strconv.Itoa(i))
+				}
+				return err
+			}
+
+		}
+
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}

pkg/restapi/configure_goldpinger.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"crypto/tls"
 	"net/http"
-	"time"
 
 	"strings"
 
@@ -61,7 +60,7 @@ func configureAPI(api *operations.GoldpingerAPI) http.Handler {
 
 			ctx, cancel := context.WithTimeout(
 				params.HTTPRequest.Context(),
-				time.Duration(goldpinger.GoldpingerConfig.PingTimeoutMs)*time.Millisecond,
+				goldpinger.GoldpingerConfig.PingTimeout,
 			)
 			defer cancel()
 
@@ -74,7 +73,7 @@ func configureAPI(api *operations.GoldpingerAPI) http.Handler {
 
 			ctx, cancel := context.WithTimeout(
 				params.HTTPRequest.Context(),
-				time.Duration(goldpinger.GoldpingerConfig.CheckTimeoutMs)*time.Millisecond,
+				goldpinger.GoldpingerConfig.CheckTimeout,
 			)
 			defer cancel()
 
@@ -87,13 +86,31 @@ func configureAPI(api *operations.GoldpingerAPI) http.Handler {
 
 			ctx, cancel := context.WithTimeout(
 				params.HTTPRequest.Context(),
-				time.Duration(goldpinger.GoldpingerConfig.CheckAllTimeoutMs)*time.Millisecond,
+				goldpinger.GoldpingerConfig.CheckAllTimeout,
 			)
 			defer cancel()
 
 			return operations.NewCheckAllPodsOK().WithPayload(goldpinger.CheckNeighboursNeighbours(ctx))
 		})
 
+	api.ClusterHealthHandler = operations.ClusterHealthHandlerFunc(
+		func(params operations.ClusterHealthParams) middleware.Responder {
+			goldpinger.CountCall("received", "cluster_health")
+
+			ctx, cancel := context.WithTimeout(
+				params.HTTPRequest.Context(),
+				goldpinger.GoldpingerConfig.CheckAllTimeout,
+			)
+			defer cancel()
+
+			payload := goldpinger.CheckCluster(ctx)
+			if payload.OK {
+				return operations.NewClusterHealthOK().WithPayload(payload)
+			} else {
+				return operations.NewClusterHealthIMATeapot().WithPayload(payload)
+			}
+		})
+
 	api.HealthzHandler = operations.HealthzHandlerFunc(
 		func(params operations.HealthzParams) middleware.Responder {
 			goldpinger.CountCall("received", "healthz")

pkg/restapi/embedded_spec.go

@@ -58,6 +58,29 @@ func init() {
         }
       }
     },
+    "/cluster_health": {
+      "get": {
+        "description": "Checks the full graph. Returns a binary OK or not OK.",
+        "produces": [
+          "application/json"
+        ],
+        "operationId": "clusterHealth",
+        "responses": {
+          "200": {
+            "description": "Healthy cluster",
+            "schema": {
+              "$ref": "#/definitions/ClusterHealthResults"
+            }
+          },
+          "418": {
+            "description": "Unhealthy cluster",
+            "schema": {
+              "$ref": "#/definitions/ClusterHealthResults"
+            }
+          }
+        }
+      }
+    },
     "/healthz": {
       "get": {
         "description": "The healthcheck endpoint provides detailed information about the health of a web service. If each of the components required by the service are healthy, then the service is considered healthy and will return a 200 OK response. If any of the components needed by the service are unhealthy, then a 503 Service Unavailable response will be provided.",
@@ -180,11 +203,23 @@ func init() {
           "type": "integer",
           "format": "int32"
         },
+        "httpResults": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/HttpResults"
+          }
+        },
         "responses": {
           "type": "object",
           "additionalProperties": {
             "$ref": "#/definitions/CheckAllPodResult"
           }
+        },
+        "tcpResults": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/TcpResults"
+          }
         }
       }
     },
@@ -194,29 +229,60 @@ func init() {
         "dnsResults": {
           "$ref": "#/definitions/DnsResults"
         },
+        "httpResults": {
+          "$ref": "#/definitions/HttpResults"
+        },
         "podResults": {
           "type": "object",
           "additionalProperties": {
             "$ref": "#/definitions/PodResult"
           }
+        },
+        "tcpResults": {
+          "$ref": "#/definitions/TcpResults"
         }
       }
     },
-    "DnsResult": {
+    "ClusterHealthResults": {
+      "type": "object",
+      "required": [
+        "OK"
+      ],
       "properties": {
-        "error": {
-          "type": "string"
+        "OK": {
+          "type": "boolean",
+          "default": false
         },
-        "response-time-ms": {
-          "type": "number",
+        "duration-ns": {
+          "type": "integer",
           "format": "int64"
+        },
+        "generated-at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "nodesHealthy": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "nodesTotal": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "nodesUnhealthy": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
         }
       }
     },
     "DnsResults": {
       "type": "object",
       "additionalProperties": {
-        "$ref": "#/definitions/DnsResult"
+        "$ref": "#/definitions/ProbeResult"
       }
     },
     "HealthCheckResults": {
@@ -236,6 +302,12 @@ func init() {
         }
       }
     },
+    "HttpResults": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ProbeResult"
+      }
+    },
     "PingResults": {
       "type": "object",
       "properties": {
@@ -283,6 +355,23 @@ func init() {
           "format": "int32"
         }
       }
+    },
+    "ProbeResult": {
+      "properties": {
+        "error": {
+          "type": "string"
+        },
+        "response-time-ms": {
+          "type": "number",
+          "format": "int64"
+        }
+      }
+    },
+    "TcpResults": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ProbeResult"
+      }
     }
   }
 }`))
@@ -327,6 +416,29 @@ func init() {
         }
       }
     },
+    "/cluster_health": {
+      "get": {
+        "description": "Checks the full graph. Returns a binary OK or not OK.",
+        "produces": [
+          "application/json"
+        ],
+        "operationId": "clusterHealth",
+        "responses": {
+          "200": {
+            "description": "Healthy cluster",
+            "schema": {
+              "$ref": "#/definitions/ClusterHealthResults"
+            }
+          },
+          "418": {
+            "description": "Unhealthy cluster",
+            "schema": {
+              "$ref": "#/definitions/ClusterHealthResults"
+            }
+          }
+        }
+      }
+    },
     "/healthz": {
       "get": {
         "description": "The healthcheck endpoint provides detailed information about the health of a web service. If each of the components required by the service are healthy, then the service is considered healthy and will return a 200 OK response. If any of the components needed by the service are unhealthy, then a 503 Service Unavailable response will be provided.",
@@ -436,11 +548,23 @@ func init() {
           "type": "integer",
           "format": "int32"
         },
+        "httpResults": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/HttpResults"
+          }
+        },
         "responses": {
           "type": "object",
           "additionalProperties": {
             "$ref": "#/definitions/CheckAllPodResult"
           }
+        },
+        "tcpResults": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/TcpResults"
+          }
         }
       }
     },
@@ -466,29 +590,60 @@ func init() {
         "dnsResults": {
           "$ref": "#/definitions/DnsResults"
         },
+        "httpResults": {
+          "$ref": "#/definitions/HttpResults"
+        },
         "podResults": {
           "type": "object",
           "additionalProperties": {
             "$ref": "#/definitions/PodResult"
           }
+        },
+        "tcpResults": {
+          "$ref": "#/definitions/TcpResults"
         }
       }
     },
-    "DnsResult": {
+    "ClusterHealthResults": {
+      "type": "object",
+      "required": [
+        "OK"
+      ],
       "properties": {
-        "error": {
-          "type": "string"
+        "OK": {
+          "type": "boolean",
+          "default": false
         },
-        "response-time-ms": {
-          "type": "number",
+        "duration-ns": {
+          "type": "integer",
           "format": "int64"
+        },
+        "generated-at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "nodesHealthy": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "nodesTotal": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "nodesUnhealthy": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
         }
       }
     },
     "DnsResults": {
       "type": "object",
       "additionalProperties": {
-        "$ref": "#/definitions/DnsResult"
+        "$ref": "#/definitions/ProbeResult"
       }
     },
     "HealthCheckResults": {
@@ -508,6 +663,12 @@ func init() {
         }
       }
     },
+    "HttpResults": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ProbeResult"
+      }
+    },
     "PingResults": {
       "type": "object",
       "properties": {
@@ -555,6 +716,23 @@ func init() {
           "format": "int32"
         }
       }
+    },
+    "ProbeResult": {
+      "properties": {
+        "error": {
+          "type": "string"
+        },
+        "response-time-ms": {
+          "type": "number",
+          "format": "int64"
+        }
+      }
+    },
+    "TcpResults": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ProbeResult"
+      }
     }
   }
 }`))

pkg/restapi/operations/check_all_pods.go

@@ -29,7 +29,7 @@ func NewCheckAllPods(ctx *middleware.Context, handler CheckAllPodsHandler) *Chec
 	return &CheckAllPods{Context: ctx, Handler: handler}
 }
 
-/*CheckAllPods swagger:route GET /check_all checkAllPods
+/* CheckAllPods swagger:route GET /check_all checkAllPods
 
 Queries the API server for all other pods in this service, and makes all of them query all of their neighbours, using their pods IPs. Calls their /check endpoint.
 
@@ -42,17 +42,15 @@ type CheckAllPods struct {
 func (o *CheckAllPods) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	route, rCtx, _ := o.Context.RouteInfo(r)
 	if rCtx != nil {
-		r = rCtx
+		*r = *rCtx
 	}
 	var Params = NewCheckAllPodsParams()
-
 	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
 		o.Context.Respond(rw, r, route.Produces, route, err)
 		return
 	}
 
 	res := o.Handler.Handle(Params) // actually handle the request
-
 	o.Context.Respond(rw, r, route.Produces, route, res)
 
 }

pkg/restapi/operations/check_all_pods_parameters.go

@@ -13,7 +13,8 @@ import (
 )
 
 // NewCheckAllPodsParams creates a new CheckAllPodsParams object
-// no default values defined in spec.
+//
+// There are no default values defined in the spec.
 func NewCheckAllPodsParams() CheckAllPodsParams {
 
 	return CheckAllPodsParams{}

pkg/restapi/operations/check_service_pods.go

@@ -29,7 +29,7 @@ func NewCheckServicePods(ctx *middleware.Context, handler CheckServicePodsHandle
 	return &CheckServicePods{Context: ctx, Handler: handler}
 }
 
-/*CheckServicePods swagger:route GET /check checkServicePods
+/* CheckServicePods swagger:route GET /check checkServicePods
 
 Queries the API server for all other pods in this service, and pings them via their pods IPs. Calls their /ping endpoint
 
@@ -42,17 +42,15 @@ type CheckServicePods struct {
 func (o *CheckServicePods) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	route, rCtx, _ := o.Context.RouteInfo(r)
 	if rCtx != nil {
-		r = rCtx
+		*r = *rCtx
 	}
 	var Params = NewCheckServicePodsParams()
-
 	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
 		o.Context.Respond(rw, r, route.Produces, route, err)
 		return
 	}
 
 	res := o.Handler.Handle(Params) // actually handle the request
-
 	o.Context.Respond(rw, r, route.Produces, route, res)
 
 }

pkg/restapi/operations/check_service_pods_parameters.go

@@ -13,7 +13,8 @@ import (
 )
 
 // NewCheckServicePodsParams creates a new CheckServicePodsParams object
-// no default values defined in spec.
+//
+// There are no default values defined in the spec.
 func NewCheckServicePodsParams() CheckServicePodsParams {
 
 	return CheckServicePodsParams{}

pkg/restapi/operations/cluster_health.go

@@ -0,0 +1,56 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+	"net/http"
+
+	"github.com/go-openapi/runtime/middleware"
+)
+
+// ClusterHealthHandlerFunc turns a function with the right signature into a cluster health handler
+type ClusterHealthHandlerFunc func(ClusterHealthParams) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ClusterHealthHandlerFunc) Handle(params ClusterHealthParams) middleware.Responder {
+	return fn(params)
+}
+
+// ClusterHealthHandler interface for that can handle valid cluster health params
+type ClusterHealthHandler interface {
+	Handle(ClusterHealthParams) middleware.Responder
+}
+
+// NewClusterHealth creates a new http.Handler for the cluster health operation
+func NewClusterHealth(ctx *middleware.Context, handler ClusterHealthHandler) *ClusterHealth {
+	return &ClusterHealth{Context: ctx, Handler: handler}
+}
+
+/* ClusterHealth swagger:route GET /cluster_health clusterHealth
+
+Checks the full graph. Returns a binary OK or not OK.
+
+*/
+type ClusterHealth struct {
+	Context *middleware.Context
+	Handler ClusterHealthHandler
+}
+
+func (o *ClusterHealth) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		*r = *rCtx
+	}
+	var Params = NewClusterHealthParams()
+	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
+		o.Context.Respond(rw, r, route.Produces, route, err)
+		return
+	}
+
+	res := o.Handler.Handle(Params) // actually handle the request
+	o.Context.Respond(rw, r, route.Produces, route, res)
+
+}

pkg/restapi/operations/cluster_health_parameters.go

@@ -0,0 +1,46 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"net/http"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/runtime/middleware"
+)
+
+// NewClusterHealthParams creates a new ClusterHealthParams object
+//
+// There are no default values defined in the spec.
+func NewClusterHealthParams() ClusterHealthParams {
+
+	return ClusterHealthParams{}
+}
+
+// ClusterHealthParams contains all the bound params for the cluster health operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters clusterHealth
+type ClusterHealthParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+}
+
+// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
+// for simple values it will use straight method calls.
+//
+// To ensure default values, the struct must have been initialized with NewClusterHealthParams() beforehand.
+func (o *ClusterHealthParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}

pkg/restapi/operations/cluster_health_responses.go

@@ -0,0 +1,102 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"net/http"
+
+	"github.com/go-openapi/runtime"
+
+	"github.com/bloomberg/goldpinger/v3/pkg/models"
+)
+
+// ClusterHealthOKCode is the HTTP code returned for type ClusterHealthOK
+const ClusterHealthOKCode int = 200
+
+/*ClusterHealthOK Healthy cluster
+
+swagger:response clusterHealthOK
+*/
+type ClusterHealthOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ClusterHealthResults `json:"body,omitempty"`
+}
+
+// NewClusterHealthOK creates ClusterHealthOK with default headers values
+func NewClusterHealthOK() *ClusterHealthOK {
+
+	return &ClusterHealthOK{}
+}
+
+// WithPayload adds the payload to the cluster health o k response
+func (o *ClusterHealthOK) WithPayload(payload *models.ClusterHealthResults) *ClusterHealthOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the cluster health o k response
+func (o *ClusterHealthOK) SetPayload(payload *models.ClusterHealthResults) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ClusterHealthOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.WriteHeader(200)
+	if o.Payload != nil {
+		payload := o.Payload
+		if err := producer.Produce(rw, payload); err != nil {
+			panic(err) // let the recovery middleware deal with this
+		}
+	}
+}
+
+// ClusterHealthIMATeapotCode is the HTTP code returned for type ClusterHealthIMATeapot
+const ClusterHealthIMATeapotCode int = 418
+
+/*ClusterHealthIMATeapot Unhealthy cluster
+
+swagger:response clusterHealthIMATeapot
+*/
+type ClusterHealthIMATeapot struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ClusterHealthResults `json:"body,omitempty"`
+}
+
+// NewClusterHealthIMATeapot creates ClusterHealthIMATeapot with default headers values
+func NewClusterHealthIMATeapot() *ClusterHealthIMATeapot {
+
+	return &ClusterHealthIMATeapot{}
+}
+
+// WithPayload adds the payload to the cluster health i m a teapot response
+func (o *ClusterHealthIMATeapot) WithPayload(payload *models.ClusterHealthResults) *ClusterHealthIMATeapot {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the cluster health i m a teapot response
+func (o *ClusterHealthIMATeapot) SetPayload(payload *models.ClusterHealthResults) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ClusterHealthIMATeapot) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.WriteHeader(418)
+	if o.Payload != nil {
+		payload := o.Payload
+		if err := producer.Produce(rw, payload); err != nil {
+			panic(err) // let the recovery middleware deal with this
+		}
+	}
+}

pkg/restapi/operations/cluster_health_urlbuilder.go

@@ -0,0 +1,84 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+	"errors"
+	"net/url"
+	golangswaggerpaths "path"
+)
+
+// ClusterHealthURL generates an URL for the cluster health operation
+type ClusterHealthURL struct {
+	_basePath string
+}
+
+// WithBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *ClusterHealthURL) WithBasePath(bp string) *ClusterHealthURL {
+	o.SetBasePath(bp)
+	return o
+}
+
+// SetBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *ClusterHealthURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ClusterHealthURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/cluster_health"
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ClusterHealthURL) Must(u *url.URL, err error) *url.URL {
+	if err != nil {
+		panic(err)
+	}
+	if u == nil {
+		panic("url can't be nil")
+	}
+	return u
+}
+
+// String returns the string representation of the path with query string
+func (o *ClusterHealthURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ClusterHealthURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ClusterHealthURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ClusterHealthURL")
+	}
+
+	base, err := o.Build()
+	if err != nil {
+		return nil, err
+	}
+
+	base.Scheme = scheme
+	base.Host = host
+	return base, nil
+}
+
+// StringFull returns the string representation of a complete url
+func (o *ClusterHealthURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

pkg/restapi/operations/goldpinger_api.go

@@ -32,6 +32,7 @@ func NewGoldpingerAPI(spec *loads.Document) *GoldpingerAPI {
 		PreServerShutdown:   func() {},
 		ServerShutdown:      func() {},
 		spec:                spec,
+		useSwaggerUI:        false,
 		ServeError:          errors.ServeError,
 		BasicAuthenticator:  security.BasicAuth,
 		APIKeyAuthenticator: security.APIKeyAuth,
@@ -47,6 +48,9 @@ func NewGoldpingerAPI(spec *loads.Document) *GoldpingerAPI {
 		CheckServicePodsHandler: CheckServicePodsHandlerFunc(func(params CheckServicePodsParams) middleware.Responder {
 			return middleware.NotImplemented("operation CheckServicePods has not yet been implemented")
 		}),
+		ClusterHealthHandler: ClusterHealthHandlerFunc(func(params ClusterHealthParams) middleware.Responder {
+			return middleware.NotImplemented("operation ClusterHealth has not yet been implemented")
+		}),
 		HealthzHandler: HealthzHandlerFunc(func(params HealthzParams) middleware.Responder {
 			return middleware.NotImplemented("operation Healthz has not yet been implemented")
 		}),
@@ -67,13 +71,16 @@ type GoldpingerAPI struct {
 	defaultConsumes string
 	defaultProduces string
 	Middleware      func(middleware.Builder) http.Handler
+	useSwaggerUI    bool
 
 	// BasicAuthenticator generates a runtime.Authenticator from the supplied basic auth function.
 	// It has a default implementation in the security package, however you can replace it for your particular usage.
 	BasicAuthenticator func(security.UserPassAuthentication) runtime.Authenticator
+
 	// APIKeyAuthenticator generates a runtime.Authenticator from the supplied token auth function.
 	// It has a default implementation in the security package, however you can replace it for your particular usage.
 	APIKeyAuthenticator func(string, string, security.TokenAuthentication) runtime.Authenticator
+
 	// BearerAuthenticator generates a runtime.Authenticator from the supplied bearer token auth function.
 	// It has a default implementation in the security package, however you can replace it for your particular usage.
 	BearerAuthenticator func(string, security.ScopedTokenAuthentication) runtime.Authenticator
@@ -90,10 +97,13 @@ type GoldpingerAPI struct {
 	CheckAllPodsHandler CheckAllPodsHandler
 	// CheckServicePodsHandler sets the operation handler for the check service pods operation
 	CheckServicePodsHandler CheckServicePodsHandler
+	// ClusterHealthHandler sets the operation handler for the cluster health operation
+	ClusterHealthHandler ClusterHealthHandler
 	// HealthzHandler sets the operation handler for the healthz operation
 	HealthzHandler HealthzHandler
 	// PingHandler sets the operation handler for the ping operation
 	PingHandler PingHandler
+
 	// ServeError is called when an error is received, there is a default handler
 	// but you can set your own with this
 	ServeError func(http.ResponseWriter, *http.Request, error)
@@ -113,6 +123,16 @@ type GoldpingerAPI struct {
 	Logger func(string, ...interface{})
 }
 
+// UseRedoc for documentation at /docs
+func (o *GoldpingerAPI) UseRedoc() {
+	o.useSwaggerUI = false
+}
+
+// UseSwaggerUI for documentation at /docs
+func (o *GoldpingerAPI) UseSwaggerUI() {
+	o.useSwaggerUI = true
+}
+
 // SetDefaultProduces sets the default produces media type
 func (o *GoldpingerAPI) SetDefaultProduces(mediaType string) {
 	o.defaultProduces = mediaType
@@ -166,6 +186,9 @@ func (o *GoldpingerAPI) Validate() error {
 	if o.CheckServicePodsHandler == nil {
 		unregistered = append(unregistered, "CheckServicePodsHandler")
 	}
+	if o.ClusterHealthHandler == nil {
+		unregistered = append(unregistered, "ClusterHealthHandler")
+	}
 	if o.HealthzHandler == nil {
 		unregistered = append(unregistered, "HealthzHandler")
 	}
@@ -271,6 +294,10 @@ func (o *GoldpingerAPI) initHandlerCache() {
 	if o.handlers["GET"] == nil {
 		o.handlers["GET"] = make(map[string]http.Handler)
 	}
+	o.handlers["GET"]["/cluster_health"] = NewClusterHealth(o.context, o.ClusterHealthHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
 	o.handlers["GET"]["/healthz"] = NewHealthz(o.context, o.HealthzHandler)
 	if o.handlers["GET"] == nil {
 		o.handlers["GET"] = make(map[string]http.Handler)
@@ -286,6 +313,9 @@ func (o *GoldpingerAPI) Serve(builder middleware.Builder) http.Handler {
 	if o.Middleware != nil {
 		return o.Middleware(builder)
 	}
+	if o.useSwaggerUI {
+		return o.context.APIHandlerSwaggerUI(builder)
+	}
 	return o.context.APIHandler(builder)
 }
 

pkg/restapi/operations/healthz.go

@@ -29,7 +29,7 @@ func NewHealthz(ctx *middleware.Context, handler HealthzHandler) *Healthz {
 	return &Healthz{Context: ctx, Handler: handler}
 }
 
-/*Healthz swagger:route GET /healthz healthz
+/* Healthz swagger:route GET /healthz healthz
 
 The healthcheck endpoint provides detailed information about the health of a web service. If each of the components required by the service are healthy, then the service is considered healthy and will return a 200 OK response. If any of the components needed by the service are unhealthy, then a 503 Service Unavailable response will be provided.
 
@@ -42,17 +42,15 @@ type Healthz struct {
 func (o *Healthz) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	route, rCtx, _ := o.Context.RouteInfo(r)
 	if rCtx != nil {
-		r = rCtx
+		*r = *rCtx
 	}
 	var Params = NewHealthzParams()
-
 	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
 		o.Context.Respond(rw, r, route.Produces, route, err)
 		return
 	}
 
 	res := o.Handler.Handle(Params) // actually handle the request
-
 	o.Context.Respond(rw, r, route.Produces, route, res)
 
 }

pkg/restapi/operations/healthz_parameters.go

@@ -13,7 +13,8 @@ import (
 )
 
 // NewHealthzParams creates a new HealthzParams object
-// no default values defined in spec.
+//
+// There are no default values defined in the spec.
 func NewHealthzParams() HealthzParams {
 
 	return HealthzParams{}

pkg/restapi/operations/ping.go

@@ -29,7 +29,7 @@ func NewPing(ctx *middleware.Context, handler PingHandler) *Ping {
 	return &Ping{Context: ctx, Handler: handler}
 }
 
-/*Ping swagger:route GET /ping ping
+/* Ping swagger:route GET /ping ping
 
 return query stats
 
@@ -42,17 +42,15 @@ type Ping struct {
 func (o *Ping) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	route, rCtx, _ := o.Context.RouteInfo(r)
 	if rCtx != nil {
-		r = rCtx
+		*r = *rCtx
 	}
 	var Params = NewPingParams()
-
 	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
 		o.Context.Respond(rw, r, route.Produces, route, err)
 		return
 	}
 
 	res := o.Handler.Handle(Params) // actually handle the request
-
 	o.Context.Respond(rw, r, route.Produces, route, res)
 
 }

pkg/restapi/operations/ping_parameters.go

@@ -13,7 +13,8 @@ import (
 )
 
 // NewPingParams creates a new PingParams object
-// no default values defined in spec.
+//
+// There are no default values defined in the spec.
 func NewPingParams() PingParams {
 
 	return PingParams{}

pkg/restapi/server.go

@@ -305,9 +305,6 @@ func (s *Server) Serve() (err error) {
 			s.Fatalf("no certificate was configured for TLS")
 		}
 
-		// must have at least one certificate or panics
-		httpsServer.TLSConfig.BuildNameToCertificate()
-
 		configureServer(httpsServer, "https", s.httpsServerL.Addr().String())
 
 		servers = append(servers, httpsServer)

static/index.html

@@ -213,6 +213,7 @@ var loadingDialog = function(enable){
 var global_data = undefined;
 var s; // the sigma graph
 
+
 var main = function(timeout){
 
         timeout = timeout || Number($("#timeout").val()) || 5.0;
@@ -229,7 +230,6 @@ var main = function(timeout){
 
                 // prepare nodes
                 var nodes = [];
-                var dnsCheckNodes = [];
                 var podIPs = [];
                 var resp = data.responses;
                 for (let podIP in resp) {
@@ -284,39 +284,44 @@ var main = function(timeout){
                         })
                 })
                 console.log(nodes);
-
-                if ('dnsResults' in data) {
-                    var yoffset = 0;
-                    for (let checkedHost in data.dnsResults) {
-                        let value = data.dnsResults[checkedHost];
-                        var allOk = true;
-                        for (let pod in value) {
-                            var podData = value[pod];
-                            var elapsed = 0;
-                            if ('response-time-ms' in podData) {
-                                elapsed = podData['response-time-ms'];
-                            }
-                            var podOk = (!('error' in podData));
-                            allOk = allOk && podOk
-                            edges.push({
-                                source: pod,
-                                target: checkedHost,
-                                _data: {
+                 
+                var probeResultsNodes = [];
+                if ('probeResults' in data) {
+                  var yoffset = 0;
+                  for (let checkedHost in data.probeResults) {
+                      let  value = data.probeResults[checkedHost];
+                      var allOk = true;
+                      for (let pod in value) {
+                          for (var i = 0; i < value[pod].length; i++){
+                                var elapsed = 0;
+                                var podData = value[pod][i];
+                                if ('response-time-ms' in podData) {
+                                        elapsed = podData['response-time-ms'];
+                                }
+                                var podOk = (!('error' in podData));
+                                allOk = allOk && podOk
+                                edges.push({
+                                  source: pod,
+                                  target: checkedHost,
+                                  _data: {
                                     "OK": podOk,
                                     "elapsed": elapsed,
-                                    "isDNSCheckNode": true,
-                                }
-                            });
+                                    "isprobeResultsNode": true,
+                                  }
+                                });              
+                          } 
                         }
+
                         value["OK"] = allOk
-                        dnsCheckNodes.push({
-                            "label": checkedHost,
-                            "id": checkedHost,
-                            "x": 0,
-                            "y": 0,
-                            _data: value,
-                        });
-                    }
+                        probeResultsNodes.push({
+                                "label": checkedHost,
+                                "id": checkedHost,
+                                "x": 0,
+                                "y": 0,
+                                _data: value,
+                         });
+           
+                  } 
                 }
 
                 // build the actual graph
@@ -351,7 +356,7 @@ var main = function(timeout){
                 });
 
                 // generate any dns nodes on the graph
-                dnsCheckNodes.forEach(function(node, i, a){
+                probeResultsNodes.forEach(function(node, i, a){
                         node.x = 2;
                         node.y = (0.6 * i / a.length) - 0.8;
                         node.size = 10;
@@ -359,7 +364,6 @@ var main = function(timeout){
                         if (!node._data.OK) {
                                 node.color = "red";
                         }
-                        //console.log(node);
                         s.graph.addNode(node);
                 });
 
@@ -374,7 +378,7 @@ var main = function(timeout){
                         if (!edge._data.OK) {
                                 color = "red";
                         }
-                        if ("isDNSCheckNode" in edge._data) {
+                        if ("isprobeResultsNode" in edge._data) {
                                 type = "dashed";
                         }
                         var edge = {

swagger.yml

@@ -12,17 +12,21 @@ definitions:
         type: integer
       ping:
         type: integer
-  DnsResult:
+  ProbeResult:
     properties:
       response-time-ms:
         type: number
         format: int64
       error:
         type: string
-  DnsResults:
+      protocol:
+        type: string
+  ProbeResults:
     type: object
     additionalProperties:
-      $ref: '#/definitions/DnsResult'
+      type: array
+      items:
+        $ref: '#/definitions/ProbeResult' 
   PingResults:
     type: object
     properties:
@@ -60,8 +64,8 @@ definitions:
   CheckResults:
     type: object
     properties:
-      dnsResults:
-        $ref: '#/definitions/DnsResults'
+      probeResults:
+        $ref: '#/definitions/ProbeResults'    
       podResults:
         type: object
         additionalProperties:
@@ -110,10 +114,10 @@ definitions:
             podIP:
               type: string
               format: ipv4
-      dnsResults:
+      probeResults:
         type: object
         additionalProperties:
-          $ref: '#/definitions/DnsResults'
+          $ref: '#/definitions/ProbeResults'       
       responses:
         type: object
         additionalProperties:
@@ -130,6 +134,31 @@ definitions:
       duration-ns:
         type: integer
         format: int64
+  ClusterHealthResults:
+    type: object
+    properties:
+      OK:
+        type: boolean
+        default: false
+      nodesHealthy:
+        type: array
+        items:
+          type: string
+      nodesUnhealthy:
+        type: array
+        items:
+          type: string
+      nodesTotal:
+        type: integer
+        format: int64
+      generated-at:
+        type: string
+        format: date-time
+      duration-ns:
+        type: integer
+        format: int64
+    required:
+    - OK
 paths:
   /ping:
     get:
@@ -167,6 +196,21 @@ paths:
           description: Success, return response
           schema:
             $ref: '#/definitions/CheckAllResults'
+  /cluster_health:
+    get:
+      description: Checks the full graph. Returns a binary OK or not OK.
+      produces:
+        - application/json
+      operationId: clusterHealth
+      responses:
+        200:
+          description: Healthy cluster
+          schema:
+            $ref: '#/definitions/ClusterHealthResults'
+        418:
+          description: Unhealthy cluster
+          schema:
+            $ref: '#/definitions/ClusterHealthResults'
   /healthz:
     get:
       description:  The healthcheck endpoint provides detailed information about