feat: feats for onedr0p

Author: buroa

internal/config/config.go

@@ -10,6 +10,7 @@ type Config struct {
 	Namespace          string
 	GatewayName        string
 	IngressClass       string
+	AutoGroup          bool
 	Output             string
 	DefaultInterval    time.Duration
 	DefaultDNSResolver string
@@ -21,8 +22,9 @@ func Load() *Config {
 	cfg := &Config{}
 	flag.StringVar(&cfg.Mode, "mode", "httproute", "Mode to run in: 'httproute' or 'ingress'")
 	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.GatewayName, "gateway-name", "", "Gateway name to filter HTTPRoutes (optional)")
+	flag.StringVar(&cfg.IngressClass, "ingress-class", "", "Ingress class to filter Ingresses (optional)")
+	flag.BoolVar(&cfg.AutoGroup, "auto-group", false, "Automatically group endpoints by gateway name or ingress class")
 	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")

internal/controller/controller.go

@@ -8,12 +8,8 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
-
-	networkingv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/dynamic"
@@ -22,51 +18,15 @@ import (
 	"github.com/home-operations/gatus-sidecar/internal/config"
 	"github.com/home-operations/gatus-sidecar/internal/endpoint"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
-	"github.com/home-operations/gatus-sidecar/internal/state"
+	"github.com/home-operations/gatus-sidecar/internal/manager"
 )
 
 // Controller is a generic Kubernetes resource controller
 type Controller struct {
 	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, stateManager *state.Manager) *Controller {
-	return &Controller{
-		gvr: schema.GroupVersionResource{
-			Group:    "networking.k8s.io",
-			Version:  "v1",
-			Resource: "ingresses",
-		},
-		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 {
-				return nil, fmt.Errorf("failed to convert to Ingress: %w", err)
-			}
-			return ingress, nil
-		},
-	}
-}
-
-// NewHTTPRouteController creates a controller for HTTPRoute resources
-func NewHTTPRouteController(resourceHandler handler.ResourceHandler, stateManager *state.Manager) *Controller {
-	return &Controller{
-		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 {
-				return nil, fmt.Errorf("failed to convert to HTTPRoute: %w", err)
-			}
-			return route, nil
-		},
-	}
+	stateManager *manager.Manager
 }
 
 // Run starts the controller watch loop
@@ -180,6 +140,9 @@ func (c *Controller) handleEvent(cfg *config.Config, obj metav1.Object, eventTyp
 		Conditions: []string{condition},
 	}
 
+	// Apply resource-specific template if available
+	c.handler.ApplyTemplate(cfg, obj, endpoint)
+
 	// Apply template overrides if present
 	if templateData != nil {
 		endpoint.ApplyTemplate(templateData)

internal/controller/httproute.go

@@ -2,14 +2,18 @@ package controller
 
 import (
 	"context"
+	"fmt"
 	"strings"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/home-operations/gatus-sidecar/internal/config"
+	"github.com/home-operations/gatus-sidecar/internal/endpoint"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
-	"github.com/home-operations/gatus-sidecar/internal/state"
+	"github.com/home-operations/gatus-sidecar/internal/manager"
 )
 
 // HTTPRouteHandler handles HTTPRoute resources
@@ -45,18 +49,40 @@ func (h *HTTPRouteHandler) ExtractURL(obj metav1.Object) string {
 	if !strings.HasPrefix(url, "http") {
 		url = "https://" + url
 	}
+
 	return url
 }
 
 func (h *HTTPRouteHandler) GetResourceName() string {
 	return "route"
 }
 
+func (h *HTTPRouteHandler) ApplyTemplate(cfg *config.Config, obj metav1.Object, endpoint *endpoint.Endpoint) bool {
+	if cfg.AutoGroup {
+		route, ok := obj.(*gatewayv1.HTTPRoute)
+		if !ok {
+			return false
+		}
+
+		// If there are no ParentRefs, cannot group
+		if len(route.Spec.ParentRefs) == 0 {
+			return false
+		}
+
+		// Group by the first ParentRef (gateway) name
+		endpoint.Group = string(route.Spec.ParentRefs[0].Name)
+		return true
+	}
+
+	return false
+}
+
 // Helper functions for HTTPRoute
 func firstHTTPRouteHostname(route *gatewayv1.HTTPRoute) string {
 	for _, h := range route.Spec.Hostnames {
 		return string(h)
 	}
+
 	return ""
 }
 
@@ -66,11 +92,28 @@ func referencesGateway(route *gatewayv1.HTTPRoute, gatewayName string) bool {
 			return true
 		}
 	}
+
 	return false
 }
 
+// NewHTTPRouteController creates a controller for HTTPRoute resources
+func NewHTTPRouteController(resourceHandler handler.ResourceHandler, stateManager *manager.Manager) *Controller {
+	return &Controller{
+		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 {
+				return nil, fmt.Errorf("failed to convert to HTTPRoute: %w", err)
+			}
+			return route, nil
+		},
+	}
+}
+
 func RunHTTPRoute(ctx context.Context, cfg *config.Config) error {
-	stateManager := state.NewManager(cfg.Output)
+	stateManager := manager.NewManager(cfg.Output)
 	handler := &HTTPRouteHandler{}
 	ctrl := NewHTTPRouteController(handler, stateManager)
 	return ctrl.Run(ctx, cfg)

internal/controller/ingress.go

@@ -8,10 +8,14 @@ import (
 
 	networkingv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	"github.com/home-operations/gatus-sidecar/internal/config"
+	"github.com/home-operations/gatus-sidecar/internal/endpoint"
 	"github.com/home-operations/gatus-sidecar/internal/handler"
-	"github.com/home-operations/gatus-sidecar/internal/state"
+	"github.com/home-operations/gatus-sidecar/internal/manager"
 )
 
 // IngressHandler handles Ingress resources
@@ -29,6 +33,7 @@ func (h *IngressHandler) ShouldProcess(obj metav1.Object, cfg *config.Config) bo
 	if cfg.IngressClass != "" && !hasIngressClass(ingress, cfg.IngressClass) {
 		return false
 	}
+
 	return true
 }
 
@@ -52,20 +57,43 @@ func (h *IngressHandler) ExtractURL(obj metav1.Object) string {
 	if !strings.HasPrefix(url, "http") {
 		url = fmt.Sprintf("%s://%s", protocol, url)
 	}
+
 	return url
 }
 
 func (h *IngressHandler) GetResourceName() string {
 	return "ingress"
 }
 
+func (h *IngressHandler) ApplyTemplate(cfg *config.Config, obj metav1.Object, endpoint *endpoint.Endpoint) bool {
+	if cfg.AutoGroup {
+		ingress, ok := obj.(*networkingv1.Ingress)
+		if !ok {
+			return false
+		}
+
+		// Group by the first ParentRef (gateway) name
+		ingressClass := getIngressClass(ingress)
+		if ingressClass == "" {
+			return false
+		}
+
+		// Group by IngressClass
+		endpoint.Group = ingressClass
+		return true
+	}
+
+	return false
+}
+
 // Helper functions for Ingress
 func firstIngressHostname(ingress *networkingv1.Ingress) string {
 	for _, rule := range ingress.Spec.Rules {
 		if rule.Host != "" {
 			return rule.Host
 		}
 	}
+
 	return ""
 }
 
@@ -75,27 +103,52 @@ func hasIngressTLS(ingress *networkingv1.Ingress, hostname string) bool {
 			return true
 		}
 	}
+
 	return false
 }
 
 func hasIngressClass(ingress *networkingv1.Ingress, ingressClass string) bool {
+	return getIngressClass(ingress) == ingressClass
+}
+
+func getIngressClass(ingress *networkingv1.Ingress) string {
 	// Check spec.ingressClassName first (preferred)
-	if ingress.Spec.IngressClassName != nil && *ingress.Spec.IngressClassName == ingressClass {
-		return true
+	if ingress.Spec.IngressClassName != nil {
+		return *ingress.Spec.IngressClassName
 	}
 
 	// Fallback to annotation (legacy)
 	if ingress.Annotations != nil {
 		if class, ok := ingress.Annotations["kubernetes.io/ingress.class"]; ok {
-			return class == ingressClass
+			return class
 		}
 	}
 
-	return false
+	return ""
+}
+
+// NewIngressController creates a controller for Ingress resources
+func NewIngressController(resourceHandler handler.ResourceHandler, stateManager *manager.Manager) *Controller {
+	return &Controller{
+		gvr: schema.GroupVersionResource{
+			Group:    "networking.k8s.io",
+			Version:  "v1",
+			Resource: "ingresses",
+		},
+		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 {
+				return nil, fmt.Errorf("failed to convert to Ingress: %w", err)
+			}
+			return ingress, nil
+		},
+	}
 }
 
 func RunIngress(ctx context.Context, cfg *config.Config) error {
-	stateManager := state.NewManager(cfg.Output)
+	stateManager := manager.NewManager(cfg.Output)
 	handler := &IngressHandler{}
 	ctrl := NewIngressController(handler, stateManager)
 	return ctrl.Run(ctx, cfg)