package main
import (
"context"
"database/sql"
"fmt"
"log"
"net/http"
"os"
"time"
_ "github.com/lib/pq"
"github.com/redis/go-redis/v9"
)
type result struct {
Name string
OK bool
Message string
}
func env(key, fallback string) string {
if v := os.Getenv(key); v != "" {
return v
}
return fallback
}
func openDB() (*sql.DB, error) {
dsn := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
env("POSTGRES_HOST", "localhost"),
env("POSTGRES_PORT", "5432"),
env("POSTGRES_USER", "app"),
env("POSTGRES_PASSWORD", ""),
env("POSTGRES_DB", "app"),
)
db, err := sql.Open("postgres", dsn)
if err != nil {
return nil, err
}
db.SetConnMaxLifetime(5 * time.Second)
return db, nil
}
// migrate runs database migrations.
func migrate() error {
db, err := openDB()
if err != nil {
return fmt.Errorf("open db: %w", err)
}
defer db.Close()
migrations := []string{
`CREATE TABLE IF NOT EXISTS healthcheck (
id SERIAL PRIMARY KEY,
checked_at TIMESTAMPTZ DEFAULT NOW(),
msg TEXT
)`,
`CREATE TABLE IF NOT EXISTS visits (
id SERIAL PRIMARY KEY,
path TEXT NOT NULL,
visited_at TIMESTAMPTZ DEFAULT NOW()
)`,
}
for i, m := range migrations {
if _, err := db.Exec(m); err != nil {
return fmt.Errorf("migration %d: %w", i, err)
}
log.Printf("migration %d: OK", i)
}
log.Println("all migrations completed")
return nil
}
func testPostgres() result {
db, err := openDB()
if err != nil {
return result{"PostgreSQL", false, fmt.Sprintf("open: %v", err)}
}
defer db.Close()
_, err = db.Exec(`INSERT INTO healthcheck (msg) VALUES ($1)`, fmt.Sprintf("ping at %s", time.Now().Format(time.RFC3339)))
if err != nil {
return result{"PostgreSQL", false, fmt.Sprintf("insert: %v", err)}
}
var count int
err = db.QueryRow(`SELECT COUNT(*) FROM healthcheck`).Scan(&count)
if err != nil {
return result{"PostgreSQL", false, fmt.Sprintf("count: %v", err)}
}
var visits int
db.QueryRow(`SELECT COUNT(*) FROM visits`).Scan(&visits)
return result{"PostgreSQL", true, fmt.Sprintf("OK — %d healthchecks, %d visits", count, visits)}
}
func testRedis() result {
addr := fmt.Sprintf("%s:%s",
env("REDIS_HOST", "localhost"),
env("REDIS_PORT", "6379"),
)
rdb := redis.NewClient(&redis.Options{Addr: addr})
defer rdb.Close()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err := rdb.Set(ctx, "test-key", "hello from test-app", 0).Err()
if err != nil {
return result{"Redis", false, fmt.Sprintf("SET: %v", err)}
}
val, err := rdb.Get(ctx, "test-key").Result()
if err != nil {
return result{"Redis", false, fmt.Sprintf("GET: %v", err)}
}
return result{"Redis", true, fmt.Sprintf("OK — GET test-key = %q", val)}
}
func handler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/healthz" {
w.WriteHeader(200)
fmt.Fprint(w, "ok")
return
}
// Track visit
if db, err := openDB(); err == nil {
db.Exec(`INSERT INTO visits (path) VALUES ($1)`, r.URL.Path)
db.Close()
}
pg := testPostgres()
rd := testRedis()
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `
StackOps Test App
StackOps Test App with migrations
Dependency connectivity checks
`)
for _, t := range []result{pg, rd} {
cls := "ok"
if !t.OK {
cls = "fail"
}
fmt.Fprintf(w, `
`, cls, t.Name, t.Message)
}
fmt.Fprintf(w, ` Checked at %s
`, time.Now().Format(time.RFC3339))
}
func main() {
if len(os.Args) > 1 && os.Args[1] == "migrate" {
if err := migrate(); err != nil {
log.Fatalf("migration failed: %v", err)
}
return
}
http.HandleFunc("/", handler)
port := env("PORT", "8080")
log.Printf("test-app listening on :%s", port)
log.Fatal(http.ListenAndServe(":"+port, nil))
}