Add CORS support and response caching to aggregate endpoints

- Introduced CORS configuration options in config.example.yaml, allowing specification of allowed origins for cross-origin requests.
- Enhanced the aggregate handler to support response caching with a configurable TTL, improving performance for repeated requests.
- Updated the aggregate API to return a structured response indicating whether any upstream requests failed, enhancing error handling and response clarity.
- Modified documentation in AGGREGATE.md and README.md to reflect the new CORS and caching features.
- Added tests to validate the new functionality in the aggregate handler.

internal/aggregate/handlers_test.go

@@ -35,7 +35,7 @@ func TestHandlerResolveAndFetch(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	h := NewHandler(parsed, up.Client(), nil)
+	h := NewHandler(parsed, up.Client(), nil, 0)
 	req := httptest.NewRequest(http.MethodGet, "/api/agg/summary?aliases=test", nil)
 	rec := httptest.NewRecorder()
 	h.ServeHTTP(rec, req)
@@ -54,6 +54,135 @@ func TestHandlerResolveAndFetch(t *testing.T) {
 	}
 }
 
+func TestHandlerFleetStatus(t *testing.T) {
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/v1/health":
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"ok": true, "data": map[string]any{"status": "ok", "read_only": false}, "revision": "rh",
+			})
+		case "/v1/system/info":
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"ok": true,
+				"data": map[string]any{
+					"version": "1.0.0", "target_arch": "amd64", "target_os": "linux", "build_profile": "release",
+					"process_started_at_epoch_secs": 1, "uptime_seconds": 10.0, "config_path": "/x.toml",
+					"config_hash": "abc", "config_reload_count": uint64(0),
+				},
+				"revision": "rs",
+			})
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer up.Close()
+
+	cfg := &config.Config{
+		Servers: []config.Server{
+			{Alias: "test", BaseURL: up.URL, PathPrefix: "/v1"},
+		},
+	}
+	if err := cfg.Validate(); err != nil {
+		t.Fatal(err)
+	}
+	parsed, err := cfg.Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := NewHandler(parsed, up.Client(), nil, 0)
+	req := httptest.NewRequest(http.MethodGet, "/api/agg/fleet-status?aliases=test", nil)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+	}
+	var env struct {
+		OK          bool            `json:"ok"`
+		Data        FleetStatusData `json:"data"`
+		GeneratedAt string          `json:"generated_at"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &env); err != nil {
+		t.Fatal(err)
+	}
+	if !env.OK || env.GeneratedAt == "" || len(env.Data.Servers) != 1 {
+		t.Fatalf("envelope: %+v", env)
+	}
+	s := env.Data.Servers[0]
+	if s.Alias != "test" || !s.OK || s.Health == nil || s.SystemInfo == nil {
+		t.Fatalf("server row: %+v", s)
+	}
+}
+
+func TestHandlerUserOne(t *testing.T) {
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/stats/users" {
+			http.NotFound(w, r)
+			return
+		}
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"ok": true,
+			"data": []map[string]any{{
+				"username": "u1", "total_octets": 1048576, "current_connections": 2,
+				"active_unique_ips": 1, "recent_unique_ips": 1,
+				"max_tcp_conns":       10,
+				"data_quota_bytes":    1000,
+			}},
+			"revision": "abc",
+		})
+	}))
+	defer up.Close()
+
+	cfg := &config.Config{
+		Servers: []config.Server{
+			{Alias: "test", BaseURL: up.URL, PathPrefix: "/v1"},
+		},
+	}
+	if err := cfg.Validate(); err != nil {
+		t.Fatal(err)
+	}
+	parsed, err := cfg.Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := NewHandler(parsed, up.Client(), nil, 0)
+	req := httptest.NewRequest(http.MethodGet, "/api/agg/user/u1?aliases=test", nil)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+	}
+	var env struct {
+		OK   bool    `json:"ok"`
+		Data UsersRow `json:"data"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &env); err != nil {
+		t.Fatal(err)
+	}
+	if env.Data.Username != "u1" || env.Data.MaxTCPConns == nil || *env.Data.MaxTCPConns != 10 {
+		t.Fatalf("row: %+v", env.Data)
+	}
+}
+
+func TestHandlerUserOneInvalidName(t *testing.T) {
+	cfg := &config.Config{
+		Servers: []config.Server{{Alias: "x", BaseURL: "http://127.0.0.1:1", PathPrefix: "/v1"}},
+	}
+	if err := cfg.Validate(); err != nil {
+		t.Fatal(err)
+	}
+	parsed, err := cfg.Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := NewHandler(parsed, http.DefaultClient, nil, 0)
+	req := httptest.NewRequest(http.MethodGet, "/api/agg/user/!!!", nil)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("got %d", rec.Code)
+	}
+}
+
 func TestHandlerMethodNotAllowed(t *testing.T) {
 	cfg := &config.Config{
 		Servers: []config.Server{{Alias: "x", BaseURL: "http://127.0.0.1:1", PathPrefix: "/v1"}},
@@ -65,7 +194,7 @@ func TestHandlerMethodNotAllowed(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	h := NewHandler(parsed, http.DefaultClient, nil)
+	h := NewHandler(parsed, http.DefaultClient, nil, 0)
 	req := httptest.NewRequest(http.MethodPost, "/api/agg/summary", nil)
 	rec := httptest.NewRecorder()
 	h.ServeHTTP(rec, req)