feat(resources): add BuildHTTPRoute builder

Build the desired gateway.networking.k8s.io/v1 HTTPRoute as an
unstructured object (no sigs.k8s.io/gateway-api dependency), following
the BuildServiceMonitor pattern. A single PathPrefix rule routes to the
agent Service; the named service port is resolved to its port number for
the backendRef. Pure-function unit tests cover the nil/basics/custom-port
cases.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: stubbi

internal/resources/httproute.go

@@ -0,0 +1,116 @@
+package resources
+
+import (
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	hermesv1 "github.com/paperclipinc/hermes-operator/api/v1"
+)
+
+// HTTPRouteGVK is the Gateway API GroupVersionKind we emit. We build it as an
+// unstructured object to avoid taking a dependency on sigs.k8s.io/gateway-api;
+// the CRDs must be installed in the cluster for the route to take effect.
+func HTTPRouteGVK() schema.GroupVersionKind {
+	return schema.GroupVersionKind{Group: "gateway.networking.k8s.io", Version: "v1", Kind: "HTTPRoute"}
+}
+
+// HTTPRouteName returns the deterministic HTTPRoute name.
+func HTTPRouteName(inst *hermesv1.HermesInstance) string { return inst.Name }
+
+// servicePortNumber resolves a Service port name to its port number, mirroring
+// buildServicePorts. Falls back to GatewayPort when the name is not found.
+func servicePortNumber(inst *hermesv1.HermesInstance, name string) int32 {
+	for _, p := range inst.Spec.Networking.Service.Ports {
+		if p.Name == name {
+			return p.Port
+		}
+	}
+	if name == MetricsPortName {
+		port := inst.Spec.Observability.Metrics.Port
+		if port == 0 {
+			return DefaultMetricsPort
+		}
+		return port
+	}
+	return GatewayPort
+}
+
+// BuildHTTPRoute constructs the desired Gateway API HTTPRoute as an unstructured
+// object. It mirrors the Ingress builder: a single prefix rule routing to the
+// agent Service. Returns nil when no HTTPRoute is requested.
+func BuildHTTPRoute(inst *hermesv1.HermesInstance) *unstructured.Unstructured {
+	spec := inst.Spec.Networking.HTTPRoute
+	if spec == nil {
+		return nil
+	}
+
+	path := spec.Path
+	if path == "" {
+		path = "/"
+	}
+	portName := spec.ServicePortName
+	if portName == "" {
+		portName = GatewayPortName
+	}
+	// Gateway API backendRefs target a Service port by number, so resolve the
+	// requested named port to the port number emitted on the Service.
+	port := servicePortNumber(inst, portName)
+
+	parentRefs := make([]interface{}, 0, len(spec.ParentRefs))
+	for _, ref := range spec.ParentRefs {
+		pr := map[string]interface{}{
+			"name": ref.Name,
+		}
+		if ref.Namespace != nil {
+			pr["namespace"] = *ref.Namespace
+		}
+		if ref.SectionName != nil {
+			pr["sectionName"] = *ref.SectionName
+		}
+		parentRefs = append(parentRefs, pr)
+	}
+
+	hostnames := make([]interface{}, 0, len(spec.Hostnames))
+	for _, h := range spec.Hostnames {
+		hostnames = append(hostnames, h)
+	}
+
+	metadata := map[string]interface{}{
+		"name":      HTTPRouteName(inst),
+		"namespace": inst.Namespace,
+		"labels":    toIface(LabelsForInstance(inst)),
+	}
+	if len(spec.Annotations) > 0 {
+		metadata["annotations"] = toIface(spec.Annotations)
+	}
+
+	return &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": HTTPRouteGVK().GroupVersion().String(),
+			"kind":       HTTPRouteGVK().Kind,
+			"metadata":   metadata,
+			"spec": map[string]interface{}{
+				"parentRefs": parentRefs,
+				"hostnames":  hostnames,
+				"rules": []interface{}{
+					map[string]interface{}{
+						"matches": []interface{}{
+							map[string]interface{}{
+								"path": map[string]interface{}{
+									"type":  "PathPrefix",
+									"value": path,
+								},
+							},
+						},
+						"backendRefs": []interface{}{
+							map[string]interface{}{
+								"name": ServiceName(inst),
+								"port": int64(port),
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}

internal/resources/httproute_test.go

@@ -0,0 +1,104 @@
+package resources
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	hermesv1 "github.com/paperclipinc/hermes-operator/api/v1"
+)
+
+func TestBuildHTTPRoute_NilWhenUnset(t *testing.T) {
+	t.Parallel()
+	inst := &hermesv1.HermesInstance{ObjectMeta: metav1.ObjectMeta{Name: "demo", Namespace: "agents"}}
+	assert.Nil(t, BuildHTTPRoute(inst), "no HTTPRoute spec means no route")
+}
+
+func TestBuildHTTPRoute_Basics(t *testing.T) {
+	t.Parallel()
+	ns := "gateways"
+	section := "https"
+	inst := &hermesv1.HermesInstance{
+		ObjectMeta: metav1.ObjectMeta{Name: "demo", Namespace: "agents"},
+		Spec: hermesv1.HermesInstanceSpec{
+			Networking: hermesv1.NetworkingSpec{
+				HTTPRoute: &hermesv1.HTTPRouteSpec{
+					Enabled:   Ptr(true),
+					Hostnames: []string{"agent.example.com"},
+					ParentRefs: []hermesv1.HTTPRouteParentRef{
+						{Name: "public-gw", Namespace: &ns, SectionName: &section},
+					},
+					Annotations: map[string]string{"team": "platform"},
+				},
+			},
+		},
+	}
+
+	route := BuildHTTPRoute(inst)
+	require.NotNil(t, route)
+	assert.Equal(t, "gateway.networking.k8s.io/v1", route.GetAPIVersion())
+	assert.Equal(t, "HTTPRoute", route.GetKind())
+	assert.Equal(t, "demo", route.GetName())
+	assert.Equal(t, "agents", route.GetNamespace())
+	assert.Equal(t, "platform", route.GetAnnotations()["team"])
+
+	spec, _, _ := getNestedMap(route.Object, "spec")
+
+	parents := spec["parentRefs"].([]interface{})
+	require.Len(t, parents, 1)
+	pr := parents[0].(map[string]interface{})
+	assert.Equal(t, "public-gw", pr["name"])
+	assert.Equal(t, "gateways", pr["namespace"])
+	assert.Equal(t, "https", pr["sectionName"])
+
+	hostnames := spec["hostnames"].([]interface{})
+	assert.Equal(t, "agent.example.com", hostnames[0])
+
+	rules := spec["rules"].([]interface{})
+	require.Len(t, rules, 1)
+	rule := rules[0].(map[string]interface{})
+
+	match := rule["matches"].([]interface{})[0].(map[string]interface{})
+	path := match["path"].(map[string]interface{})
+	assert.Equal(t, "PathPrefix", path["type"])
+	assert.Equal(t, "/", path["value"])
+
+	backend := rule["backendRefs"].([]interface{})[0].(map[string]interface{})
+	assert.Equal(t, "demo", backend["name"])
+	assert.Equal(t, int64(GatewayPort), backend["port"], "backendRefs target the Service port by number")
+}
+
+func TestBuildHTTPRoute_CustomPathAndPort(t *testing.T) {
+	t.Parallel()
+	inst := &hermesv1.HermesInstance{
+		ObjectMeta: metav1.ObjectMeta{Name: "demo", Namespace: "agents"},
+		Spec: hermesv1.HermesInstanceSpec{
+			Networking: hermesv1.NetworkingSpec{
+				Service: hermesv1.ServiceSpec{
+					Ports: []hermesv1.NamedServicePort{{Name: "web", Port: 9000}},
+				},
+				HTTPRoute: &hermesv1.HTTPRouteSpec{
+					Enabled:         Ptr(true),
+					Path:            "/api",
+					ServicePortName: "web",
+				},
+			},
+		},
+	}
+	route := BuildHTTPRoute(inst)
+	require.NotNil(t, route)
+	spec, _, _ := getNestedMap(route.Object, "spec")
+	rule := spec["rules"].([]interface{})[0].(map[string]interface{})
+	path := rule["matches"].([]interface{})[0].(map[string]interface{})["path"].(map[string]interface{})
+	assert.Equal(t, "/api", path["value"])
+	backend := rule["backendRefs"].([]interface{})[0].(map[string]interface{})
+	assert.Equal(t, int64(9000), backend["port"], "named port resolves to its Service port number")
+}
+
+func TestHTTPRouteName(t *testing.T) {
+	t.Parallel()
+	inst := &hermesv1.HermesInstance{ObjectMeta: metav1.ObjectMeta{Name: "demo"}}
+	assert.Equal(t, "demo", HTTPRouteName(inst))
+}