Mail access: IMAP + app password (IPv4 only), not Gmail API
This commit is contained in:
228
internal/server/server.go
Normal file
228
internal/server/server.go
Normal file
@@ -0,0 +1,228 @@
|
||||
// Package server wires the HTTP surface of the Email Agent.
|
||||
//
|
||||
// Phase 1 exposes liveness/readiness endpoints and a placeholder dashboard.
|
||||
// Login and the real HTMX screens arrive in Phase 1.2.
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"html/template"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"gitea.lab.audasmedia.com.au/sam/email_agent/internal/config"
|
||||
"gitea.lab.audasmedia.com.au/sam/email_agent/internal/store"
|
||||
"gitea.lab.audasmedia.com.au/sam/email_agent/internal/version"
|
||||
)
|
||||
|
||||
// Server holds the HTTP dependencies.
|
||||
type Server struct {
|
||||
cfg *config.Config
|
||||
store *store.Store
|
||||
logger *slog.Logger
|
||||
http *http.Server
|
||||
index *template.Template
|
||||
}
|
||||
|
||||
// New builds a Server. It does not start listening.
|
||||
func New(cfg *config.Config, st *store.Store, logger *slog.Logger) (*Server, error) {
|
||||
index, err := template.New("index").Parse(indexHTML)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse index template: %w", err)
|
||||
}
|
||||
|
||||
s := &Server{
|
||||
cfg: cfg,
|
||||
store: st,
|
||||
logger: logger,
|
||||
index: index,
|
||||
}
|
||||
s.http = &http.Server{
|
||||
Addr: cfg.Addr,
|
||||
Handler: s.Handler(),
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
ReadTimeout: 30 * time.Second,
|
||||
WriteTimeout: 30 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// Handler returns the root HTTP handler with middleware applied.
|
||||
func (s *Server) Handler() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /health", s.handleHealth)
|
||||
mux.HandleFunc("GET /readyz", s.handleReady)
|
||||
mux.HandleFunc("GET /{$}", s.handleIndex)
|
||||
return s.recoverPanic(s.logRequests(mux))
|
||||
}
|
||||
|
||||
// Run starts the HTTP server and blocks until ctx is cancelled.
|
||||
func (s *Server) Run(ctx context.Context) error {
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
s.logger.Info("http server listening",
|
||||
"addr", s.cfg.Addr,
|
||||
"env", s.cfg.Env,
|
||||
"db", s.store.Path(),
|
||||
"version", version.Version,
|
||||
)
|
||||
if err := s.http.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
errCh <- err
|
||||
return
|
||||
}
|
||||
errCh <- nil
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-errCh:
|
||||
return err
|
||||
case <-ctx.Done():
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
s.logger.Info("shutting down http server")
|
||||
return s.http.Shutdown(shutdownCtx)
|
||||
}
|
||||
}
|
||||
|
||||
type healthResponse struct {
|
||||
Status string `json:"status"`
|
||||
Version string `json:"version"`
|
||||
Commit string `json:"commit"`
|
||||
Env string `json:"env"`
|
||||
UptimeSeconds int64 `json:"uptime_seconds"`
|
||||
Database string `json:"database"`
|
||||
Time string `json:"time"`
|
||||
}
|
||||
|
||||
var startedAt = time.Now()
|
||||
|
||||
// handleHealth reports liveness plus a database connectivity check.
|
||||
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
|
||||
defer cancel()
|
||||
|
||||
resp := healthResponse{
|
||||
Status: "ok",
|
||||
Version: version.Version,
|
||||
Commit: version.Commit,
|
||||
Env: s.cfg.Env,
|
||||
UptimeSeconds: int64(time.Since(startedAt).Seconds()),
|
||||
Database: "ok",
|
||||
Time: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
code := http.StatusOK
|
||||
|
||||
if err := s.store.Ping(ctx); err != nil {
|
||||
s.logger.Error("health check: database unreachable", "error", err)
|
||||
resp.Status = "degraded"
|
||||
resp.Database = "unreachable"
|
||||
code = http.StatusServiceUnavailable
|
||||
}
|
||||
|
||||
writeJSON(w, code, resp)
|
||||
}
|
||||
|
||||
// handleReady reports readiness for load balancers (same signal as health).
|
||||
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
|
||||
defer cancel()
|
||||
if err := s.store.Ping(ctx); err != nil {
|
||||
writeJSON(w, http.StatusServiceUnavailable, map[string]string{"status": "not ready"})
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ready"})
|
||||
}
|
||||
|
||||
// handleIndex renders a placeholder dashboard. The real login + inbox screens
|
||||
// are Phase 1.2.
|
||||
func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
data := struct {
|
||||
Version string
|
||||
Env string
|
||||
}{Version: version.Version, Env: s.cfg.Env}
|
||||
if err := s.index.Execute(w, data); err != nil {
|
||||
s.logger.Error("render index", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, code int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
w.WriteHeader(code)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
// logRequests logs one line per request at debug level.
|
||||
func (s *Server) logRequests(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
|
||||
next.ServeHTTP(rec, r)
|
||||
s.logger.Debug("request",
|
||||
"method", r.Method,
|
||||
"path", r.URL.Path,
|
||||
"status", rec.status,
|
||||
"duration_ms", time.Since(start).Milliseconds(),
|
||||
"remote", r.RemoteAddr,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
// recoverPanic keeps one bad request from taking down the process.
|
||||
func (s *Server) recoverPanic(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
defer func() {
|
||||
if rec := recover(); rec != nil {
|
||||
s.logger.Error("panic recovered", "error", rec, "path", r.URL.Path)
|
||||
http.Error(w, "internal server error", http.StatusInternalServerError)
|
||||
}
|
||||
}()
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
type statusRecorder struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (r *statusRecorder) WriteHeader(code int) {
|
||||
r.status = code
|
||||
r.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
|
||||
const indexHTML = `<!doctype html>
|
||||
<html lang="en" data-theme="light">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Email Agent</title>
|
||||
<style>
|
||||
:root { color-scheme: light dark; }
|
||||
body { font-family: Inter, -apple-system, system-ui, "Segoe UI", Helvetica, Arial, sans-serif;
|
||||
background: #f6f5f4; color: #31302e; margin: 0; }
|
||||
@media (prefers-color-scheme: dark) { body { background: #141518; color: #dcdee2; } }
|
||||
main { max-width: 640px; margin: 12vh auto; padding: 0 24px; }
|
||||
.band { background: #213183; color: #fff; border-radius: 12px; padding: 24px; }
|
||||
h1 { font-size: 32px; line-height: 1.1; margin: 0 0 8px; }
|
||||
p { font-size: 15px; line-height: 1.5; }
|
||||
code { background: rgba(127,127,127,.15); padding: 2px 6px; border-radius: 4px; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
<div class="band">
|
||||
<h1>Email Agent</h1>
|
||||
<p>Phase 1 skeleton is running. Version <code>{{.Version}}</code> ({{.Env}}).</p>
|
||||
</div>
|
||||
<p>Login and the inbox arrive in Phase 1.2. Liveness is at
|
||||
<a href="/health">/health</a>.</p>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
`
|
||||
Reference in New Issue
Block a user