snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/healthcheck/check.go

@@ -0,0 +1,128 @@
+package healthcheck
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+)
+
+type (
+	checkFn func(ctx context.Context) error
+
+	Meta struct {
+		Label       string
+		Description string
+	}
+
+	check struct {
+		fn checkFn
+		*Meta
+	}
+
+	result struct {
+		err error
+		*Meta
+	}
+
+	results []*result
+	checks  struct {
+		l  sync.RWMutex
+		cc []*check
+	}
+)
+
+var (
+	defaults *checks
+)
+
+func init() {
+	defaults = New()
+}
+
+func Defaults() *checks {
+	return defaults
+}
+
+func New() *checks {
+	return &checks{cc: []*check{}}
+}
+
+// Add appends new check
+func (c *checks) Add(fn checkFn, label string, description ...string) {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	c.cc = append(c.cc, &check{fn, &Meta{Label: label, Description: strings.Join(description, "")}})
+}
+
+func (c *checks) Run(ctx context.Context) results {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	var rr = make([]*result, len(c.cc))
+
+	for i, c := range c.cc {
+		rr[i] = &result{c.fn(ctx), c.Meta}
+	}
+
+	return rr
+}
+
+func (rr results) Healthy() bool {
+	for _, c := range rr {
+		if c.err != nil {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (rr results) String() string {
+	buf := &bytes.Buffer{}
+
+	rr.WriteTo(buf)
+
+	return buf.String()
+}
+
+func (rr results) WriteTo(w io.Writer) (int64, error) {
+	var (
+		p = func(f string, aa ...interface{}) {
+			_, _ = fmt.Fprintf(w, f, aa...)
+		}
+	)
+
+	for _, r := range rr {
+		if r.IsHealthy() {
+			p("PASS")
+		} else {
+			p("FAIL")
+		}
+
+		p(" %s", r.Label)
+
+		if !r.IsHealthy() {
+			p(": %v", r.Error())
+		}
+
+		p("\n")
+	}
+
+	return 0, nil
+}
+
+func (r *result) IsHealthy() bool {
+	return r != nil && r.err == nil
+}
+
+func (r *result) Error() string {
+	if r == nil || r.err == nil {
+		return ""
+	}
+
+	return r.err.Error()
+}

server/pkg/healthcheck/check_test.go

@@ -0,0 +1,82 @@
+package healthcheck
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Healthy(t *testing.T) {
+	tests := []struct {
+		name    string
+		checks  []*check
+		healthy bool
+		string  string
+	}{
+		{
+			"should be healthy with handle for stringer output",
+			[]*check{{func(ctx context.Context) error { return nil }, &Meta{Label: "check01"}}},
+			true,
+			"PASS check01\n",
+		},
+		{
+			"should handle multiple healthy checks",
+			[]*check{
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "check01"}},
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "check02"}},
+			},
+			true,
+			"PASS check01\nPASS check02\n",
+		},
+		{
+			"should handle healthy and unhealthy checks",
+			[]*check{
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "check01"}},
+				{func(ctx context.Context) error { return fmt.Errorf("x") }, &Meta{Label: "check02"}},
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "check03"}},
+			},
+			false,
+			"PASS check01\nFAIL check02: x\nPASS check03\n",
+		},
+		{
+			"should handle labels",
+			[]*check{
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "check01"}},
+				{func(ctx context.Context) error { return nil }, &Meta{Label: "Pretty check"}},
+			},
+			true,
+			"PASS check01\nPASS Pretty check\n",
+		},
+		{
+			"should handle empty check list",
+			[]*check{},
+			true,
+			"",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			a := assert.New(t)
+			r := (&checks{cc: tt.checks}).Run(context.Background())
+			a.Equal(tt.healthy, r.Healthy(), "healthy result failed")
+			a.Equal(tt.string, r.String(), "stringer output match failed")
+		})
+	}
+}
+
+// tested with
+// go test -count 10 -race -run Test_DataRace ./pkg/healthcheck/...
+func Test_DataRace(t *testing.T) {
+	hc := New()
+
+	go func() {
+		hc.Add(func(ctx context.Context) error { return nil }, "hc1")
+		hc.Add(func(ctx context.Context) error { return nil }, "hc2")
+		hc.Add(func(ctx context.Context) error { return nil }, "hc3")
+	}()
+	go hc.Run(context.Background())
+
+}

server/pkg/healthcheck/http_handler.go

@@ -0,0 +1,16 @@
+package healthcheck
+
+import "net/http"
+
+func HttpHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		results := Defaults().Run(r.Context())
+		if results.Healthy() {
+			w.WriteHeader(http.StatusOK)
+		} else {
+			w.WriteHeader(http.StatusInternalServerError)
+		}
+
+		results.WriteTo(w)
+	}
+}