131 lines
4.8 KiB
Go
131 lines
4.8 KiB
Go
package v1
|
|
|
|
import (
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"github.com/wild-cloud/wild-central/internal/config"
|
|
"github.com/wild-cloud/wild-central/internal/haproxy"
|
|
)
|
|
|
|
// HaproxyStatus returns the status of the HAProxy service and current instance routes.
|
|
func (api *API) HaproxyStatus(w http.ResponseWriter, r *http.Request) {
|
|
status, err := api.haproxy.GetStatus()
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to get HAProxy status: %v", err))
|
|
return
|
|
}
|
|
routes, _ := api.buildInstanceRoutes()
|
|
respondJSON(w, http.StatusOK, map[string]any{
|
|
"status": status.Status,
|
|
"pid": status.PID,
|
|
"configFile": status.ConfigFile,
|
|
"routes": routes,
|
|
})
|
|
}
|
|
|
|
// HaproxyGetConfig returns the current HAProxy configuration file contents
|
|
func (api *API) HaproxyGetConfig(w http.ResponseWriter, r *http.Request) {
|
|
content, err := api.haproxy.ReadConfig()
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to read HAProxy config: %v", err))
|
|
return
|
|
}
|
|
respondJSON(w, http.StatusOK, map[string]any{
|
|
"configFile": api.haproxy.GetConfigPath(),
|
|
"content": content,
|
|
})
|
|
}
|
|
|
|
// HaproxyRestart restarts the HAProxy service
|
|
func (api *API) HaproxyRestart(w http.ResponseWriter, r *http.Request) {
|
|
if err := api.haproxy.RestartService(); err != nil {
|
|
respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to restart HAProxy: %v", err))
|
|
return
|
|
}
|
|
api.broadcastHaproxyEvent("haproxy:restart", "HAProxy service restarted")
|
|
respondJSON(w, http.StatusOK, map[string]string{
|
|
"message": "HAProxy service restarted successfully",
|
|
})
|
|
}
|
|
|
|
// HaproxyGenerate regenerates HAProxy config from all WC instance data and custom routes,
|
|
// then updates nftables to match. Both operations happen together so ports stay in sync.
|
|
func (api *API) HaproxyGenerate(w http.ResponseWriter, r *http.Request) {
|
|
routes, customRoutes, configContent, err := api.syncHAProxy()
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
respondJSON(w, http.StatusOK, map[string]any{
|
|
"message": "HAProxy configuration generated and applied successfully",
|
|
"routes": routes,
|
|
"customRoutes": len(customRoutes),
|
|
"config": configContent,
|
|
})
|
|
}
|
|
|
|
// syncHAProxy regenerates and applies the HAProxy and nftables configuration.
|
|
// Returns the routes, custom routes, and config content on success.
|
|
func (api *API) syncHAProxy() ([]haproxy.InstanceRoute, []haproxy.CustomRoute, string, error) {
|
|
routes, err := api.buildInstanceRoutes()
|
|
if err != nil {
|
|
return nil, nil, "", fmt.Errorf("failed to list instances: %w", err)
|
|
}
|
|
|
|
globalCfg, err := config.LoadState(api.statePath())
|
|
if err != nil {
|
|
return nil, nil, "", fmt.Errorf("failed to load global config: %w", err)
|
|
}
|
|
|
|
var customRoutes []haproxy.CustomRoute
|
|
for _, cr := range globalCfg.Cloud.HAProxy.CustomRoutes {
|
|
customRoutes = append(customRoutes, haproxy.CustomRoute{
|
|
Name: cr.Name,
|
|
Port: cr.Port,
|
|
Backend: cr.Backend,
|
|
})
|
|
}
|
|
|
|
configContent := api.haproxy.Generate(routes, customRoutes, globalCfg.Cloud.Central.Domain)
|
|
if err := api.haproxy.WriteConfig(configContent); err != nil {
|
|
return nil, nil, "", fmt.Errorf("failed to write HAProxy config: %w", err)
|
|
}
|
|
|
|
if err := api.haproxy.ReloadService(); err != nil {
|
|
return nil, nil, "", fmt.Errorf("failed to reload HAProxy: %w", err)
|
|
}
|
|
|
|
extraTCP, extraUDP := config.SplitExtraPorts(globalCfg.Cloud.Nftables.ExtraPorts)
|
|
extraUDP = append(extraUDP, api.vpnAutoUDPPorts()...)
|
|
ports := api.haproxy.GetListenPorts(routes, customRoutes)
|
|
nftContent := api.nftables.Generate(ports, extraTCP, extraUDP, globalCfg.Cloud.Nftables.WANInterface)
|
|
if err := api.nftables.WriteRules(nftContent); err != nil {
|
|
slog.Error("failed to update nftables rules", "component", "haproxy-sync", "error", err)
|
|
} else if err := api.nftables.ApplyRules(); err != nil {
|
|
slog.Error("failed to apply nftables rules", "component", "haproxy-sync", "error", err)
|
|
}
|
|
|
|
api.broadcastHaproxyEvent("haproxy:config", "HAProxy configuration updated and applied")
|
|
return routes, customRoutes, configContent, nil
|
|
}
|
|
|
|
// HaproxyStats returns live per-backend connection stats from the HAProxy stats socket
|
|
func (api *API) HaproxyStats(w http.ResponseWriter, r *http.Request) {
|
|
stats, err := api.haproxy.GetStats()
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to get HAProxy stats: %v", err))
|
|
return
|
|
}
|
|
respondJSON(w, http.StatusOK, map[string]any{"backends": stats})
|
|
}
|
|
|
|
// buildInstanceRoutes returns haproxy.InstanceRoute entries.
|
|
// TODO: Instance routes will be populated via service registration from Wild Cloud instances.
|
|
// For now, returns an empty list — Central doesn't manage instances directly.
|
|
func (api *API) buildInstanceRoutes() ([]haproxy.InstanceRoute, error) {
|
|
return nil, nil
|
|
}
|
|
|