refactor app status reporter

Author: bhmj

appstatus/appstatus.go

@@ -0,0 +1,106 @@
+package appstatus
+
+import (
+	"errors"
+	"sync"
+)
+
+var errAlreadyRegistered = errors.New("service already registered")
+
+type StatusReporter interface {
+	GetServiceReporter(serviceName string) (ServiceStatusReporter, error)
+	IsReady() bool
+	IsAlive() bool
+}
+
+type ServiceStatusReporter interface {
+	Ready()    // service is up
+	NotReady() // temporary outage; expecting recovery
+	Dead()     // service is down
+}
+
+type statusReporter struct {
+	sync.RWMutex
+	alive bool
+	ready map[string]bool
+}
+
+type serviceReporter struct {
+	statusReporter *statusReporter
+	serviceName    string
+}
+
+// ---------------------------------------------------------------
+
+func New() StatusReporter {
+	return &statusReporter{
+		ready: make(map[string]bool),
+		alive: true,
+	}
+}
+
+func (s *statusReporter) GetServiceReporter(serviceName string) (ServiceStatusReporter, error) {
+	s.Lock()
+	defer s.Unlock()
+	if _, found := s.ready[serviceName]; found {
+		return nil, errAlreadyRegistered
+	}
+	s.ready[serviceName] = false
+	return &serviceReporter{
+		statusReporter: s,
+		serviceName:    serviceName,
+	}, nil
+}
+
+func (s *statusReporter) Ready(name string) {
+	s.Lock()
+	defer s.Unlock()
+	s.ready[name] = true
+}
+
+func (s *statusReporter) NotReady(name string) {
+	s.Lock()
+	defer s.Unlock()
+	s.ready[name] = false
+}
+
+func (s *statusReporter) Dead() {
+	s.Lock()
+	defer s.Unlock()
+	s.alive = false
+}
+
+func (s *statusReporter) IsReady() bool {
+	s.RLock()
+	defer s.RUnlock()
+	for _, ready := range s.ready {
+		if !ready {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *statusReporter) IsAlive() bool {
+	s.RLock()
+	defer s.RUnlock()
+	return s.alive
+}
+
+func (s *serviceReporter) Ready() {
+	s.statusReporter.Lock()
+	defer s.statusReporter.Unlock()
+	s.statusReporter.ready[s.serviceName] = true
+}
+
+func (s *serviceReporter) NotReady() {
+	s.statusReporter.Lock()
+	defer s.statusReporter.Unlock()
+	s.statusReporter.ready[s.serviceName] = false
+}
+
+func (s *serviceReporter) Dead() {
+	s.statusReporter.Lock()
+	defer s.statusReporter.Unlock()
+	s.statusReporter.alive = false
+}

podstatus/healthcheck_server.go healthserver/healthcheck_server.gopodstatus/healthcheck_server.go renamed to healthserver/healthcheck_server.go

@@ -1,4 +1,4 @@
-package podstatus
+package appstatus
 
 import (
 	"context"
@@ -12,15 +12,20 @@ import (
 	"github.com/bhmj/goblocks/log"
 )
 
+type AppStatus interface {
+	IsReady() bool
+	IsAlive() bool
+}
+
 type HealthcheckServer struct {
-	server         *http.Server
-	statusReporter PodStatus
-	logger         log.MetaLogger
-	port           int
+	server    *http.Server
+	appStatus AppStatus
+	logger    log.MetaLogger
+	port      int
 }
 
-func NewHealthcheckServer(logger log.MetaLogger, port int, statusReporter PodStatus) *HealthcheckServer {
-	health := &HealthcheckServer{statusReporter: statusReporter, logger: logger, port: port}
+func NewHealthcheckServer(logger log.MetaLogger, port int, appStatus AppStatus) *HealthcheckServer {
+	health := &HealthcheckServer{appStatus: appStatus, logger: logger, port: port}
 	router := http.NewServeMux()
 	router.HandleFunc("GET /ready", health.ReadyHandler)
 	router.HandleFunc("GET /alive", health.AliveHandler)
@@ -60,7 +65,7 @@ func (s *HealthcheckServer) ReadyHandler(w http.ResponseWriter, r *http.Request)
 	defer r.Body.Close()
 	_, _ = io.Copy(io.Discard, r.Body)
 
-	if s.statusReporter.IsReady() {
+	if s.appStatus.IsReady() {
 		w.WriteHeader(http.StatusOK)
 	} else {
 		w.WriteHeader(http.StatusInternalServerError)
@@ -71,7 +76,7 @@ func (s *HealthcheckServer) AliveHandler(w http.ResponseWriter, r *http.Request)
 	defer r.Body.Close()
 	_, _ = io.Copy(io.Discard, r.Body)
 
-	if s.statusReporter.IsAlive() {
+	if s.appStatus.IsAlive() {
 		w.WriteHeader(http.StatusOK)
 	} else {
 		w.WriteHeader(http.StatusInternalServerError)