mesh: create new routes-controller to reconcile xRoute types into a ComputedRoutes resource

go.mod

@@ -88,6 +88,7 @@ require (
 	github.com/mitchellh/pointerstructure v1.2.1
 	github.com/mitchellh/reflectwalk v1.0.2
 	github.com/natefinch/npipe v0.0.0-20160621034901-c1b8fa8bdcce
+	github.com/oklog/ulid v1.3.1
 	github.com/oklog/ulid/v2 v2.1.0
 	github.com/olekukonko/tablewriter v0.0.4
 	github.com/patrickmn/go-cache v2.1.0+incompatible
@@ -219,7 +220,6 @@ require (
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/nicolai86/scaleway-sdk v1.10.2-0.20180628010248-798f60e20bb2 // indirect
 	github.com/oklog/run v1.0.0 // indirect
-	github.com/oklog/ulid v1.3.1 // indirect
 	github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b // indirect
 	github.com/packethost/packngo v0.1.1-0.20180711074735-b9cb5096f54c // indirect
 	github.com/pierrec/lz4 v2.5.2+incompatible // indirect

internal/controller/helper.go

@@ -0,0 +1,34 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package controller
+
+import (
+	"github.com/hashicorp/consul/internal/resource"
+	"github.com/hashicorp/consul/proto-public/pbresource"
+)
+
+// MakeRequests accepts a list of pbresource.ID and pbresource.Reference items,
+// and mirrors them into a slice of []controller.Request items where the Type
+// of of the items has replaced by 'typ'.
+func MakeRequests[V resource.ReferenceOrID](
+	typ *pbresource.Type,
+	refs []V,
+) []Request {
+	if len(refs) == 0 {
+		return nil
+	}
+
+	out := make([]Request, 0, len(refs))
+	for _, ref := range refs {
+		out = append(out, Request{
+			ID: &pbresource.ID{
+				Type:    typ,
+				Tenancy: ref.GetTenancy(),
+				Name:    ref.GetName(),
+			},
+		})
+	}
+
+	return out
+}

internal/controller/helper_test.go

@@ -0,0 +1,77 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package controller
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/hashicorp/consul/internal/resource"
+	"github.com/hashicorp/consul/proto-public/pbresource"
+	"github.com/hashicorp/consul/proto/private/prototest"
+)
+
+func TestMakeRequests(t *testing.T) {
+	redType := &pbresource.Type{
+		Group:        "colors",
+		GroupVersion: "vfake",
+		Kind:         "red",
+	}
+	blueType := &pbresource.Type{
+		Group:        "colors",
+		GroupVersion: "vfake",
+		Kind:         "blue",
+	}
+
+	casparID := &pbresource.ID{
+		Type:    redType,
+		Tenancy: resource.DefaultNamespacedTenancy(),
+		Name:    "caspar",
+		Uid:     "ignored",
+	}
+	babypantsID := &pbresource.ID{
+		Type:    redType,
+		Tenancy: resource.DefaultNamespacedTenancy(),
+		Name:    "babypants",
+		Uid:     "ignored",
+	}
+	zimRef := &pbresource.Reference{
+		Type:    redType,
+		Tenancy: resource.DefaultNamespacedTenancy(),
+		Name:    "zim",
+		Section: "ignored",
+	}
+	girRef := &pbresource.Reference{
+		Type:    redType,
+		Tenancy: resource.DefaultNamespacedTenancy(),
+		Name:    "gir",
+		Section: "ignored",
+	}
+
+	newBlueReq := func(name string) Request {
+		return Request{
+			ID: &pbresource.ID{
+				Type:    blueType,
+				Tenancy: resource.DefaultNamespacedTenancy(),
+				Name:    name,
+			},
+		}
+	}
+
+	require.Nil(t, MakeRequests[*pbresource.ID](blueType, nil))
+	require.Nil(t, MakeRequests[*pbresource.Reference](blueType, nil))
+
+	prototest.AssertElementsMatch(t, []Request{
+		newBlueReq("caspar"), newBlueReq("babypants"),
+	}, MakeRequests[*pbresource.ID](blueType, []*pbresource.ID{
+		casparID, babypantsID,
+	}))
+
+	prototest.AssertElementsMatch(t, []Request{
+		newBlueReq("gir"), newBlueReq("zim"),
+	}, MakeRequests[*pbresource.Reference](blueType, []*pbresource.Reference{
+		girRef, zimRef,
+	}))
+}

internal/mesh/exports.go

@@ -6,6 +6,7 @@ package mesh
 import (
 	"github.com/hashicorp/consul/internal/controller"
 	"github.com/hashicorp/consul/internal/mesh/internal/controllers"
+	"github.com/hashicorp/consul/internal/mesh/internal/controllers/routes"
 	"github.com/hashicorp/consul/internal/mesh/internal/controllers/sidecarproxy"
 	"github.com/hashicorp/consul/internal/mesh/internal/controllers/sidecarproxy/status"
 	"github.com/hashicorp/consul/internal/mesh/internal/types"
@@ -47,15 +48,16 @@ var (
 
 	// Resource Types for the latest version.
 
-	ProxyConfigurationType     = types.ProxyConfigurationType
-	UpstreamsType              = types.UpstreamsType
-	UpstreamsConfigurationType = types.UpstreamsConfigurationType
-	ProxyStateTemplateType     = types.ProxyStateTemplateType
-	HTTPRouteType              = types.HTTPRouteType
-	GRPCRouteType              = types.GRPCRouteType
-	TCPRouteType               = types.TCPRouteType
-	DestinationPolicyType      = types.DestinationPolicyType
-	ComputedRoutesType         = types.ComputedRoutesType
+	ProxyConfigurationType              = types.ProxyConfigurationType
+	UpstreamsType                       = types.UpstreamsType
+	UpstreamsConfigurationType          = types.UpstreamsConfigurationType
+	ProxyStateTemplateType              = types.ProxyStateTemplateType
+	ProxyStateTemplateConfigurationType = types.ProxyStateTemplateType
+	HTTPRouteType                       = types.HTTPRouteType
+	GRPCRouteType                       = types.GRPCRouteType
+	TCPRouteType                        = types.TCPRouteType
+	DestinationPolicyType               = types.DestinationPolicyType
+	ComputedRoutesType                  = types.ComputedRoutesType
 
 	// Controller statuses.
 
@@ -68,6 +70,25 @@ var (
 	SidecarProxyStatusReasonDestinationServiceFound        = status.StatusReasonDestinationServiceFound
 	SidecarProxyStatusReasonMeshProtocolDestinationPort    = status.StatusReasonMeshProtocolDestinationPort
 	SidecarProxyStatusReasonNonMeshProtocolDestinationPort = status.StatusReasonNonMeshProtocolDestinationPort
+
+	// Routes controller
+	RoutesStatusKey                                                = routes.StatusKey
+	RoutesStatusConditionAccepted                                  = routes.StatusConditionAccepted
+	RoutesStatusConditionAcceptedMissingParentRefReason            = routes.MissingParentRefReason
+	RoutesStatusConditionAcceptedMissingBackendRefReason           = routes.MissingBackendRefReason
+	RoutesStatusConditionAcceptedParentRefOutsideMeshReason        = routes.ParentRefOutsideMeshReason
+	RoutesStatusConditionAcceptedBackendRefOutsideMeshReason       = routes.BackendRefOutsideMeshReason
+	RoutesStatusConditionAcceptedParentRefUsingMeshPortReason      = routes.ParentRefUsingMeshPortReason
+	RoutesStatusConditionAcceptedBackendRefUsingMeshPortReason     = routes.BackendRefUsingMeshPortReason
+	RoutesStatusConditionAcceptedUnknownParentRefPortReason        = routes.UnknownParentRefPortReason
+	RoutesStatusConditionAcceptedUnknownBackendRefPortReason       = routes.UnknownBackendRefPortReason
+	RoutesStatusConditionAcceptedConflictNotBoundToParentRefReason = routes.ConflictNotBoundToParentRefReason
+)
+
+const (
+	// Important constants
+
+	NullRouteBackend = types.NullRouteBackend
 )
 
 // RegisterTypes adds all resource types within the "mesh" API group

internal/mesh/internal/controllers/register.go

@@ -7,6 +7,7 @@ import (
 	"github.com/hashicorp/consul/internal/catalog"
 	"github.com/hashicorp/consul/internal/controller"
 	"github.com/hashicorp/consul/internal/mesh/internal/cache/sidecarproxycache"
+	"github.com/hashicorp/consul/internal/mesh/internal/controllers/routes"
 	"github.com/hashicorp/consul/internal/mesh/internal/controllers/sidecarproxy"
 	"github.com/hashicorp/consul/internal/mesh/internal/controllers/xds"
 	"github.com/hashicorp/consul/internal/mesh/internal/mappers/sidecarproxymapper"
@@ -31,4 +32,6 @@ func Register(mgr *controller.Manager, deps Dependencies) {
 	mgr.Register(
 		sidecarproxy.Controller(destinationsCache, proxyCfgCache, m, deps.TrustDomainFetcher, deps.LocalDatacenter),
 	)
+
+	mgr.Register(routes.Controller())
 }

internal/mesh/internal/controllers/routes/controller.go

@@ -0,0 +1,178 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package routes
+
+import (
+	"context"
+
+	"github.com/hashicorp/go-hclog"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/anypb"
+
+	"github.com/hashicorp/consul/internal/catalog"
+	"github.com/hashicorp/consul/internal/controller"
+	"github.com/hashicorp/consul/internal/mesh/internal/controllers/routes/loader"
+	"github.com/hashicorp/consul/internal/mesh/internal/controllers/routes/xroutemapper"
+	"github.com/hashicorp/consul/internal/mesh/internal/types"
+	"github.com/hashicorp/consul/internal/resource"
+	pbmesh "github.com/hashicorp/consul/proto-public/pbmesh/v1alpha1"
+	"github.com/hashicorp/consul/proto-public/pbresource"
+)
+
+func Controller() controller.Controller {
+	mapper := xroutemapper.New()
+
+	r := &routesReconciler{
+		mapper: mapper,
+	}
+	return controller.ForType(types.ComputedRoutesType).
+		WithWatch(types.HTTPRouteType, mapper.MapHTTPRoute).
+		WithWatch(types.GRPCRouteType, mapper.MapGRPCRoute).
+		WithWatch(types.TCPRouteType, mapper.MapTCPRoute).
+		WithWatch(types.DestinationPolicyType, mapper.MapDestinationPolicy).
+		WithWatch(catalog.FailoverPolicyType, mapper.MapFailoverPolicy).
+		WithWatch(catalog.ServiceType, mapper.MapService).
+		WithReconciler(r)
+}
+
+type routesReconciler struct {
+	mapper *xroutemapper.Mapper
+}
+
+func (r *routesReconciler) Reconcile(ctx context.Context, rt controller.Runtime, req controller.Request) error {
+	// Notably don't inject the resource-id here into the logger, since we have
+	// to do a fan-out to multiple resources due to xRoutes having multiple
+	// parent refs.
+	rt.Logger = rt.Logger.With("controller", StatusKey)
+
+	rt.Logger.Trace("reconciling computed routes")
+
+	loggerFor := func(id *pbresource.ID) hclog.Logger {
+		return rt.Logger.With("resource-id", id)
+	}
+	related, err := loader.LoadResourcesForComputedRoutes(ctx, loggerFor, rt.Client, r.mapper, req.ID)
+	if err != nil {
+		rt.Logger.Error("error loading relevant resources", "error", err)
+		return err
+	}
+
+	pending := make(PendingStatuses)
+
+	ValidateXRouteReferences(related, pending)
+
+	generatedResults := GenerateComputedRoutes(related, pending)
+
+	if err := UpdatePendingStatuses(ctx, rt, pending); err != nil {
+		rt.Logger.Error("error updating statuses for affected relevant resources", "error", err)
+		return err
+	}
+
+	for _, result := range generatedResults {
+		computedRoutesID := result.ID
+
+		logger := rt.Logger.With("resource-id", computedRoutesID)
+
+		prev, err := resource.GetDecodedResource[*pbmesh.ComputedRoutes](ctx, rt.Client, computedRoutesID)
+		if err != nil {
+			logger.Error("error loading previous computed routes", "error", err)
+			return err
+		}
+
+		if err := ensureComputedRoutesIsSynced(ctx, logger, rt.Client, result, prev); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func ensureComputedRoutesIsSynced(
+	ctx context.Context,
+	logger hclog.Logger,
+	client pbresource.ResourceServiceClient,
+	result *ComputedRoutesResult,
+	prev *types.DecodedComputedRoutes,
+) error {
+	if result.Data == nil {
+		return deleteComputedRoutes(ctx, logger, client, prev)
+	}
+
+	// Upsert the resource if changed.
+	if prev != nil {
+		if proto.Equal(prev.Data, result.Data) {
+			return nil // no change
+		}
+		result.ID = prev.Resource.Id
+	}
+
+	return upsertComputedRoutes(ctx, logger, client, result.ID, result.OwnerID, result.Data)
+}
+
+func upsertComputedRoutes(
+	ctx context.Context,
+	logger hclog.Logger,
+	client pbresource.ResourceServiceClient,
+	id *pbresource.ID,
+	ownerID *pbresource.ID,
+	data *pbmesh.ComputedRoutes,
+) error {
+	mcData, err := anypb.New(data)
+	if err != nil {
+		logger.Error("error marshalling new computed routes payload", "error", err)
+		return err
+	}
+
+	// Now perform the write. The computed routes resource should be owned
+	// by the service so that it will automatically be deleted upon service
+	// deletion.
+
+	_, err = client.Write(ctx, &pbresource.WriteRequest{
+		Resource: &pbresource.Resource{
+			Id:    id,
+			Owner: ownerID,
+			Data:  mcData,
+		},
+	})
+	if err != nil {
+		logger.Error("error writing computed routes", "error", err)
+		return err
+	}
+
+	logger.Trace("updated computed routes resource was successfully written")
+
+	return nil
+}
+
+func deleteComputedRoutes(
+	ctx context.Context,
+	logger hclog.Logger,
+	client pbresource.ResourceServiceClient,
+	prev *types.DecodedComputedRoutes,
+) error {
+	if prev == nil {
+		return nil
+	}
+
+	// The service the computed routes controls no longer participates in the
+	// mesh at all.
+
+	logger.Trace("removing previous computed routes")
+
+	// This performs a CAS deletion.
+	_, err := client.Delete(ctx, &pbresource.DeleteRequest{
+		Id:      prev.Resource.Id,
+		Version: prev.Resource.Version,
+	})
+	// Potentially we could look for CAS failures by checking if the gRPC
+	// status code is Aborted. However its an edge case and there could
+	// possibly be other reasons why the gRPC status code would be aborted
+	// besides CAS version mismatches. The simplest thing to do is to just
+	// propagate the error and retry reconciliation later.
+	if err != nil {
+		logger.Error("error deleting previous computed routes resource", "error", err)
+		return err
+	}
+
+	return nil
+}