package discoverychain import ( "testing" "time" "github.com/hashicorp/consul/agent/connect" "github.com/hashicorp/consul/agent/structs" "github.com/stretchr/testify/require" ) type compileTestCase struct { entries *structs.DiscoveryChainConfigEntries setup func(req *CompileRequest) expect *structs.CompiledDiscoveryChain // expectIsDefault tests behavior of CompiledDiscoveryChain.IsDefault() expectIsDefault bool expectCustom bool expectErr string expectGraphErr bool } func TestCompile(t *testing.T) { t.Parallel() cases := map[string]compileTestCase{ "router with defaults": testcase_JustRouterWithDefaults(), "router with defaults and resolver": testcase_RouterWithDefaults_NoSplit_WithResolver(), "router with defaults and noop split": testcase_RouterWithDefaults_WithNoopSplit_DefaultResolver(), "router with defaults and noop split and resolver": testcase_RouterWithDefaults_WithNoopSplit_WithResolver(), "router with no destination": testcase_JustRouterWithNoDestination(), "route bypasses splitter": testcase_RouteBypassesSplit(), "noop split": testcase_NoopSplit_DefaultResolver(), "noop split with protocol from proxy defaults": testcase_NoopSplit_DefaultResolver_ProtocolFromProxyDefaults(), "noop split with resolver": testcase_NoopSplit_WithResolver(), "subset split": testcase_SubsetSplit(), "service split": testcase_ServiceSplit(), "split bypasses next splitter": testcase_SplitBypassesSplit(), "service redirect": testcase_ServiceRedirect(), "service and subset redirect": testcase_ServiceAndSubsetRedirect(), "datacenter redirect": testcase_DatacenterRedirect(), "datacenter redirect with mesh gateways": testcase_DatacenterRedirect_WithMeshGateways(), "service failover": testcase_ServiceFailover(), "service failover through redirect": testcase_ServiceFailoverThroughRedirect(), "circular resolver failover": testcase_Resolver_CircularFailover(), "service and subset failover": testcase_ServiceAndSubsetFailover(), "datacenter failover": testcase_DatacenterFailover(), "datacenter failover with mesh gateways": testcase_DatacenterFailover_WithMeshGateways(), "noop split to resolver with default subset": testcase_NoopSplit_WithDefaultSubset(), "resolver with default subset": testcase_Resolve_WithDefaultSubset(), "default resolver with external sni": testcase_DefaultResolver_ExternalSNI(), "resolver with no entries and inferring defaults": testcase_DefaultResolver(), "default resolver with proxy defaults": testcase_DefaultResolver_WithProxyDefaults(), "loadbalancer splitter and resolver": testcase_LBSplitterAndResolver(), "loadbalancer resolver": testcase_LBResolver(), "service redirect to service with default resolver is not a default chain": testcase_RedirectToDefaultResolverIsNotDefaultChain(), "all the bells and whistles": testcase_AllBellsAndWhistles(), "multi dc canary": testcase_MultiDatacenterCanary(), // various errors "splitter requires valid protocol": testcase_SplitterRequiresValidProtocol(), "router requires valid protocol": testcase_RouterRequiresValidProtocol(), "split to unsplittable protocol": testcase_SplitToUnsplittableProtocol(), "route to unroutable protocol": testcase_RouteToUnroutableProtocol(), "failover crosses protocols": testcase_FailoverCrossesProtocols(), "redirect crosses protocols": testcase_RedirectCrossesProtocols(), "redirect to missing subset": testcase_RedirectToMissingSubset(), "resolver with failover and external sni": testcase_Resolver_ExternalSNI_FailoverNotAllowed(), "resolver with subsets and external sni": testcase_Resolver_ExternalSNI_SubsetsNotAllowed(), "resolver with redirect and external sni": testcase_Resolver_ExternalSNI_RedirectNotAllowed(), // overrides "resolver with protocol from override": testcase_ResolverProtocolOverride(), "resolver with protocol from override ignored": testcase_ResolverProtocolOverrideIgnored(), "router ignored due to protocol override": testcase_RouterIgnored_ResolverProtocolOverride(), // circular references "circular resolver redirect": testcase_Resolver_CircularRedirect(), "circular split": testcase_CircularSplit(), } for name, tc := range cases { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() // sanity check entries are normalized and valid for _, entry := range tc.entries.Routers { require.NoError(t, entry.Normalize()) require.NoError(t, entry.Validate()) } for _, entry := range tc.entries.Splitters { require.NoError(t, entry.Normalize()) require.NoError(t, entry.Validate()) } for _, entry := range tc.entries.Resolvers { require.NoError(t, entry.Normalize()) require.NoError(t, entry.Validate()) } req := CompileRequest{ ServiceName: "main", EvaluateInNamespace: "default", EvaluateInDatacenter: "dc1", EvaluateInTrustDomain: "trustdomain.consul", UseInDatacenter: "dc1", Entries: tc.entries, } if tc.setup != nil { tc.setup(&req) } res, err := Compile(req) if tc.expectErr != "" { require.Error(t, err) require.Contains(t, err.Error(), tc.expectErr) _, ok := err.(*structs.ConfigEntryGraphError) if tc.expectGraphErr { require.True(t, ok, "%T is not a *ConfigEntryGraphError", err) } else { require.False(t, ok, "did not expect a *ConfigEntryGraphError here: %v", err) } } else { require.NoError(t, err) // Avoid requiring unnecessary test boilerplate and inject these // ourselves. tc.expect.ServiceName = "main" tc.expect.Namespace = "default" tc.expect.Datacenter = "dc1" if tc.expectCustom { require.NotEmpty(t, res.CustomizationHash) res.CustomizationHash = "" } else { require.Empty(t, res.CustomizationHash) } require.Equal(t, tc.expect, res) require.Equal(t, tc.expectIsDefault, res.IsDefault()) } }) } } func testcase_JustRouterWithDefaults() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: newDefaultServiceRoute("main", "default"), NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_JustRouterWithNoDestination() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", Routes: []structs.ServiceRoute{ { Match: &structs.ServiceRouteMatch{ HTTP: &structs.ServiceRouteHTTPMatch{ PathPrefix: "/", }, }, }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: &structs.ServiceRoute{ Match: &structs.ServiceRouteMatch{ HTTP: &structs.ServiceRouteHTTPMatch{ PathPrefix: "/", }, }, }, NextNode: "resolver:main.default.dc1", }, { Definition: newDefaultServiceRoute("main", "default"), NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_RouterWithDefaults_NoSplit_WithResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: newDefaultServiceRoute("main", "default"), NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 33 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_RouterWithDefaults_WithNoopSplit_DefaultResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: newDefaultServiceRoute("main", "default"), NextNode: "splitter:main.default", }, }, }, "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_NoopSplit_DefaultResolver_ProtocolFromProxyDefaults() compileTestCase { entries := newEntries() setGlobalProxyProtocol(entries, "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: newDefaultServiceRoute("main", "default"), NextNode: "splitter:main.default", }, }, }, "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_RouterWithDefaults_WithNoopSplit_WithResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: newDefaultServiceRoute("main", "default"), NextNode: "splitter:main.default", }, }, }, "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 33 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_RouteBypassesSplit() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") setServiceProtocol(entries, "other", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", Routes: []structs.ServiceRoute{ // route direct subset reference (bypass split) newSimpleRoute("other", func(r *structs.ServiceRoute) { r.Destination.ServiceSubset = "bypass" }), }, }, ) entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "other", Splits: []structs.ServiceSplit{ {Weight: 100, Service: "ignored"}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "other", Subsets: map[string]structs.ServiceResolverSubset{ "bypass": { Filter: "Service.Meta.version == bypass", }, }, }, ) router := entries.GetRouter(structs.NewServiceID("main", nil)) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: &router.Routes[0], NextNode: "resolver:bypass.other.default.dc1", }, { Definition: newDefaultServiceRoute("main", "default"), NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, "resolver:bypass.other.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "bypass.other.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "bypass.other.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "bypass.other.default.dc1": newTarget("other", "bypass", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == bypass", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_NoopSplit_DefaultResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_NoopSplit_WithResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:main.default.dc1", }, }, }, "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 33 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_SubsetSplit() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 60, ServiceSubset: "v2"}, {Weight: 40, ServiceSubset: "v1"}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Subsets: map[string]structs.ServiceResolverSubset{ "v1": { Filter: "Service.Meta.version == 1", }, "v2": { Filter: "Service.Meta.version == 2", }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 60, NextNode: "resolver:v2.main.default.dc1", }, { Weight: 40, NextNode: "resolver:v1.main.default.dc1", }, }, }, "resolver:v2.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v2.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v2.main.default.dc1", }, }, "resolver:v1.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v1.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v1.main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 2", } }), "v1.main.default.dc1": newTarget("main", "v1", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 1", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceSplit() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") setServiceProtocol(entries, "foo", "http") setServiceProtocol(entries, "bar", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 60, Service: "foo"}, {Weight: 40, Service: "bar"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 60, NextNode: "resolver:foo.default.dc1", }, { Weight: 40, NextNode: "resolver:bar.default.dc1", }, }, }, "resolver:foo.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "foo.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "foo.default.dc1", }, }, "resolver:bar.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "bar.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "bar.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "foo.default.dc1": newTarget("foo", "", "default", "dc1", nil), "bar.default.dc1": newTarget("bar", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_SplitBypassesSplit() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") setServiceProtocol(entries, "next", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ { Weight: 100, Service: "next", ServiceSubset: "bypassed", }, }, }, &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "next", Splits: []structs.ServiceSplit{ { Weight: 100, ServiceSubset: "not-bypassed", }, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "next", Subsets: map[string]structs.ServiceResolverSubset{ "bypassed": { Filter: "Service.Meta.version == bypass", }, "not-bypassed": { Filter: "Service.Meta.version != bypass", }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:bypassed.next.default.dc1", }, }, }, "resolver:bypassed.next.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "bypassed.next.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "bypassed.next.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "bypassed.next.default.dc1": newTarget("next", "bypassed", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == bypass", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceRedirect() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:other.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:other.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "other.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "other.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "other.default.dc1": newTarget("other", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceAndSubsetRedirect() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", ServiceSubset: "v2", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "other", Subsets: map[string]structs.ServiceResolverSubset{ "v1": { Filter: "Service.Meta.version == 1", }, "v2": { Filter: "Service.Meta.version == 2", }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:v2.other.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:v2.other.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v2.other.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v2.other.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "v2.other.default.dc1": newTarget("other", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 2", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DatacenterRedirect() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Redirect: &structs.ServiceResolverRedirect{ Datacenter: "dc9", }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc9", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc9": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc9", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc9", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc9": newTarget("main", "", "default", "dc9", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DatacenterRedirect_WithMeshGateways() compileTestCase { entries := newEntries() entries.GlobalProxy = &structs.ProxyConfigEntry{ Kind: structs.ProxyDefaults, Name: structs.ProxyConfigGlobal, MeshGateway: structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, }, } entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Redirect: &structs.ServiceResolverRedirect{ Datacenter: "dc9", }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc9", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc9": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc9", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc9", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc9": newTarget("main", "", "default", "dc9", func(t *structs.DiscoveryTarget) { t.MeshGateway = structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceFailover() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": {Service: "backup"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{"backup.default.dc1"}, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "backup.default.dc1": newTarget("backup", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceFailoverThroughRedirect() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "backup", Redirect: &structs.ServiceResolverRedirect{ Service: "actual", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": {Service: "backup"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{"actual.default.dc1"}, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "actual.default.dc1": newTarget("actual", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_Resolver_CircularFailover() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "backup", Failover: map[string]structs.ServiceResolverFailover{ "*": {Service: "main"}, }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": {Service: "backup"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{"backup.default.dc1"}, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "backup.default.dc1": newTarget("backup", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_ServiceAndSubsetFailover() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Subsets: map[string]structs.ServiceResolverSubset{ "backup": { Filter: "Service.Meta.version == backup", }, }, Failover: map[string]structs.ServiceResolverFailover{ "*": {ServiceSubset: "backup"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{"backup.main.default.dc1"}, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "backup.main.default.dc1": newTarget("main", "backup", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == backup", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DatacenterFailover() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": {Datacenters: []string{"dc2", "dc4"}}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{"main.default.dc2", "main.default.dc4"}, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "main.default.dc2": newTarget("main", "", "default", "dc2", nil), "main.default.dc4": newTarget("main", "", "default", "dc4", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DatacenterFailover_WithMeshGateways() compileTestCase { entries := newEntries() entries.GlobalProxy = &structs.ProxyConfigEntry{ Kind: structs.ProxyDefaults, Name: structs.ProxyConfigGlobal, MeshGateway: structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, }, } entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": {Datacenters: []string{"dc2", "dc4"}}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", Failover: &structs.DiscoveryFailover{ Targets: []string{ "main.default.dc2", "main.default.dc4", }, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), "main.default.dc2": newTarget("main", "", "default", "dc2", func(t *structs.DiscoveryTarget) { t.MeshGateway = structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, } }), "main.default.dc4": newTarget("main", "", "default", "dc4", func(t *structs.DiscoveryTarget) { t.MeshGateway = structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_NoopSplit_WithDefaultSubset() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", DefaultSubset: "v2", Subsets: map[string]structs.ServiceResolverSubset{ "v1": {Filter: "Service.Meta.version == 1"}, "v2": {Filter: "Service.Meta.version == 2"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 100, NextNode: "resolver:v2.main.default.dc1", }, }, }, "resolver:v2.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v2.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v2.main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 2", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DefaultResolver() compileTestCase { entries := newEntries() expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ // TODO-TARGET "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true} } func testcase_DefaultResolver_WithProxyDefaults() compileTestCase { entries := newEntries() entries.GlobalProxy = &structs.ProxyConfigEntry{ Kind: structs.ProxyDefaults, Name: structs.ProxyConfigGlobal, Config: map[string]interface{}{ "protocol": "grpc", }, MeshGateway: structs.MeshGatewayConfig{ Mode: structs.MeshGatewayModeRemote, }, } expect := &structs.CompiledDiscoveryChain{ Protocol: "grpc", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true} } func testcase_RedirectToDefaultResolverIsNotDefaultChain() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:other.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:other.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "other.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "other.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "other.default.dc1": newTarget("other", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: false /*being explicit here because this is the whole point of this test*/} } func testcase_Resolve_WithDefaultSubset() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", DefaultSubset: "v2", Subsets: map[string]structs.ServiceResolverSubset{ "v1": {Filter: "Service.Meta.version == 1"}, "v2": {Filter: "Service.Meta.version == 2"}, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:v2.main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:v2.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v2.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v2.main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 2", } }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_DefaultResolver_ExternalSNI() compileTestCase { entries := newEntries() entries.AddServices(&structs.ServiceConfigEntry{ Kind: structs.ServiceDefaults, Name: "main", ExternalSNI: "main.some.other.service.mesh", }) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", func(t *structs.DiscoveryTarget) { t.SNI = "main.some.other.service.mesh" t.External = true }), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true} } func testcase_Resolver_ExternalSNI_FailoverNotAllowed() compileTestCase { entries := newEntries() entries.AddServices(&structs.ServiceConfigEntry{ Kind: structs.ServiceDefaults, Name: "main", ExternalSNI: "main.some.other.service.mesh", }) entries.AddResolvers(&structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, Failover: map[string]structs.ServiceResolverFailover{ "*": {Service: "backup"}, }, }) return compileTestCase{ entries: entries, expectErr: `service "main" has an external SNI set; cannot define failover for external services`, expectGraphErr: true, } } func testcase_Resolver_ExternalSNI_SubsetsNotAllowed() compileTestCase { entries := newEntries() entries.AddServices(&structs.ServiceConfigEntry{ Kind: structs.ServiceDefaults, Name: "main", ExternalSNI: "main.some.other.service.mesh", }) entries.AddResolvers(&structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, Subsets: map[string]structs.ServiceResolverSubset{ "canary": { Filter: "Service.Meta.version == canary", }, }, }) return compileTestCase{ entries: entries, expectErr: `service "main" has an external SNI set; cannot define subsets for external services`, expectGraphErr: true, } } func testcase_Resolver_ExternalSNI_RedirectNotAllowed() compileTestCase { entries := newEntries() entries.AddServices(&structs.ServiceConfigEntry{ Kind: structs.ServiceDefaults, Name: "main", ExternalSNI: "main.some.other.service.mesh", }) entries.AddResolvers(&structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, Redirect: &structs.ServiceResolverRedirect{ Datacenter: "dc2", }, }) return compileTestCase{ entries: entries, expectErr: `service "main" has an external SNI set; cannot define redirects for external services`, expectGraphErr: true, } } func testcase_MultiDatacenterCanary() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") setServiceProtocol(entries, "main-dc2", "http") setServiceProtocol(entries, "main-dc3", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 60, Service: "main-dc2"}, {Weight: 40, Service: "main-dc3"}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main-dc2", Redirect: &structs.ServiceResolverRedirect{ Service: "main", Datacenter: "dc2", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main-dc3", Redirect: &structs.ServiceResolverRedirect{ Service: "main", Datacenter: "dc3", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", ConnectTimeout: 33 * time.Second, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 60, NextNode: "resolver:main.default.dc2", }, { Weight: 40, NextNode: "resolver:main.default.dc3", }, }, }, "resolver:main.default.dc2": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc2", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 33 * time.Second, Target: "main.default.dc2", }, }, "resolver:main.default.dc3": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc3", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 33 * time.Second, Target: "main.default.dc3", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc2": newTarget("main", "", "default", "dc2", nil), "main.default.dc3": newTarget("main", "", "default", "dc3", nil), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_AllBellsAndWhistles() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") setServiceProtocol(entries, "svc-redirect", "http") setServiceProtocol(entries, "svc-redirect-again", "http") setServiceProtocol(entries, "svc-split", "http") setServiceProtocol(entries, "svc-split-again", "http") setServiceProtocol(entries, "svc-split-one-more-time", "http") setServiceProtocol(entries, "redirected", "http") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", Routes: []structs.ServiceRoute{ newSimpleRoute("svc-redirect"), // double redirected to a default subset newSimpleRoute("svc-split"), // one split is split further }, }, ) entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "svc-split", Splits: []structs.ServiceSplit{ {Weight: 60, Service: "svc-redirect"}, // double redirected to a default subset {Weight: 40, Service: "svc-split-again"}, // split again }, }, &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "svc-split-again", Splits: []structs.ServiceSplit{ {Weight: 75, Service: "main", ServiceSubset: "v1"}, {Weight: 25, Service: "svc-split-one-more-time"}, }, }, &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "svc-split-one-more-time", Splits: []structs.ServiceSplit{ {Weight: 80, Service: "main", ServiceSubset: "v2"}, {Weight: 20, Service: "main", ServiceSubset: "v3"}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "svc-redirect", Redirect: &structs.ServiceResolverRedirect{ Service: "svc-redirect-again", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "svc-redirect-again", Redirect: &structs.ServiceResolverRedirect{ Service: "redirected", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "redirected", DefaultSubset: "prod", Subsets: map[string]structs.ServiceResolverSubset{ "prod": {Filter: "ServiceMeta.env == prod"}, "qa": {Filter: "ServiceMeta.env == qa"}, }, LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 100, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", DefaultSubset: "default-subset", Subsets: map[string]structs.ServiceResolverSubset{ "v1": {Filter: "Service.Meta.version == 1"}, "v2": {Filter: "Service.Meta.version == 2"}, "v3": {Filter: "Service.Meta.version == 3"}, "default-subset": {OnlyPassing: true}, }, }, ) var ( router = entries.GetRouter(structs.NewServiceID("main", nil)) ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "router:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "router:main.default": { Type: structs.DiscoveryGraphNodeTypeRouter, Name: "main.default", Routes: []*structs.DiscoveryRoute{ { Definition: &router.Routes[0], NextNode: "resolver:prod.redirected.default.dc1", }, { Definition: &router.Routes[1], NextNode: "splitter:svc-split.default", }, { Definition: newDefaultServiceRoute("main", "default"), NextNode: "resolver:default-subset.main.default.dc1", }, }, }, "splitter:svc-split.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "svc-split.default", Splits: []*structs.DiscoverySplit{ { Weight: 60, NextNode: "resolver:prod.redirected.default.dc1", }, { Weight: 30, NextNode: "resolver:v1.main.default.dc1", }, { Weight: 8, NextNode: "resolver:v2.main.default.dc1", }, { Weight: 2, NextNode: "resolver:v3.main.default.dc1", }, }, LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 100, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, "resolver:prod.redirected.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "prod.redirected.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "prod.redirected.default.dc1", }, LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 100, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, "resolver:v1.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v1.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v1.main.default.dc1", }, }, "resolver:v2.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v2.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v2.main.default.dc1", }, }, "resolver:v3.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "v3.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "v3.main.default.dc1", }, }, "resolver:default-subset.main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "default-subset.main.default.dc1", Resolver: &structs.DiscoveryResolver{ ConnectTimeout: 5 * time.Second, Target: "default-subset.main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "prod.redirected.default.dc1": newTarget("redirected", "prod", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "ServiceMeta.env == prod", } }), "v1.main.default.dc1": newTarget("main", "v1", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 1", } }), "v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 2", } }), "v3.main.default.dc1": newTarget("main", "v3", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{ Filter: "Service.Meta.version == 3", } }), "default-subset.main.default.dc1": newTarget("main", "default-subset", "default", "dc1", func(t *structs.DiscoveryTarget) { t.Subset = structs.ServiceResolverSubset{OnlyPassing: true} }), }, } return compileTestCase{entries: entries, expect: expect} } func testcase_SplitterRequiresValidProtocol() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "tcp") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: structs.ServiceSplitter, Name: "main", Splits: []structs.ServiceSplit{ {Weight: 90, Namespace: "v1"}, {Weight: 10, Namespace: "v2"}, }, }, ) return compileTestCase{ entries: entries, expectErr: "does not permit advanced routing or splitting behavior", expectGraphErr: true, } } func testcase_RouterRequiresValidProtocol() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "tcp") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: structs.ServiceRouter, Name: "main", Routes: []structs.ServiceRoute{ { Match: &structs.ServiceRouteMatch{ HTTP: &structs.ServiceRouteHTTPMatch{ PathExact: "/other", }, }, Destination: &structs.ServiceRouteDestination{ Namespace: "other", }, }, }, }, ) return compileTestCase{ entries: entries, expectErr: "does not permit advanced routing or splitting behavior", expectGraphErr: true, } } func testcase_SplitToUnsplittableProtocol() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "tcp") setServiceProtocol(entries, "other", "tcp") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: structs.ServiceSplitter, Name: "main", Splits: []structs.ServiceSplit{ {Weight: 90}, {Weight: 10, Service: "other"}, }, }, ) return compileTestCase{ entries: entries, expectErr: "does not permit advanced routing or splitting behavior", expectGraphErr: true, } } func testcase_RouteToUnroutableProtocol() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "tcp") setServiceProtocol(entries, "other", "tcp") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: structs.ServiceRouter, Name: "main", Routes: []structs.ServiceRoute{ { Match: &structs.ServiceRouteMatch{ HTTP: &structs.ServiceRouteHTTPMatch{ PathExact: "/other", }, }, Destination: &structs.ServiceRouteDestination{ Service: "other", }, }, }, }, ) return compileTestCase{ entries: entries, expectErr: "does not permit advanced routing or splitting behavior", expectGraphErr: true, } } func testcase_FailoverCrossesProtocols() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "grpc") setServiceProtocol(entries, "other", "tcp") entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "main", Failover: map[string]structs.ServiceResolverFailover{ "*": { Service: "other", }, }, }, ) return compileTestCase{ entries: entries, expectErr: "uses inconsistent protocols", expectGraphErr: true, } } func testcase_RedirectCrossesProtocols() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "grpc") setServiceProtocol(entries, "other", "tcp") entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", }, }, ) return compileTestCase{ entries: entries, expectErr: "uses inconsistent protocols", expectGraphErr: true, } } func testcase_RedirectToMissingSubset() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "other", ConnectTimeout: 33 * time.Second, }, &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", ServiceSubset: "v1", }, }, ) return compileTestCase{ entries: entries, expectErr: `does not have a subset named "v1"`, expectGraphErr: true, } } func testcase_ResolverProtocolOverride() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "grpc") expect := &structs.CompiledDiscoveryChain{ Protocol: "http2", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ // TODO-TARGET "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true, expectCustom: true, setup: func(req *CompileRequest) { req.OverrideProtocol = "http2" }, } } func testcase_ResolverProtocolOverrideIgnored() compileTestCase { // This shows that if you try to override the protocol to its current value // the override is completely ignored. entries := newEntries() setServiceProtocol(entries, "main", "http2") expect := &structs.CompiledDiscoveryChain{ Protocol: "http2", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ // TODO-TARGET "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true, setup: func(req *CompileRequest) { req.OverrideProtocol = "http2" }, } } func testcase_RouterIgnored_ResolverProtocolOverride() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "grpc") entries.AddRouters( &structs.ServiceRouterConfigEntry{ Kind: "service-router", Name: "main", }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "tcp", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: true, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, }, }, Targets: map[string]*structs.DiscoveryTarget{ // TODO-TARGET "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect, expectIsDefault: true, expectCustom: true, setup: func(req *CompileRequest) { req.OverrideProtocol = "tcp" }, } } func testcase_Resolver_CircularRedirect() compileTestCase { entries := newEntries() entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", Redirect: &structs.ServiceResolverRedirect{ Service: "other", }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "other", Redirect: &structs.ServiceResolverRedirect{ Service: "main", }, }, ) return compileTestCase{entries: entries, expectErr: "detected circular resolver redirect", expectGraphErr: true, } } func testcase_CircularSplit() compileTestCase { entries := newEntries() setGlobalProxyProtocol(entries, "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 100, Service: "other"}, }, }, &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "other", Splits: []structs.ServiceSplit{ {Weight: 100, Service: "main"}, }, }, ) return compileTestCase{entries: entries, expectErr: "detected circular reference", expectGraphErr: true, } } func testcase_LBSplitterAndResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "foo", "http") setServiceProtocol(entries, "bar", "http") setServiceProtocol(entries, "baz", "http") entries.AddSplitters( &structs.ServiceSplitterConfigEntry{ Kind: "service-splitter", Name: "main", Splits: []structs.ServiceSplit{ {Weight: 60, Service: "foo"}, {Weight: 20, Service: "bar"}, {Weight: 20, Service: "baz"}, }, }, ) entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "foo", LoadBalancer: &structs.LoadBalancer{ Policy: "least_request", LeastRequestConfig: &structs.LeastRequestConfig{ ChoiceCount: 3, }, }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "bar", LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 101, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "baz", LoadBalancer: &structs.LoadBalancer{ Policy: "maglev", HashPolicies: []structs.HashPolicy{ { Field: "cookie", FieldValue: "chocolate-chip", CookieConfig: &structs.CookieConfig{ TTL: 2 * time.Minute, Path: "/bowl", }, Terminal: true, }, }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "splitter:main.default", Nodes: map[string]*structs.DiscoveryGraphNode{ "splitter:main.default": { Type: structs.DiscoveryGraphNodeTypeSplitter, Name: "main.default", Splits: []*structs.DiscoverySplit{ { Weight: 60, NextNode: "resolver:foo.default.dc1", }, { Weight: 20, NextNode: "resolver:bar.default.dc1", }, { Weight: 20, NextNode: "resolver:baz.default.dc1", }, }, // The LB config from bar is attached because splitters only care about hash-based policies, // and it's the config from bar not baz because we pick the first one we encounter in the Splits. LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 101, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, // Each service's LB config is passed down from the service-resolver to the resolver node "resolver:foo.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "foo.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: false, ConnectTimeout: 5 * time.Second, Target: "foo.default.dc1", }, LoadBalancer: &structs.LoadBalancer{ Policy: "least_request", LeastRequestConfig: &structs.LeastRequestConfig{ ChoiceCount: 3, }, }, }, "resolver:bar.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "bar.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: false, ConnectTimeout: 5 * time.Second, Target: "bar.default.dc1", }, LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 101, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, "resolver:baz.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "baz.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: false, ConnectTimeout: 5 * time.Second, Target: "baz.default.dc1", }, LoadBalancer: &structs.LoadBalancer{ Policy: "maglev", HashPolicies: []structs.HashPolicy{ { Field: "cookie", FieldValue: "chocolate-chip", CookieConfig: &structs.CookieConfig{ TTL: 2 * time.Minute, Path: "/bowl", }, Terminal: true, }, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "foo.default.dc1": newTarget("foo", "", "default", "dc1", nil), "bar.default.dc1": newTarget("bar", "", "default", "dc1", nil), "baz.default.dc1": newTarget("baz", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } // ensure chain with LB cfg in resolver isn't a default chain (!IsDefault) func testcase_LBResolver() compileTestCase { entries := newEntries() setServiceProtocol(entries, "main", "http") entries.AddResolvers( &structs.ServiceResolverConfigEntry{ Kind: "service-resolver", Name: "main", LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 101, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, ) expect := &structs.CompiledDiscoveryChain{ Protocol: "http", StartNode: "resolver:main.default.dc1", Nodes: map[string]*structs.DiscoveryGraphNode{ "resolver:main.default.dc1": { Type: structs.DiscoveryGraphNodeTypeResolver, Name: "main.default.dc1", Resolver: &structs.DiscoveryResolver{ Default: false, ConnectTimeout: 5 * time.Second, Target: "main.default.dc1", }, LoadBalancer: &structs.LoadBalancer{ Policy: "ring_hash", RingHashConfig: &structs.RingHashConfig{ MaximumRingSize: 101, }, HashPolicies: []structs.HashPolicy{ { SourceIP: true, }, }, }, }, }, Targets: map[string]*structs.DiscoveryTarget{ "main.default.dc1": newTarget("main", "", "default", "dc1", nil), }, } return compileTestCase{entries: entries, expect: expect} } func newSimpleRoute(name string, muts ...func(*structs.ServiceRoute)) structs.ServiceRoute { r := structs.ServiceRoute{ Match: &structs.ServiceRouteMatch{ HTTP: &structs.ServiceRouteHTTPMatch{PathPrefix: "/" + name}, }, Destination: &structs.ServiceRouteDestination{Service: name}, } for _, mut := range muts { mut(&r) } return r } func setGlobalProxyProtocol(entries *structs.DiscoveryChainConfigEntries, protocol string) { entries.GlobalProxy = &structs.ProxyConfigEntry{ Kind: structs.ProxyDefaults, Name: structs.ProxyConfigGlobal, Config: map[string]interface{}{ "protocol": protocol, }, } } func setServiceProtocol(entries *structs.DiscoveryChainConfigEntries, name, protocol string) { entries.AddServices(&structs.ServiceConfigEntry{ Kind: structs.ServiceDefaults, Name: name, Protocol: protocol, }) } func newEntries() *structs.DiscoveryChainConfigEntries { return &structs.DiscoveryChainConfigEntries{ Routers: make(map[structs.ServiceID]*structs.ServiceRouterConfigEntry), Splitters: make(map[structs.ServiceID]*structs.ServiceSplitterConfigEntry), Resolvers: make(map[structs.ServiceID]*structs.ServiceResolverConfigEntry), } } func newTarget(service, serviceSubset, namespace, datacenter string, modFn func(t *structs.DiscoveryTarget)) *structs.DiscoveryTarget { t := structs.NewDiscoveryTarget(service, serviceSubset, namespace, datacenter) t.SNI = connect.TargetSNI(t, "trustdomain.consul") t.Name = t.SNI if modFn != nil { modFn(t) } return t }