From e7ea24dece173b7bfb8c9f22a46cac2fde6824ea Mon Sep 17 00:00:00 2001 From: Gus Date: Wed, 10 Sep 2025 09:39:09 +0800 Subject: [PATCH 1/5] Add keep-alive handler with DB ping --- handler/{ping.go => keep_alive.go} | 12 ++--- handler/keep_alive_db.go | 49 +++++++++++++++++++ handler/keep_alive_db_test.go | 51 ++++++++++++++++++++ handler/{ping_test.go => keep_alive_test.go} | 6 +-- handler/payload/keep_alive.go | 7 +++ handler/payload/ping.go | 6 --- metal/kernel/router.go | 2 +- 7 files changed, 117 insertions(+), 16 deletions(-) rename handler/{ping.go => keep_alive.go} (64%) create mode 100644 handler/keep_alive_db.go create mode 100644 handler/keep_alive_db_test.go rename handler/{ping_test.go => keep_alive_test.go} (91%) create mode 100644 handler/payload/keep_alive.go delete mode 100644 handler/payload/ping.go diff --git a/handler/ping.go b/handler/keep_alive.go similarity index 64% rename from handler/ping.go rename to handler/keep_alive.go index 437a3150..a565cf66 100644 --- a/handler/ping.go +++ b/handler/keep_alive.go @@ -11,15 +11,15 @@ import ( "github.com/oullin/pkg/portal" ) -type PingHandler struct { +type KeepAliveHandler struct { env *env.Ping } -func MakePingHandler(e *env.Ping) PingHandler { - return PingHandler{env: e} +func MakeKeepAliveHandler(e *env.Ping) KeepAliveHandler { + return KeepAliveHandler{env: e} } -func (h PingHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Request) *http.ApiError { +func (h KeepAliveHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Request) *http.ApiError { user, pass, ok := r.BasicAuth() if !ok || h.env.HasInvalidCreds(user, pass) { @@ -32,13 +32,13 @@ func (h PingHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Request) *htt resp := http.MakeResponseFrom("0.0.1", w, r) now := time.Now().UTC() - data := payload.PingResponse{ + data := payload.KeepAliveResponse{ Message: "pong", DateTime: now.Format(portal.DatesLayout), } if err := resp.RespondOk(data); err != nil { - return http.LogInternalError("could not encode ping response", err) + return http.LogInternalError("could not encode keep-alive response", err) } return nil diff --git a/handler/keep_alive_db.go b/handler/keep_alive_db.go new file mode 100644 index 00000000..413e7fc5 --- /dev/null +++ b/handler/keep_alive_db.go @@ -0,0 +1,49 @@ +package handler + +import ( + "fmt" + baseHttp "net/http" + "time" + + "github.com/oullin/database" + "github.com/oullin/handler/payload" + "github.com/oullin/metal/env" + "github.com/oullin/pkg/http" + "github.com/oullin/pkg/portal" +) + +type KeepAliveDBHandler struct { + env *env.Ping + db *database.Connection +} + +func MakeKeepAliveDBHandler(e *env.Ping, db *database.Connection) KeepAliveDBHandler { + return KeepAliveDBHandler{env: e, db: db} +} + +func (h KeepAliveDBHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Request) *http.ApiError { + user, pass, ok := r.BasicAuth() + + if !ok || h.env.HasInvalidCreds(user, pass) { + return http.LogUnauthorisedError( + "invalid credentials", + fmt.Errorf("invalid credentials"), + ) + } + + h.db.Ping() + + resp := http.MakeResponseFrom("0.0.1", w, r) + now := time.Now().UTC() + + data := payload.KeepAliveResponse{ + Message: "pong", + DateTime: now.Format(portal.DatesLayout), + } + + if err := resp.RespondOk(data); err != nil { + return http.LogInternalError("could not encode keep-alive response", err) + } + + return nil +} diff --git a/handler/keep_alive_db_test.go b/handler/keep_alive_db_test.go new file mode 100644 index 00000000..c76864a7 --- /dev/null +++ b/handler/keep_alive_db_test.go @@ -0,0 +1,51 @@ +package handler + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/oullin/handler/payload" + handlertests "github.com/oullin/handler/tests" + "github.com/oullin/metal/env" + "github.com/oullin/pkg/portal" +) + +func TestKeepAliveDBHandler(t *testing.T) { + db, _ := handlertests.MakeTestDB(t) + e := env.Ping{Username: "user", Password: "pass"} + h := MakeKeepAliveDBHandler(&e, db) + + t.Run("valid credentials", func(t *testing.T) { + req := httptest.NewRequest("GET", "/ping", nil) + req.SetBasicAuth("user", "pass") + rec := httptest.NewRecorder() + if err := h.Handle(rec, req); err != nil { + t.Fatalf("handle err: %v", err) + } + if rec.Code != http.StatusOK { + t.Fatalf("status %d", rec.Code) + } + var resp payload.KeepAliveResponse + if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil { + t.Fatalf("decode: %v", err) + } + if resp.Message != "pong" { + t.Fatalf("unexpected message: %s", resp.Message) + } + if _, err := time.Parse(portal.DatesLayout, resp.DateTime); err != nil { + t.Fatalf("invalid datetime: %v", err) + } + }) + + t.Run("invalid credentials", func(t *testing.T) { + req := httptest.NewRequest("GET", "/ping", nil) + req.SetBasicAuth("bad", "creds") + rec := httptest.NewRecorder() + if err := h.Handle(rec, req); err == nil || err.Status != http.StatusUnauthorized { + t.Fatalf("expected unauthorized, got %#v", err) + } + }) +} diff --git a/handler/ping_test.go b/handler/keep_alive_test.go similarity index 91% rename from handler/ping_test.go rename to handler/keep_alive_test.go index cf2fe289..a0296be2 100644 --- a/handler/ping_test.go +++ b/handler/keep_alive_test.go @@ -12,9 +12,9 @@ import ( "github.com/oullin/pkg/portal" ) -func TestPingHandler(t *testing.T) { +func TestKeepAliveHandler(t *testing.T) { e := env.Ping{Username: "user", Password: "pass"} - h := MakePingHandler(&e) + h := MakeKeepAliveHandler(&e) t.Run("valid credentials", func(t *testing.T) { req := httptest.NewRequest("GET", "/ping", nil) @@ -26,7 +26,7 @@ func TestPingHandler(t *testing.T) { if rec.Code != http.StatusOK { t.Fatalf("status %d", rec.Code) } - var resp payload.PingResponse + var resp payload.KeepAliveResponse if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil { t.Fatalf("decode: %v", err) } diff --git a/handler/payload/keep_alive.go b/handler/payload/keep_alive.go new file mode 100644 index 00000000..85887a20 --- /dev/null +++ b/handler/payload/keep_alive.go @@ -0,0 +1,7 @@ +package payload + +// KeepAliveResponse represents the response payload for the keep-alive endpoint. +type KeepAliveResponse struct { + Message string `json:"message"` + DateTime string `json:"date_time"` +} diff --git a/handler/payload/ping.go b/handler/payload/ping.go deleted file mode 100644 index d05f6805..00000000 --- a/handler/payload/ping.go +++ /dev/null @@ -1,6 +0,0 @@ -package payload - -type PingResponse struct { - Message string `json:"message"` - DateTime string `json:"date_time"` -} diff --git a/metal/kernel/router.go b/metal/kernel/router.go index 5e3df29b..71f126ef 100644 --- a/metal/kernel/router.go +++ b/metal/kernel/router.go @@ -81,7 +81,7 @@ func (r *Router) Signature() { } func (r *Router) Ping() { - abstract := handler.MakePingHandler(&r.Env.Ping) + abstract := handler.MakeKeepAliveHandler(&r.Env.Ping) apiHandler := http.MakeApiHandler( r.Pipeline.Chain(abstract.Handle), From 89e4de283d9d17420ec1c944bb9f72ad09d8d003 Mon Sep 17 00:00:00 2001 From: Gus Date: Wed, 10 Sep 2025 09:51:26 +0800 Subject: [PATCH 2/5] Add router test for database keep-alive --- database/connection.go | 17 +++++++----- handler/keep_alive_db.go | 4 ++- handler/keep_alive_db_test.go | 10 +++++++ handler/payload/keep_alive.go | 1 - main.go | 4 ++- metal/kernel/app.go | 1 + metal/kernel/router.go | 10 +++++++ metal/kernel/router_ping_db_test.go | 42 +++++++++++++++++++++++++++++ 8 files changed, 79 insertions(+), 10 deletions(-) create mode 100644 metal/kernel/router_ping_db_test.go diff --git a/database/connection.go b/database/connection.go index 8f08e64c..d30c41ed 100644 --- a/database/connection.go +++ b/database/connection.go @@ -47,27 +47,30 @@ func (c *Connection) Close() bool { return true } -func (c *Connection) Ping() { +func (c *Connection) Ping() (bool, error) { var driver *sql.DB slog.Info("Database ping started", "separator", "---------") - if conn, err := c.driver.DB(); err != nil { + conn, err := c.driver.DB() + if err != nil { slog.Error("Error retrieving the db driver", "error", err.Error()) - - return - } else { - driver = conn - slog.Info("Database driver acquired", "type", fmt.Sprintf("%T", driver)) + return false, err } + driver = conn + slog.Info("Database driver acquired", "type", fmt.Sprintf("%T", driver)) + if err := driver.Ping(); err != nil { slog.Error("Error pinging the db driver", "error", err.Error()) + return false, err } slog.Info("Database driver is healthy", "stats", driver.Stats()) slog.Info("Database ping completed", "separator", "---------") + + return true, nil } func (c *Connection) Sql() *gorm.DB { diff --git a/handler/keep_alive_db.go b/handler/keep_alive_db.go index 413e7fc5..8b7e7890 100644 --- a/handler/keep_alive_db.go +++ b/handler/keep_alive_db.go @@ -31,7 +31,9 @@ func (h KeepAliveDBHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Reques ) } - h.db.Ping() + if ok, err := h.db.Ping(); !ok { + return http.LogInternalError("database ping failed", err) + } resp := http.MakeResponseFrom("0.0.1", w, r) now := time.Now().UTC() diff --git a/handler/keep_alive_db_test.go b/handler/keep_alive_db_test.go index c76864a7..38e9cefc 100644 --- a/handler/keep_alive_db_test.go +++ b/handler/keep_alive_db_test.go @@ -48,4 +48,14 @@ func TestKeepAliveDBHandler(t *testing.T) { t.Fatalf("expected unauthorized, got %#v", err) } }) + + t.Run("db ping failure", func(t *testing.T) { + db.Close() + req := httptest.NewRequest("GET", "/ping", nil) + req.SetBasicAuth("user", "pass") + rec := httptest.NewRecorder() + if err := h.Handle(rec, req); err == nil || err.Status != http.StatusInternalServerError { + t.Fatalf("expected internal error, got %#v", err) + } + }) } diff --git a/handler/payload/keep_alive.go b/handler/payload/keep_alive.go index 85887a20..1e142d32 100644 --- a/handler/payload/keep_alive.go +++ b/handler/payload/keep_alive.go @@ -1,6 +1,5 @@ package payload -// KeepAliveResponse represents the response payload for the keep-alive endpoint. type KeepAliveResponse struct { Message string `json:"message"` DateTime string `json:"date_time"` diff --git a/main.go b/main.go index 19e9178f..b818f686 100644 --- a/main.go +++ b/main.go @@ -35,7 +35,9 @@ func main() { app.Boot() // --- Testing - app.GetDB().Ping() + if ok, err := app.GetDB().Ping(); !ok { + slog.Error("database ping failed", "error", err) + } slog.Info("Starting new server on :" + app.GetEnv().Network.HttpPort) // --- diff --git a/metal/kernel/app.go b/metal/kernel/app.go index 968d4dfc..bb37b47c 100644 --- a/metal/kernel/app.go +++ b/metal/kernel/app.go @@ -70,6 +70,7 @@ func (a *App) Boot() { router := *a.router router.Ping() + router.PingDB() router.Profile() router.Experience() router.Projects() diff --git a/metal/kernel/router.go b/metal/kernel/router.go index 71f126ef..8c34e176 100644 --- a/metal/kernel/router.go +++ b/metal/kernel/router.go @@ -90,6 +90,16 @@ func (r *Router) Ping() { r.Mux.HandleFunc("GET /ping", apiHandler) } +func (r *Router) PingDB() { + abstract := handler.MakeKeepAliveDBHandler(&r.Env.Ping, r.Db) + + apiHandler := http.MakeApiHandler( + r.Pipeline.Chain(abstract.Handle), + ) + + r.Mux.HandleFunc("GET /ping/db", apiHandler) +} + func (r *Router) Profile() { addStaticRoute(r, "/profile", "./storage/fixture/profile.json", handler.MakeProfileHandler) } diff --git a/metal/kernel/router_ping_db_test.go b/metal/kernel/router_ping_db_test.go new file mode 100644 index 00000000..623aaf18 --- /dev/null +++ b/metal/kernel/router_ping_db_test.go @@ -0,0 +1,42 @@ +package kernel + +import ( + "net/http" + "net/http/httptest" + "testing" + + handlertests "github.com/oullin/handler/tests" + "github.com/oullin/metal/env" + "github.com/oullin/pkg/middleware" +) + +func TestPingDBRoute(t *testing.T) { + db, _ := handlertests.MakeTestDB(t) + r := Router{ + Env: &env.Environment{Ping: env.Ping{Username: "user", Password: "pass"}}, + Db: db, + Mux: http.NewServeMux(), + Pipeline: middleware.Pipeline{PublicMiddleware: middleware.MakePublicMiddleware("", false)}, + } + r.PingDB() + + t.Run("valid credentials", func(t *testing.T) { + req := httptest.NewRequest("GET", "/ping/db", nil) + req.SetBasicAuth("user", "pass") + rec := httptest.NewRecorder() + r.Mux.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code) + } + }) + + t.Run("invalid credentials", func(t *testing.T) { + req := httptest.NewRequest("GET", "/ping/db", nil) + req.SetBasicAuth("bad", "creds") + rec := httptest.NewRecorder() + r.Mux.ServeHTTP(rec, req) + if rec.Code != http.StatusUnauthorized { + t.Fatalf("expected status %d, got %d", http.StatusUnauthorized, rec.Code) + } + }) +} From d2bc4b14702304e8d0d2c448fc72b7b790b2a800 Mon Sep 17 00:00:00 2001 From: Gus Date: Wed, 10 Sep 2025 10:39:07 +0800 Subject: [PATCH 3/5] Refactor DB ping and rename endpoint --- database/connection.go | 13 ++----------- handler/keep_alive_db_test.go | 6 +++--- metal/kernel/router.go | 2 +- metal/kernel/router_ping_db_test.go | 4 ++-- 4 files changed, 8 insertions(+), 17 deletions(-) diff --git a/database/connection.go b/database/connection.go index d30c41ed..df9374a1 100644 --- a/database/connection.go +++ b/database/connection.go @@ -50,26 +50,17 @@ func (c *Connection) Close() bool { func (c *Connection) Ping() (bool, error) { var driver *sql.DB - slog.Info("Database ping started", "separator", "---------") - conn, err := c.driver.DB() if err != nil { - slog.Error("Error retrieving the db driver", "error", err.Error()) - return false, err + return false, fmt.Errorf("error retrieving the db driver: %w", err) } driver = conn - slog.Info("Database driver acquired", "type", fmt.Sprintf("%T", driver)) if err := driver.Ping(); err != nil { - slog.Error("Error pinging the db driver", "error", err.Error()) - return false, err + return false, fmt.Errorf("error pinging the db driver: %w", err) } - slog.Info("Database driver is healthy", "stats", driver.Stats()) - - slog.Info("Database ping completed", "separator", "---------") - return true, nil } diff --git a/handler/keep_alive_db_test.go b/handler/keep_alive_db_test.go index 38e9cefc..2ce01b2d 100644 --- a/handler/keep_alive_db_test.go +++ b/handler/keep_alive_db_test.go @@ -19,7 +19,7 @@ func TestKeepAliveDBHandler(t *testing.T) { h := MakeKeepAliveDBHandler(&e, db) t.Run("valid credentials", func(t *testing.T) { - req := httptest.NewRequest("GET", "/ping", nil) + req := httptest.NewRequest("GET", "/ping-db", nil) req.SetBasicAuth("user", "pass") rec := httptest.NewRecorder() if err := h.Handle(rec, req); err != nil { @@ -41,7 +41,7 @@ func TestKeepAliveDBHandler(t *testing.T) { }) t.Run("invalid credentials", func(t *testing.T) { - req := httptest.NewRequest("GET", "/ping", nil) + req := httptest.NewRequest("GET", "/ping-db", nil) req.SetBasicAuth("bad", "creds") rec := httptest.NewRecorder() if err := h.Handle(rec, req); err == nil || err.Status != http.StatusUnauthorized { @@ -51,7 +51,7 @@ func TestKeepAliveDBHandler(t *testing.T) { t.Run("db ping failure", func(t *testing.T) { db.Close() - req := httptest.NewRequest("GET", "/ping", nil) + req := httptest.NewRequest("GET", "/ping-db", nil) req.SetBasicAuth("user", "pass") rec := httptest.NewRecorder() if err := h.Handle(rec, req); err == nil || err.Status != http.StatusInternalServerError { diff --git a/metal/kernel/router.go b/metal/kernel/router.go index 8c34e176..33d2cc6d 100644 --- a/metal/kernel/router.go +++ b/metal/kernel/router.go @@ -97,7 +97,7 @@ func (r *Router) PingDB() { r.Pipeline.Chain(abstract.Handle), ) - r.Mux.HandleFunc("GET /ping/db", apiHandler) + r.Mux.HandleFunc("GET /ping-db", apiHandler) } func (r *Router) Profile() { diff --git a/metal/kernel/router_ping_db_test.go b/metal/kernel/router_ping_db_test.go index 623aaf18..feb4ae6e 100644 --- a/metal/kernel/router_ping_db_test.go +++ b/metal/kernel/router_ping_db_test.go @@ -21,7 +21,7 @@ func TestPingDBRoute(t *testing.T) { r.PingDB() t.Run("valid credentials", func(t *testing.T) { - req := httptest.NewRequest("GET", "/ping/db", nil) + req := httptest.NewRequest("GET", "/ping-db", nil) req.SetBasicAuth("user", "pass") rec := httptest.NewRecorder() r.Mux.ServeHTTP(rec, req) @@ -31,7 +31,7 @@ func TestPingDBRoute(t *testing.T) { }) t.Run("invalid credentials", func(t *testing.T) { - req := httptest.NewRequest("GET", "/ping/db", nil) + req := httptest.NewRequest("GET", "/ping-db", nil) req.SetBasicAuth("bad", "creds") rec := httptest.NewRecorder() r.Mux.ServeHTTP(rec, req) From d2905f58f2bdc6c4dff057ad3698df5362b06f78 Mon Sep 17 00:00:00 2001 From: Gus Date: Wed, 10 Sep 2025 10:51:43 +0800 Subject: [PATCH 4/5] Add no-cache response helper and simplify DB ping --- database/connection.go | 15 +++++---------- handler/keep_alive.go | 2 +- handler/keep_alive_db.go | 4 ++-- main.go | 2 +- pkg/http/response.go | 19 +++++++++++++++++++ pkg/http/response_test.go | 27 +++++++++++++++++++++++++++ 6 files changed, 55 insertions(+), 14 deletions(-) diff --git a/database/connection.go b/database/connection.go index df9374a1..4a9a48ce 100644 --- a/database/connection.go +++ b/database/connection.go @@ -1,7 +1,6 @@ package database import ( - "database/sql" "fmt" "log/slog" @@ -47,21 +46,17 @@ func (c *Connection) Close() bool { return true } -func (c *Connection) Ping() (bool, error) { - var driver *sql.DB - +func (c *Connection) Ping() error { conn, err := c.driver.DB() if err != nil { - return false, fmt.Errorf("error retrieving the db driver: %w", err) + return fmt.Errorf("error retrieving the db driver: %w", err) } - driver = conn - - if err := driver.Ping(); err != nil { - return false, fmt.Errorf("error pinging the db driver: %w", err) + if err := conn.Ping(); err != nil { + return fmt.Errorf("error pinging the db driver: %w", err) } - return true, nil + return nil } func (c *Connection) Sql() *gorm.DB { diff --git a/handler/keep_alive.go b/handler/keep_alive.go index a565cf66..521a5235 100644 --- a/handler/keep_alive.go +++ b/handler/keep_alive.go @@ -29,7 +29,7 @@ func (h KeepAliveHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Request) ) } - resp := http.MakeResponseFrom("0.0.1", w, r) + resp := http.MakeNoCacheResponse(w, r) now := time.Now().UTC() data := payload.KeepAliveResponse{ diff --git a/handler/keep_alive_db.go b/handler/keep_alive_db.go index 8b7e7890..b589377c 100644 --- a/handler/keep_alive_db.go +++ b/handler/keep_alive_db.go @@ -31,11 +31,11 @@ func (h KeepAliveDBHandler) Handle(w baseHttp.ResponseWriter, r *baseHttp.Reques ) } - if ok, err := h.db.Ping(); !ok { + if err := h.db.Ping(); err != nil { return http.LogInternalError("database ping failed", err) } - resp := http.MakeResponseFrom("0.0.1", w, r) + resp := http.MakeNoCacheResponse(w, r) now := time.Now().UTC() data := payload.KeepAliveResponse{ diff --git a/main.go b/main.go index b818f686..2f2ec70b 100644 --- a/main.go +++ b/main.go @@ -35,7 +35,7 @@ func main() { app.Boot() // --- Testing - if ok, err := app.GetDB().Ping(); !ok { + if err := app.GetDB().Ping(); err != nil { slog.Error("database ping failed", "error", err) } slog.Info("Starting new server on :" + app.GetEnv().Network.HttpPort) diff --git a/pkg/http/response.go b/pkg/http/response.go index 636f2d48..188d41f8 100644 --- a/pkg/http/response.go +++ b/pkg/http/response.go @@ -38,6 +38,21 @@ func MakeResponseFrom(salt string, writer baseHttp.ResponseWriter, request *base } } +func MakeNoCacheResponse(writer baseHttp.ResponseWriter, request *baseHttp.Request) *Response { + cacheControl := "no-store" + + return &Response{ + writer: writer, + request: request, + cacheControl: cacheControl, + headers: func(w baseHttp.ResponseWriter) { + w.Header().Set("Content-Type", "application/json") + w.Header().Set("X-Content-Type-Options", "nosniff") + w.Header().Set("Cache-Control", cacheControl) + }, + } +} + func (r *Response) WithHeaders(callback func(w baseHttp.ResponseWriter)) { callback(r.writer) } @@ -53,6 +68,10 @@ func (r *Response) RespondOk(payload any) error { } func (r *Response) HasCache() bool { + if r.etag == "" { + return false + } + request := r.request match := strings.TrimSpace( diff --git a/pkg/http/response_test.go b/pkg/http/response_test.go index 35acd4b2..a505543d 100644 --- a/pkg/http/response_test.go +++ b/pkg/http/response_test.go @@ -31,6 +31,33 @@ func TestResponse_RespondOkAndHasCache(t *testing.T) { } } +func TestResponse_NoCache(t *testing.T) { + req := httptest.NewRequest("GET", "/", nil) + rec := httptest.NewRecorder() + + r := MakeNoCacheResponse(rec, req) + + if err := r.RespondOk(map[string]string{"a": "b"}); err != nil { + t.Fatalf("respond: %v", err) + } + + if rec.Code != http.StatusOK { + t.Fatalf("status %d", rec.Code) + } + + if rec.Header().Get("Cache-Control") != "no-store" { + t.Fatalf("unexpected cache-control: %s", rec.Header().Get("Cache-Control")) + } + + if rec.Header().Get("ETag") != "" { + t.Fatalf("etag should be empty") + } + + if r.HasCache() { + t.Fatalf("expected no cache") + } +} + func TestResponse_WithHeaders(t *testing.T) { req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() From 56b1ecc0ff20f0ac0ca36d0473ac17b337d49a24 Mon Sep 17 00:00:00 2001 From: Gus Date: Wed, 10 Sep 2025 11:14:38 +0800 Subject: [PATCH 5/5] Rename Ping methods to KeepAlive variants --- metal/kernel/app.go | 4 ++-- metal/kernel/router.go | 4 ++-- .../{router_ping_db_test.go => router_keep_alive_db_test.go} | 4 ++-- .../kernel/{router_ping_test.go => router_keep_alive_test.go} | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) rename metal/kernel/{router_ping_db_test.go => router_keep_alive_db_test.go} (94%) rename metal/kernel/{router_ping_test.go => router_keep_alive_test.go} (94%) diff --git a/metal/kernel/app.go b/metal/kernel/app.go index bb37b47c..e110064b 100644 --- a/metal/kernel/app.go +++ b/metal/kernel/app.go @@ -69,8 +69,8 @@ func (a *App) Boot() { router := *a.router - router.Ping() - router.PingDB() + router.KeepAlive() + router.KeepAliveDB() router.Profile() router.Experience() router.Projects() diff --git a/metal/kernel/router.go b/metal/kernel/router.go index 33d2cc6d..0760117a 100644 --- a/metal/kernel/router.go +++ b/metal/kernel/router.go @@ -80,7 +80,7 @@ func (r *Router) Signature() { r.Mux.HandleFunc("POST /generate-signature", generate) } -func (r *Router) Ping() { +func (r *Router) KeepAlive() { abstract := handler.MakeKeepAliveHandler(&r.Env.Ping) apiHandler := http.MakeApiHandler( @@ -90,7 +90,7 @@ func (r *Router) Ping() { r.Mux.HandleFunc("GET /ping", apiHandler) } -func (r *Router) PingDB() { +func (r *Router) KeepAliveDB() { abstract := handler.MakeKeepAliveDBHandler(&r.Env.Ping, r.Db) apiHandler := http.MakeApiHandler( diff --git a/metal/kernel/router_ping_db_test.go b/metal/kernel/router_keep_alive_db_test.go similarity index 94% rename from metal/kernel/router_ping_db_test.go rename to metal/kernel/router_keep_alive_db_test.go index feb4ae6e..baac81b6 100644 --- a/metal/kernel/router_ping_db_test.go +++ b/metal/kernel/router_keep_alive_db_test.go @@ -10,7 +10,7 @@ import ( "github.com/oullin/pkg/middleware" ) -func TestPingDBRoute(t *testing.T) { +func TestKeepAliveDBRoute(t *testing.T) { db, _ := handlertests.MakeTestDB(t) r := Router{ Env: &env.Environment{Ping: env.Ping{Username: "user", Password: "pass"}}, @@ -18,7 +18,7 @@ func TestPingDBRoute(t *testing.T) { Mux: http.NewServeMux(), Pipeline: middleware.Pipeline{PublicMiddleware: middleware.MakePublicMiddleware("", false)}, } - r.PingDB() + r.KeepAliveDB() t.Run("valid credentials", func(t *testing.T) { req := httptest.NewRequest("GET", "/ping-db", nil) diff --git a/metal/kernel/router_ping_test.go b/metal/kernel/router_keep_alive_test.go similarity index 94% rename from metal/kernel/router_ping_test.go rename to metal/kernel/router_keep_alive_test.go index 692b3d47..bb00b728 100644 --- a/metal/kernel/router_ping_test.go +++ b/metal/kernel/router_keep_alive_test.go @@ -9,13 +9,13 @@ import ( "github.com/oullin/pkg/middleware" ) -func TestPingRoute(t *testing.T) { +func TestKeepAliveRoute(t *testing.T) { r := Router{ Env: &env.Environment{Ping: env.Ping{Username: "user", Password: "pass"}}, Mux: http.NewServeMux(), Pipeline: middleware.Pipeline{PublicMiddleware: middleware.MakePublicMiddleware("", false)}, } - r.Ping() + r.KeepAlive() t.Run("valid credentials", func(t *testing.T) { req := httptest.NewRequest("GET", "/ping", nil)