feat: implement state manager

Author: buroa

internal/config/config.go

@@ -10,7 +10,7 @@ type Config struct {
 	Namespace          string
 	GatewayName        string
 	IngressClass       string
-	OutputDir          string
+	Output             string
 	DefaultInterval    time.Duration
 	DefaultDNSResolver string
 	DefaultCondition   string
@@ -23,7 +23,7 @@ func Load() *Config {
 	flag.StringVar(&cfg.Namespace, "namespace", "", "Namespace to watch (empty for all)")
 	flag.StringVar(&cfg.GatewayName, "gateway", "", "Gateway name to filter HTTPRoutes (required for HTTPRoute mode)")
 	flag.StringVar(&cfg.IngressClass, "ingress-class", "", "Ingress class to filter Ingresses (optional for Ingress mode)")
-	flag.StringVar(&cfg.OutputDir, "output", "/config", "Directory to write generated YAML files")
+	flag.StringVar(&cfg.Output, "output", "/config/gatus-sidecar.yaml", "File to write generated YAML")
 	flag.DurationVar(&cfg.DefaultInterval, "default-interval", time.Minute, "Default interval value for endpoints")
 	flag.StringVar(&cfg.DefaultDNSResolver, "default-dns", "tcp://1.1.1.1:53", "Default DNS resolver for endpoints")
 	flag.StringVar(&cfg.DefaultCondition, "default-condition", "[STATUS] == 200", "Default condition")

internal/controller/controller.go

@@ -20,26 +20,29 @@ import (
 	"k8s.io/client-go/rest"
 
 	"github.com/home-operations/gatus-sidecar/internal/config"
-	"github.com/home-operations/gatus-sidecar/internal/generator"
+	"github.com/home-operations/gatus-sidecar/internal/endpoint"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
+	"github.com/home-operations/gatus-sidecar/internal/state"
 )
 
 // Controller is a generic Kubernetes resource controller
 type Controller struct {
-	gvr     schema.GroupVersionResource
-	handler handler.ResourceHandler
-	convert func(*unstructured.Unstructured) (metav1.Object, error)
+	gvr          schema.GroupVersionResource
+	handler      handler.ResourceHandler
+	convert      func(*unstructured.Unstructured) (metav1.Object, error)
+	stateManager *state.Manager
 }
 
 // NewIngressController creates a controller for Ingress resources
-func NewIngressController(resourceHandler handler.ResourceHandler) *Controller {
+func NewIngressController(resourceHandler handler.ResourceHandler, stateManager *state.Manager) *Controller {
 	return &Controller{
 		gvr: schema.GroupVersionResource{
 			Group:    "networking.k8s.io",
 			Version:  "v1",
 			Resource: "ingresses",
 		},
-		handler: resourceHandler,
+		handler:      resourceHandler,
+		stateManager: stateManager,
 		convert: func(u *unstructured.Unstructured) (metav1.Object, error) {
 			ingress := &networkingv1.Ingress{}
 			if err := runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, ingress); err != nil {
@@ -51,10 +54,11 @@ func NewIngressController(resourceHandler handler.ResourceHandler) *Controller {
 }
 
 // NewHTTPRouteController creates a controller for HTTPRoute resources
-func NewHTTPRouteController(resourceHandler handler.ResourceHandler) *Controller {
+func NewHTTPRouteController(resourceHandler handler.ResourceHandler, stateManager *state.Manager) *Controller {
 	return &Controller{
-		gvr:     gatewayv1.SchemeGroupVersion.WithResource("httproutes"),
-		handler: resourceHandler,
+		gvr:          gatewayv1.SchemeGroupVersion.WithResource("httproutes"),
+		handler:      resourceHandler,
+		stateManager: stateManager,
 		convert: func(u *unstructured.Unstructured) (metav1.Object, error) {
 			route := &gatewayv1.HTTPRoute{}
 			if err := runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, route); err != nil {
@@ -133,21 +137,21 @@ func (c *Controller) handleEvent(cfg *config.Config, obj metav1.Object, eventTyp
 	}
 
 	name := obj.GetName()
-	filename := fmt.Sprintf("%s-%s.yaml", obj.GetName(), obj.GetNamespace())
+	namespace := obj.GetNamespace()
+	resource := fmt.Sprintf("%s-%s", name, namespace)
 
 	if eventType == watch.Deleted {
-		if err := generator.Delete(cfg.OutputDir, filename); err != nil {
-			slog.Error("failed to delete file for resource", c.handler.GetResourceName(), obj.GetName(), "error", err)
-		} else {
-			slog.Info("deleted file for resource", c.handler.GetResourceName(), obj.GetName())
+		changed := c.stateManager.Remove(resource)
+		if changed {
+			slog.Info("removed endpoint from state", "resource", c.handler.GetResourceName(), "name", name)
 		}
 		return
 	}
 
 	// Get the URL from the resource
 	url := c.handler.ExtractURL(obj)
 	if url == "" {
-		slog.Warn("resource has no hosts/hostnames", c.handler.GetResourceName(), obj.GetName())
+		slog.Warn("resource has no hosts/hostnames", "resource", c.handler.GetResourceName(), "name", name)
 		return
 	}
 
@@ -161,24 +165,29 @@ func (c *Controller) handleEvent(cfg *config.Config, obj metav1.Object, eventTyp
 	if annotations != nil {
 		if templateStr, ok := annotations[cfg.TemplateAnnotation]; ok && templateStr != "" {
 			if err := yaml.Unmarshal([]byte(templateStr), &templateData); err != nil {
-				slog.Error("failed to unmarshal template for resource", c.handler.GetResourceName(), obj.GetName(), "error", err)
+				slog.Error("failed to unmarshal template for resource", "resource", c.handler.GetResourceName(), "name", name, "error", err)
 				return
 			}
 		}
 	}
 
-	data := map[string]any{
-		"name":       name,
-		"url":        url,
-		"interval":   interval,
-		"client":     map[string]any{"dns-resolver": dnsResolver},
-		"conditions": []string{condition},
+	// Create endpoint state with defaults
+	endpoint := &endpoint.Endpoint{
+		Name:       name,
+		URL:        url,
+		Interval:   interval,
+		Client:     map[string]any{"dns-resolver": dnsResolver},
+		Conditions: []string{condition},
 	}
 
-	// Write with optional template data
-	if err := generator.Write(data, cfg.OutputDir, filename, templateData); err != nil {
-		slog.Error("write file for resource", c.handler.GetResourceName(), obj.GetName(), "error", err)
-	} else {
-		slog.Info("wrote file for resource", c.handler.GetResourceName(), obj.GetName())
+	// Apply template overrides if present
+	if templateData != nil {
+		endpoint.ApplyTemplate(templateData)
+	}
+
+	// Update state
+	changed := c.stateManager.AddOrUpdate(resource, endpoint)
+	if changed {
+		slog.Info("updated endpoint in state", "resource", c.handler.GetResourceName(), "name", name)
 	}
 }

internal/controller/httproute.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/home-operations/gatus-sidecar/internal/config"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
+	"github.com/home-operations/gatus-sidecar/internal/state"
 )
 
 // HTTPRouteHandler handles HTTPRoute resources
@@ -69,7 +70,8 @@ func referencesGateway(route *gatewayv1.HTTPRoute, gatewayName string) bool {
 }
 
 func RunHTTPRoute(ctx context.Context, cfg *config.Config) error {
+	stateManager := state.NewManager(cfg.Output)
 	handler := &HTTPRouteHandler{}
-	ctrl := NewHTTPRouteController(handler)
+	ctrl := NewHTTPRouteController(handler, stateManager)
 	return ctrl.Run(ctx, cfg)
 }

internal/controller/ingress.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/home-operations/gatus-sidecar/internal/config"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
+	"github.com/home-operations/gatus-sidecar/internal/state"
 )
 
 // IngressHandler handles Ingress resources
@@ -94,7 +95,8 @@ func hasIngressClass(ingress *networkingv1.Ingress, ingressClass string) bool {
 }
 
 func RunIngress(ctx context.Context, cfg *config.Config) error {
+	stateManager := state.NewManager(cfg.Output)
 	handler := &IngressHandler{}
-	ctrl := NewIngressController(handler)
+	ctrl := NewIngressController(handler, stateManager)
 	return ctrl.Run(ctx, cfg)
 }

internal/endpoint/endpoint.go

@@ -0,0 +1,79 @@
+package endpoint
+
+import "maps"
+
+// Endpoint represents the configuration for a single endpoint
+type Endpoint struct {
+	Name       string         `yaml:"name"`
+	URL        string         `yaml:"url"`
+	Interval   string         `yaml:"interval"`
+	Client     map[string]any `yaml:"client"`
+	Conditions []string       `yaml:"conditions"`
+	Extra      map[string]any `yaml:",inline,omitempty"` // For additional template fields
+}
+
+// ApplyTemplate applies template data to the endpoint, allowing overrides of default values
+func (e *Endpoint) ApplyTemplate(templateData map[string]any) {
+	if templateData == nil {
+		return
+	}
+
+	// Initialize Extra map if needed
+	if e.Extra == nil {
+		e.Extra = make(map[string]any)
+	}
+
+	// Apply template overrides
+	for key, value := range templateData {
+		switch key {
+		case "name":
+			e.setStringField(&e.Name, value)
+		case "url":
+			e.setStringField(&e.URL, value)
+		case "interval":
+			e.setStringField(&e.Interval, value)
+		case "client":
+			e.setClientField(value)
+		case "conditions":
+			e.setConditionsField(value)
+		default:
+			// Store other fields in Extra for inline YAML output
+			e.Extra[key] = value
+		}
+	}
+}
+
+// setStringField sets a string field if the value is a string
+func (e *Endpoint) setStringField(field *string, value any) {
+	if str, ok := value.(string); ok {
+		*field = str
+	}
+}
+
+// setClientField merges client settings
+func (e *Endpoint) setClientField(value any) {
+	if client, ok := value.(map[string]any); ok {
+		if e.Client == nil {
+			e.Client = make(map[string]any)
+		}
+		maps.Copy(e.Client, client)
+	}
+}
+
+// setConditionsField handles different condition formats
+func (e *Endpoint) setConditionsField(value any) {
+	switch v := value.(type) {
+	case []string:
+		e.Conditions = v
+	case []any:
+		conditions := make([]string, 0, len(v))
+		for _, cond := range v {
+			if str, ok := cond.(string); ok {
+				conditions = append(conditions, str)
+			}
+		}
+		e.Conditions = conditions
+	case string:
+		e.Conditions = []string{v}
+	}
+}