Use github.com/heptio/healthcheck

Rather than a handrolled solution, this commit uses heptio's healthcheck
library. Future consumers of the health check handler need only to
register liveness or readiness probes.

Gopkg.toml

@@ -42,4 +42,7 @@
 
 [[constraint]]
   name = "google.golang.org/grpc"
-  version = "1.8.0"
+  version = "1.8.0"
+[[constraint]]
+  branch = "master"
+  name = "github.com/heptiolabs/healthcheck"

cmd/controller/main.go

@@ -16,6 +16,7 @@
 package main
 
 import (
+	"net/http"
 	"strings"
 	"time"
 
@@ -25,6 +26,8 @@ import (
 	"agones.dev/agones/pkg/gameservers"
 	"agones.dev/agones/pkg/util/runtime"
 	"agones.dev/agones/pkg/util/signals"
+	"github.com/heptiolabs/healthcheck"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
@@ -100,19 +103,40 @@ func main() {
 		logrus.WithError(err).Fatal("Could not create the agones api clientset")
 	}
 
+	health := healthcheck.NewHandler()
 	agonesInformerFactory := externalversions.NewSharedInformerFactory(agonesClient, 30*time.Second)
 	kubeInformationFactory := informers.NewSharedInformerFactory(kubeClient, 30*time.Second)
-	c := gameservers.NewController(minPort, maxPort, sidecarImage, alwaysPullSidecar, kubeClient, kubeInformationFactory, extClient, agonesClient, agonesInformerFactory)
+	c := gameservers.NewController(health, minPort, maxPort, sidecarImage, alwaysPullSidecar, kubeClient, kubeInformationFactory, extClient, agonesClient, agonesInformerFactory)
 
 	stop := signals.NewStopChannel()
 
 	kubeInformationFactory.Start(stop)
 	agonesInformerFactory.Start(stop)
 
+	go startHealthCheck(health)
+
 	err = c.Run(2, stop)
 	if err != nil {
 		logrus.WithError(err).Fatal("Could not run gameserver controller")
 	}
 
 	logrus.Info("Shut down gameserver controller")
 }
+
+func startHealthCheck(h healthcheck.Handler) {
+	logrus.Info("Starting health check...")
+	srv := &http.Server{
+		Addr:    ":8080",
+		Handler: h,
+	}
+	defer srv.Close() // nolint: errcheck
+
+	if err := srv.ListenAndServe(); err != nil {
+		if err == http.ErrServerClosed {
+			logrus.WithError(err).Info("health check: http server closed")
+		} else {
+			err := errors.Wrap(err, "Could not listen on :8080")
+			runtime.HandleError(logrus.WithError(err), err)
+		}
+	}
+}

pkg/gameservers/controller.go

@@ -16,7 +16,6 @@ package gameservers
 
 import (
 	"fmt"
-	"net/http"
 	"time"
 
 	"agones.dev/agones/pkg/apis/stable"
@@ -26,6 +25,7 @@ import (
 	"agones.dev/agones/pkg/client/informers/externalversions"
 	listerv1alpha1 "agones.dev/agones/pkg/client/listers/stable/v1alpha1"
 	"agones.dev/agones/pkg/util/runtime"
+	"github.com/heptiolabs/healthcheck"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
@@ -65,14 +65,15 @@ type Controller struct {
 	queue                  workqueue.RateLimitingInterface
 	portAllocator          *PortAllocator
 	healthController       *HealthController
-	server                 *http.Server
 	recorder               record.EventRecorder
 	// this allows for overwriting for testing purposes
 	syncHandler func(string) error
 }
 
 // NewController returns a new gameserver crd controller
-func NewController(minPort, maxPort int32,
+func NewController(
+	health healthcheck.Handler,
+	minPort, maxPort int32,
 	sidecarImage string,
 	alwaysPullSidecarImage bool,
 	kubeClient kubernetes.Interface,
@@ -131,20 +132,6 @@ func NewController(minPort, maxPort int32,
 
 	c.syncHandler = c.syncGameServer
 
-	mux := http.NewServeMux()
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
-		_, err := w.Write([]byte("ok"))
-		if err != nil {
-			logrus.WithError(err).Error("could not send ok response on healthz")
-			w.WriteHeader(http.StatusInternalServerError)
-		}
-	})
-
-	c.server = &http.Server{
-		Addr:    ":8080",
-		Handler: mux,
-	}
-
 	return c
 }
 
@@ -153,19 +140,6 @@ func NewController(minPort, maxPort int32,
 func (c Controller) Run(threadiness int, stop <-chan struct{}) error {
 	defer c.queue.ShutDown()
 
-	logrus.Info("Starting health check...")
-	go func() {
-		if err := c.server.ListenAndServe(); err != nil {
-			if err == http.ErrServerClosed {
-				logrus.WithError(err).Info("health check: http server closed")
-			} else {
-				err := errors.Wrap(err, "Could not listen on :8080")
-				runtime.HandleError(logrus.WithError(err), err)
-			}
-		}
-	}()
-	defer c.server.Close() // nolint: errcheck
-
 	err := c.waitForEstablishedCRD()
 	if err != nil {
 		return err

pkg/gameservers/controller_test.go

@@ -16,13 +16,13 @@ package gameservers
 
 import (
 	"fmt"
-	"net/http"
 	"sync"
 	"testing"
 	"time"
 
 	"agones.dev/agones/pkg/apis/stable"
 	"agones.dev/agones/pkg/apis/stable/v1alpha1"
+	"github.com/heptiolabs/healthcheck"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
@@ -208,27 +208,6 @@ func TestWatchGameServers(t *testing.T) {
 	assert.Equal(t, "default/test", <-received)
 }
 
-func TestHealthCheck(t *testing.T) {
-	c, mocks := newFakeController()
-	mocks.extClient.AddReactor("get", "customresourcedefinitions", func(action k8stesting.Action) (bool, runtime.Object, error) {
-		return true, newEstablishedCRD(), nil
-	})
-
-	c.syncHandler = func(name string) error {
-		return nil
-	}
-
-	stop, cancel := startInformers(mocks, c.gameServerSynced)
-	defer cancel()
-
-	go func() {
-		err := c.Run(1, stop)
-		assert.Nil(t, err, "Run should not error")
-	}()
-
-	testHTTPHealth(t, "http://localhost:8080/healthz", "ok", http.StatusOK)
-}
-
 func TestSyncGameServerDeletionTimestamp(t *testing.T) {
 	t.Parallel()
 
@@ -778,7 +757,7 @@ func testWithNonZeroDeletionTimestamp(t *testing.T, state v1alpha1.State, f func
 // newFakeController returns a controller, backed by the fake Clientset
 func newFakeController() (*Controller, mocks) {
 	m := newMocks()
-	c := NewController(10, 20, "sidecar:dev", false,
+	c := NewController(healthcheck.NewHandler(), 10, 20, "sidecar:dev", false,
 		m.kubeClient, m.kubeInformationFactory, m.extClient, m.agonesClient, m.agonesInformerFactory)
 	c.recorder = m.fakeRecorder
 	return c, m