Add pool HTTP API, wire node-status endpoint, and fix metrics test

- Add owm-pool Rust crate (config, DB migrations, share/balance/payout schema)
- Add internal/http pool_api with GET /internal/pool/nodes/{pubkey}/status handler and tests
- Wire pool node-status route into coordinator HTTP mux (main.go)
- Fix metrics_test: initialize sentinel label values so all 8 Vec metric families appear in Gather output

Author: CodeByMAB

owm-coordinator/cmd/coordinator/main.go

@@ -30,6 +30,7 @@ import (
 
 	"github.com/owmnetwork/owm-coordinator/internal/config"
 	"github.com/owmnetwork/owm-coordinator/internal/fl"
+	poolhttp "github.com/owmnetwork/owm-coordinator/internal/http"
 	_ "github.com/owmnetwork/owm-coordinator/internal/metrics"
 	"github.com/owmnetwork/owm-coordinator/internal/lightning"
 	"github.com/owmnetwork/owm-coordinator/internal/lightning/mock"
@@ -283,6 +284,7 @@ func run() error {
 	}
 	mux := http.NewServeMux()
 	mux.Handle("/metrics", promhttp.Handler())
+	mux.HandleFunc("GET /internal/pool/nodes/{pubkey}/status", poolhttp.HandleGetNodeStatus(db, log))
 	httpSrv := &http.Server{Addr: httpAddr, Handler: mux}
 	go func() {
 		if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {

owm-coordinator/internal/http/pool_api.go

@@ -0,0 +1,76 @@
+package poolhttp
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"go.uber.org/zap"
+)
+
+// dbQuerier is the minimal DB interface used internally by the handler.
+// *pgxpool.Pool satisfies this interface in production; a hand-rolled mock
+// satisfies it in tests without leaking any exported surface.
+type dbQuerier interface {
+	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
+}
+
+type nodeStatusRow struct {
+	NodeID string
+	Tier   string
+	Status string
+}
+
+type nodeStatusResponse struct {
+	NodeID              string `json:"node_id"`
+	Tier                string `json:"tier"`
+	Status              string `json:"status"`
+	CoordinatorVerified bool   `json:"coordinator_verified"`
+}
+
+// handleGetNodeStatus is the unexported implementation that accepts the narrow
+// dbQuerier interface, keeping the logic testable without exposing the
+// interface publicly.
+func handleGetNodeStatus(db dbQuerier, log *zap.Logger) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		pubkey := r.PathValue("pubkey")
+
+		var row nodeStatusRow
+		err := db.QueryRow(
+			r.Context(),
+			"SELECT node_id, tier, status FROM nodes WHERE public_key = $1",
+			pubkey,
+		).Scan(&row.NodeID, &row.Tier, &row.Status)
+
+		w.Header().Set("Content-Type", "application/json")
+
+		if errors.Is(err, pgx.ErrNoRows) {
+			w.WriteHeader(http.StatusNotFound)
+			json.NewEncoder(w).Encode(map[string]string{"error": "node not found"}) //nolint:errcheck
+			return
+		}
+		if err != nil {
+			log.Error("query node status", zap.Error(err))
+			w.WriteHeader(http.StatusInternalServerError)
+			json.NewEncoder(w).Encode(map[string]string{"error": "internal error"}) //nolint:errcheck
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(nodeStatusResponse{ //nolint:errcheck
+			NodeID:              row.NodeID,
+			Tier:                row.Tier,
+			Status:              row.Status,
+			CoordinatorVerified: true,
+		})
+	}
+}
+
+// HandleGetNodeStatus returns an http.HandlerFunc that looks up a node by its
+// public key and reports its current status.
+func HandleGetNodeStatus(db *pgxpool.Pool, log *zap.Logger) http.HandlerFunc {
+	return handleGetNodeStatus(db, log)
+}

owm-coordinator/internal/http/pool_api_test.go

@@ -0,0 +1,120 @@
+package poolhttp
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5"
+	"go.uber.org/zap"
+)
+
+// mockRow implements pgx.Row for testing.
+type mockRow struct {
+	nodeID string
+	tier   string
+	status string
+	err    error
+}
+
+func (m *mockRow) Scan(dest ...any) error {
+	if m.err != nil {
+		return m.err
+	}
+	*dest[0].(*string) = m.nodeID
+	*dest[1].(*string) = m.tier
+	*dest[2].(*string) = m.status
+	return nil
+}
+
+// mockDB implements dbQuerier for testing.
+type mockDB struct {
+	nodeID string
+	tier   string
+	status string
+	err    error
+}
+
+func (m *mockDB) QueryRow(_ context.Context, _ string, _ ...any) pgx.Row {
+	return &mockRow{
+		nodeID: m.nodeID,
+		tier:   m.tier,
+		status: m.status,
+		err:    m.err,
+	}
+}
+
+func serveWithMux(handler http.HandlerFunc, req *http.Request) *httptest.ResponseRecorder {
+	rr := httptest.NewRecorder()
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /internal/pool/nodes/{pubkey}/status", handler)
+	mux.ServeHTTP(rr, req)
+	return rr
+}
+
+func TestHandleGetNodeStatus_Active(t *testing.T) {
+	db := &mockDB{nodeID: "uuid-1", tier: "t1", status: "active"}
+	handler := handleGetNodeStatus(db, zap.NewNop())
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/pool/nodes/somepubkey/status", nil)
+	rr := serveWithMux(handler, req)
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+	body := rr.Body.String()
+	if !strings.Contains(body, `"status":"active"`) {
+		t.Errorf("body missing status:active, got: %s", body)
+	}
+	if !strings.Contains(body, `"coordinator_verified":true`) {
+		t.Errorf("body missing coordinator_verified:true, got: %s", body)
+	}
+}
+
+func TestHandleGetNodeStatus_Pending(t *testing.T) {
+	db := &mockDB{nodeID: "uuid-2", tier: "t1", status: "pending"}
+	handler := handleGetNodeStatus(db, zap.NewNop())
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/pool/nodes/somepubkey/status", nil)
+	rr := serveWithMux(handler, req)
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+	if !strings.Contains(rr.Body.String(), `"status":"pending"`) {
+		t.Errorf("body missing status:pending, got: %s", rr.Body.String())
+	}
+}
+
+func TestHandleGetNodeStatus_NotFound(t *testing.T) {
+	db := &mockDB{err: pgx.ErrNoRows}
+	handler := handleGetNodeStatus(db, zap.NewNop())
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/pool/nodes/somepubkey/status", nil)
+	rr := serveWithMux(handler, req)
+
+	if rr.Code != http.StatusNotFound {
+		t.Fatalf("expected 404, got %d", rr.Code)
+	}
+	if !strings.Contains(rr.Body.String(), `"error":"node not found"`) {
+		t.Errorf("body missing error message, got: %s", rr.Body.String())
+	}
+}
+
+func TestHandleGetNodeStatus_DBError(t *testing.T) {
+	db := &mockDB{err: errors.New("connection reset by peer")}
+	handler := handleGetNodeStatus(db, zap.NewNop())
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/pool/nodes/somepubkey/status", nil)
+	rr := serveWithMux(handler, req)
+
+	if rr.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d", rr.Code)
+	}
+	if !strings.Contains(rr.Body.String(), `"error":"internal error"`) {
+		t.Errorf("body missing internal error message, got: %s", rr.Body.String())
+	}
+}

owm-coordinator/internal/metrics/metrics_test.go

@@ -11,6 +11,16 @@ import (
 )
 
 func TestMetrics_AllEightPresent(t *testing.T) {
+	// Vec metrics only appear in /metrics output once at least one label
+	// combination has been observed. Initialize a sentinel value for each so
+	// the Gather call below emits all eight metric families.
+	OwmNodesTotal.WithLabelValues("_test", "_test")
+	OwmTasksTotal.WithLabelValues("_test", "_test")
+	OwmFLRoundsTotal.WithLabelValues("_test")
+	OwmPaymentsTotal.WithLabelValues("_test")
+	OwmStakeVerificationsTotal.WithLabelValues("_test")
+	OwmSlashEventsTotal.WithLabelValues("_test")
+
 	ts := httptest.NewServer(promhttp.Handler())
 	defer ts.Close()
 

owm-pool/.gitignore

@@ -0,0 +1,3 @@
+/target
+*.env
+.env*