How to use main method of main Package

...87				require.NoError(t, entry.Normalize())88				require.NoError(t, entry.Validate())89			}90			req := CompileRequest{91				ServiceName:           "main",92				EvaluateInNamespace:   "default",93				EvaluateInDatacenter:  "dc1",94				EvaluateInTrustDomain: "trustdomain.consul",95				UseInDatacenter:       "dc1",96				Entries:               tc.entries,97			}98			if tc.setup != nil {99				tc.setup(&req)100			}101			res, err := Compile(req)102			if tc.expectErr != "" {103				require.Error(t, err)104				require.Contains(t, err.Error(), tc.expectErr)105				_, ok := err.(*structs.ConfigEntryGraphError)106				if tc.expectGraphErr {107					require.True(t, ok, "%T is not a *ConfigEntryGraphError", err)108				} else {109					require.False(t, ok, "did not expect a *ConfigEntryGraphError here: %v", err)110				}111			} else {112				require.NoError(t, err)113				// Avoid requiring unnecessary test boilerplate and inject these114				// ourselves.115				tc.expect.ServiceName = "main"116				tc.expect.Namespace = "default"117				tc.expect.Datacenter = "dc1"118				if tc.expectCustom {119					require.NotEmpty(t, res.CustomizationHash)120					res.CustomizationHash = ""121				} else {122					require.Empty(t, res.CustomizationHash)123				}124				require.Equal(t, tc.expect, res)125				require.Equal(t, tc.expectIsDefault, res.IsDefault())126			}127		})128	}129}130func testcase_JustRouterWithDefaults() compileTestCase {131	entries := newEntries()132	setServiceProtocol(entries, "main", "http")133	entries.AddRouters(134		&structs.ServiceRouterConfigEntry{135			Kind: "service-router",136			Name: "main",137		},138	)139	expect := &structs.CompiledDiscoveryChain{140		Protocol:  "http",141		StartNode: "router:main.default",142		Nodes: map[string]*structs.DiscoveryGraphNode{143			"router:main.default": {144				Type: structs.DiscoveryGraphNodeTypeRouter,145				Name: "main.default",146				Routes: []*structs.DiscoveryRoute{147					{148						Definition: newDefaultServiceRoute("main", "default"),149						NextNode:   "resolver:main.default.dc1",150					},151				},152			},153			"resolver:main.default.dc1": {154				Type: structs.DiscoveryGraphNodeTypeResolver,155				Name: "main.default.dc1",156				Resolver: &structs.DiscoveryResolver{157					Default:        true,158					ConnectTimeout: 5 * time.Second,159					Target:         "main.default.dc1",160				},161			},162		},163		Targets: map[string]*structs.DiscoveryTarget{164			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),165		},166	}167	return compileTestCase{entries: entries, expect: expect}168}169func testcase_JustRouterWithNoDestination() compileTestCase {170	entries := newEntries()171	setServiceProtocol(entries, "main", "http")172	entries.AddRouters(173		&structs.ServiceRouterConfigEntry{174			Kind: "service-router",175			Name: "main",176			Routes: []structs.ServiceRoute{177				{178					Match: &structs.ServiceRouteMatch{179						HTTP: &structs.ServiceRouteHTTPMatch{180							PathPrefix: "/",181						},182					},183				},184			},185		},186	)187	expect := &structs.CompiledDiscoveryChain{188		Protocol:  "http",189		StartNode: "router:main.default",190		Nodes: map[string]*structs.DiscoveryGraphNode{191			"router:main.default": {192				Type: structs.DiscoveryGraphNodeTypeRouter,193				Name: "main.default",194				Routes: []*structs.DiscoveryRoute{195					{196						Definition: &structs.ServiceRoute{197							Match: &structs.ServiceRouteMatch{198								HTTP: &structs.ServiceRouteHTTPMatch{199									PathPrefix: "/",200								},201							},202						},203						NextNode: "resolver:main.default.dc1",204					},205					{206						Definition: newDefaultServiceRoute("main", "default"),207						NextNode:   "resolver:main.default.dc1",208					},209				},210			},211			"resolver:main.default.dc1": {212				Type: structs.DiscoveryGraphNodeTypeResolver,213				Name: "main.default.dc1",214				Resolver: &structs.DiscoveryResolver{215					Default:        true,216					ConnectTimeout: 5 * time.Second,217					Target:         "main.default.dc1",218				},219			},220		},221		Targets: map[string]*structs.DiscoveryTarget{222			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),223		},224	}225	return compileTestCase{entries: entries, expect: expect}226}227func testcase_RouterWithDefaults_NoSplit_WithResolver() compileTestCase {228	entries := newEntries()229	setServiceProtocol(entries, "main", "http")230	entries.AddRouters(231		&structs.ServiceRouterConfigEntry{232			Kind: "service-router",233			Name: "main",234		},235	)236	entries.AddResolvers(237		&structs.ServiceResolverConfigEntry{238			Kind:           "service-resolver",239			Name:           "main",240			ConnectTimeout: 33 * time.Second,241		},242	)243	expect := &structs.CompiledDiscoveryChain{244		Protocol:  "http",245		StartNode: "router:main.default",246		Nodes: map[string]*structs.DiscoveryGraphNode{247			"router:main.default": {248				Type: structs.DiscoveryGraphNodeTypeRouter,249				Name: "main.default",250				Routes: []*structs.DiscoveryRoute{251					{252						Definition: newDefaultServiceRoute("main", "default"),253						NextNode:   "resolver:main.default.dc1",254					},255				},256			},257			"resolver:main.default.dc1": {258				Type: structs.DiscoveryGraphNodeTypeResolver,259				Name: "main.default.dc1",260				Resolver: &structs.DiscoveryResolver{261					ConnectTimeout: 33 * time.Second,262					Target:         "main.default.dc1",263				},264			},265		},266		Targets: map[string]*structs.DiscoveryTarget{267			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),268		},269	}270	return compileTestCase{entries: entries, expect: expect}271}272func testcase_RouterWithDefaults_WithNoopSplit_DefaultResolver() compileTestCase {273	entries := newEntries()274	setServiceProtocol(entries, "main", "http")275	entries.AddRouters(276		&structs.ServiceRouterConfigEntry{277			Kind: "service-router",278			Name: "main",279		},280	)281	entries.AddSplitters(282		&structs.ServiceSplitterConfigEntry{283			Kind: "service-splitter",284			Name: "main",285			Splits: []structs.ServiceSplit{286				{Weight: 100},287			},288		},289	)290	expect := &structs.CompiledDiscoveryChain{291		Protocol:  "http",292		StartNode: "router:main.default",293		Nodes: map[string]*structs.DiscoveryGraphNode{294			"router:main.default": {295				Type: structs.DiscoveryGraphNodeTypeRouter,296				Name: "main.default",297				Routes: []*structs.DiscoveryRoute{298					{299						Definition: newDefaultServiceRoute("main", "default"),300						NextNode:   "splitter:main.default",301					},302				},303			},304			"splitter:main.default": {305				Type: structs.DiscoveryGraphNodeTypeSplitter,306				Name: "main.default",307				Splits: []*structs.DiscoverySplit{308					{309						Weight:   100,310						NextNode: "resolver:main.default.dc1",311					},312				},313			},314			"resolver:main.default.dc1": {315				Type: structs.DiscoveryGraphNodeTypeResolver,316				Name: "main.default.dc1",317				Resolver: &structs.DiscoveryResolver{318					Default:        true,319					ConnectTimeout: 5 * time.Second,320					Target:         "main.default.dc1",321				},322			},323		},324		Targets: map[string]*structs.DiscoveryTarget{325			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),326		},327	}328	return compileTestCase{entries: entries, expect: expect}329}330func testcase_NoopSplit_DefaultResolver_ProtocolFromProxyDefaults() compileTestCase {331	entries := newEntries()332	setGlobalProxyProtocol(entries, "http")333	entries.AddRouters(334		&structs.ServiceRouterConfigEntry{335			Kind: "service-router",336			Name: "main",337		},338	)339	entries.AddSplitters(340		&structs.ServiceSplitterConfigEntry{341			Kind: "service-splitter",342			Name: "main",343			Splits: []structs.ServiceSplit{344				{Weight: 100},345			},346		},347	)348	expect := &structs.CompiledDiscoveryChain{349		Protocol:  "http",350		StartNode: "router:main.default",351		Nodes: map[string]*structs.DiscoveryGraphNode{352			"router:main.default": {353				Type: structs.DiscoveryGraphNodeTypeRouter,354				Name: "main.default",355				Routes: []*structs.DiscoveryRoute{356					{357						Definition: newDefaultServiceRoute("main", "default"),358						NextNode:   "splitter:main.default",359					},360				},361			},362			"splitter:main.default": {363				Type: structs.DiscoveryGraphNodeTypeSplitter,364				Name: "main.default",365				Splits: []*structs.DiscoverySplit{366					{367						Weight:   100,368						NextNode: "resolver:main.default.dc1",369					},370				},371			},372			"resolver:main.default.dc1": {373				Type: structs.DiscoveryGraphNodeTypeResolver,374				Name: "main.default.dc1",375				Resolver: &structs.DiscoveryResolver{376					Default:        true,377					ConnectTimeout: 5 * time.Second,378					Target:         "main.default.dc1",379				},380			},381		},382		Targets: map[string]*structs.DiscoveryTarget{383			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),384		},385	}386	return compileTestCase{entries: entries, expect: expect}387}388func testcase_RouterWithDefaults_WithNoopSplit_WithResolver() compileTestCase {389	entries := newEntries()390	setServiceProtocol(entries, "main", "http")391	entries.AddRouters(392		&structs.ServiceRouterConfigEntry{393			Kind: "service-router",394			Name: "main",395		},396	)397	entries.AddSplitters(398		&structs.ServiceSplitterConfigEntry{399			Kind: "service-splitter",400			Name: "main",401			Splits: []structs.ServiceSplit{402				{Weight: 100},403			},404		},405	)406	entries.AddResolvers(407		&structs.ServiceResolverConfigEntry{408			Kind:           "service-resolver",409			Name:           "main",410			ConnectTimeout: 33 * time.Second,411		},412	)413	expect := &structs.CompiledDiscoveryChain{414		Protocol:  "http",415		StartNode: "router:main.default",416		Nodes: map[string]*structs.DiscoveryGraphNode{417			"router:main.default": {418				Type: structs.DiscoveryGraphNodeTypeRouter,419				Name: "main.default",420				Routes: []*structs.DiscoveryRoute{421					{422						Definition: newDefaultServiceRoute("main", "default"),423						NextNode:   "splitter:main.default",424					},425				},426			},427			"splitter:main.default": {428				Type: structs.DiscoveryGraphNodeTypeSplitter,429				Name: "main.default",430				Splits: []*structs.DiscoverySplit{431					{432						Weight:   100,433						NextNode: "resolver:main.default.dc1",434					},435				},436			},437			"resolver:main.default.dc1": {438				Type: structs.DiscoveryGraphNodeTypeResolver,439				Name: "main.default.dc1",440				Resolver: &structs.DiscoveryResolver{441					ConnectTimeout: 33 * time.Second,442					Target:         "main.default.dc1",443				},444			},445		},446		Targets: map[string]*structs.DiscoveryTarget{447			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),448		},449	}450	return compileTestCase{entries: entries, expect: expect}451}452func testcase_RouteBypassesSplit() compileTestCase {453	entries := newEntries()454	setServiceProtocol(entries, "main", "http")455	setServiceProtocol(entries, "other", "http")456	entries.AddRouters(457		&structs.ServiceRouterConfigEntry{458			Kind: "service-router",459			Name: "main",460			Routes: []structs.ServiceRoute{461				// route direct subset reference (bypass split)462				newSimpleRoute("other", func(r *structs.ServiceRoute) {463					r.Destination.ServiceSubset = "bypass"464				}),465			},466		},467	)468	entries.AddSplitters(469		&structs.ServiceSplitterConfigEntry{470			Kind: "service-splitter",471			Name: "other",472			Splits: []structs.ServiceSplit{473				{Weight: 100, Service: "ignored"},474			},475		},476	)477	entries.AddResolvers(478		&structs.ServiceResolverConfigEntry{479			Kind: "service-resolver",480			Name: "other",481			Subsets: map[string]structs.ServiceResolverSubset{482				"bypass": {483					Filter: "Service.Meta.version == bypass",484				},485			},486		},487	)488	router := entries.GetRouter(structs.NewServiceID("main", nil))489	expect := &structs.CompiledDiscoveryChain{490		Protocol:  "http",491		StartNode: "router:main.default",492		Nodes: map[string]*structs.DiscoveryGraphNode{493			"router:main.default": {494				Type: structs.DiscoveryGraphNodeTypeRouter,495				Name: "main.default",496				Routes: []*structs.DiscoveryRoute{497					{498						Definition: &router.Routes[0],499						NextNode:   "resolver:bypass.other.default.dc1",500					},501					{502						Definition: newDefaultServiceRoute("main", "default"),503						NextNode:   "resolver:main.default.dc1",504					},505				},506			},507			"resolver:main.default.dc1": {508				Type: structs.DiscoveryGraphNodeTypeResolver,509				Name: "main.default.dc1",510				Resolver: &structs.DiscoveryResolver{511					Default:        true,512					ConnectTimeout: 5 * time.Second,513					Target:         "main.default.dc1",514				},515			},516			"resolver:bypass.other.default.dc1": {517				Type: structs.DiscoveryGraphNodeTypeResolver,518				Name: "bypass.other.default.dc1",519				Resolver: &structs.DiscoveryResolver{520					ConnectTimeout: 5 * time.Second,521					Target:         "bypass.other.default.dc1",522				},523			},524		},525		Targets: map[string]*structs.DiscoveryTarget{526			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),527			"bypass.other.default.dc1": newTarget("other", "bypass", "default", "dc1", func(t *structs.DiscoveryTarget) {528				t.Subset = structs.ServiceResolverSubset{529					Filter: "Service.Meta.version == bypass",530				}531			}),532		},533	}534	return compileTestCase{entries: entries, expect: expect}535}536func testcase_NoopSplit_DefaultResolver() compileTestCase {537	entries := newEntries()538	setServiceProtocol(entries, "main", "http")539	entries.AddSplitters(540		&structs.ServiceSplitterConfigEntry{541			Kind: "service-splitter",542			Name: "main",543			Splits: []structs.ServiceSplit{544				{Weight: 100},545			},546		},547	)548	expect := &structs.CompiledDiscoveryChain{549		Protocol:  "http",550		StartNode: "splitter:main.default",551		Nodes: map[string]*structs.DiscoveryGraphNode{552			"splitter:main.default": {553				Type: structs.DiscoveryGraphNodeTypeSplitter,554				Name: "main.default",555				Splits: []*structs.DiscoverySplit{556					{557						Weight:   100,558						NextNode: "resolver:main.default.dc1",559					},560				},561			},562			"resolver:main.default.dc1": {563				Type: structs.DiscoveryGraphNodeTypeResolver,564				Name: "main.default.dc1",565				Resolver: &structs.DiscoveryResolver{566					Default:        true,567					ConnectTimeout: 5 * time.Second,568					Target:         "main.default.dc1",569				},570			},571		},572		Targets: map[string]*structs.DiscoveryTarget{573			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),574		},575	}576	return compileTestCase{entries: entries, expect: expect}577}578func testcase_NoopSplit_WithResolver() compileTestCase {579	entries := newEntries()580	setServiceProtocol(entries, "main", "http")581	entries.AddSplitters(582		&structs.ServiceSplitterConfigEntry{583			Kind: "service-splitter",584			Name: "main",585			Splits: []structs.ServiceSplit{586				{Weight: 100},587			},588		},589	)590	entries.AddResolvers(591		&structs.ServiceResolverConfigEntry{592			Kind:           "service-resolver",593			Name:           "main",594			ConnectTimeout: 33 * time.Second,595		},596	)597	expect := &structs.CompiledDiscoveryChain{598		Protocol:  "http",599		StartNode: "splitter:main.default",600		Nodes: map[string]*structs.DiscoveryGraphNode{601			"splitter:main.default": {602				Type: structs.DiscoveryGraphNodeTypeSplitter,603				Name: "main.default",604				Splits: []*structs.DiscoverySplit{605					{606						Weight:   100,607						NextNode: "resolver:main.default.dc1",608					},609				},610			},611			"resolver:main.default.dc1": {612				Type: structs.DiscoveryGraphNodeTypeResolver,613				Name: "main.default.dc1",614				Resolver: &structs.DiscoveryResolver{615					ConnectTimeout: 33 * time.Second,616					Target:         "main.default.dc1",617				},618			},619		},620		Targets: map[string]*structs.DiscoveryTarget{621			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),622		},623	}624	return compileTestCase{entries: entries, expect: expect}625}626func testcase_SubsetSplit() compileTestCase {627	entries := newEntries()628	setServiceProtocol(entries, "main", "http")629	entries.AddSplitters(630		&structs.ServiceSplitterConfigEntry{631			Kind: "service-splitter",632			Name: "main",633			Splits: []structs.ServiceSplit{634				{Weight: 60, ServiceSubset: "v2"},635				{Weight: 40, ServiceSubset: "v1"},636			},637		},638	)639	entries.AddResolvers(640		&structs.ServiceResolverConfigEntry{641			Kind: "service-resolver",642			Name: "main",643			Subsets: map[string]structs.ServiceResolverSubset{644				"v1": {645					Filter: "Service.Meta.version == 1",646				},647				"v2": {648					Filter: "Service.Meta.version == 2",649				},650			},651		},652	)653	expect := &structs.CompiledDiscoveryChain{654		Protocol:  "http",655		StartNode: "splitter:main.default",656		Nodes: map[string]*structs.DiscoveryGraphNode{657			"splitter:main.default": {658				Type: structs.DiscoveryGraphNodeTypeSplitter,659				Name: "main.default",660				Splits: []*structs.DiscoverySplit{661					{662						Weight:   60,663						NextNode: "resolver:v2.main.default.dc1",664					},665					{666						Weight:   40,667						NextNode: "resolver:v1.main.default.dc1",668					},669				},670			},671			"resolver:v2.main.default.dc1": {672				Type: structs.DiscoveryGraphNodeTypeResolver,673				Name: "v2.main.default.dc1",674				Resolver: &structs.DiscoveryResolver{675					ConnectTimeout: 5 * time.Second,676					Target:         "v2.main.default.dc1",677				},678			},679			"resolver:v1.main.default.dc1": {680				Type: structs.DiscoveryGraphNodeTypeResolver,681				Name: "v1.main.default.dc1",682				Resolver: &structs.DiscoveryResolver{683					ConnectTimeout: 5 * time.Second,684					Target:         "v1.main.default.dc1",685				},686			},687		},688		Targets: map[string]*structs.DiscoveryTarget{689			"v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) {690				t.Subset = structs.ServiceResolverSubset{691					Filter: "Service.Meta.version == 2",692				}693			}),694			"v1.main.default.dc1": newTarget("main", "v1", "default", "dc1", func(t *structs.DiscoveryTarget) {695				t.Subset = structs.ServiceResolverSubset{696					Filter: "Service.Meta.version == 1",697				}698			}),699		},700	}701	return compileTestCase{entries: entries, expect: expect}702}703func testcase_ServiceSplit() compileTestCase {704	entries := newEntries()705	setServiceProtocol(entries, "main", "http")706	setServiceProtocol(entries, "foo", "http")707	setServiceProtocol(entries, "bar", "http")708	entries.AddSplitters(709		&structs.ServiceSplitterConfigEntry{710			Kind: "service-splitter",711			Name: "main",712			Splits: []structs.ServiceSplit{713				{Weight: 60, Service: "foo"},714				{Weight: 40, Service: "bar"},715			},716		},717	)718	expect := &structs.CompiledDiscoveryChain{719		Protocol:  "http",720		StartNode: "splitter:main.default",721		Nodes: map[string]*structs.DiscoveryGraphNode{722			"splitter:main.default": {723				Type: structs.DiscoveryGraphNodeTypeSplitter,724				Name: "main.default",725				Splits: []*structs.DiscoverySplit{726					{727						Weight:   60,728						NextNode: "resolver:foo.default.dc1",729					},730					{731						Weight:   40,732						NextNode: "resolver:bar.default.dc1",733					},734				},735			},736			"resolver:foo.default.dc1": {737				Type: structs.DiscoveryGraphNodeTypeResolver,738				Name: "foo.default.dc1",739				Resolver: &structs.DiscoveryResolver{740					Default:        true,741					ConnectTimeout: 5 * time.Second,742					Target:         "foo.default.dc1",743				},744			},745			"resolver:bar.default.dc1": {746				Type: structs.DiscoveryGraphNodeTypeResolver,747				Name: "bar.default.dc1",748				Resolver: &structs.DiscoveryResolver{749					Default:        true,750					ConnectTimeout: 5 * time.Second,751					Target:         "bar.default.dc1",752				},753			},754		},755		Targets: map[string]*structs.DiscoveryTarget{756			"foo.default.dc1": newTarget("foo", "", "default", "dc1", nil),757			"bar.default.dc1": newTarget("bar", "", "default", "dc1", nil),758		},759	}760	return compileTestCase{entries: entries, expect: expect}761}762func testcase_SplitBypassesSplit() compileTestCase {763	entries := newEntries()764	setServiceProtocol(entries, "main", "http")765	setServiceProtocol(entries, "next", "http")766	entries.AddSplitters(767		&structs.ServiceSplitterConfigEntry{768			Kind: "service-splitter",769			Name: "main",770			Splits: []structs.ServiceSplit{771				{772					Weight:        100,773					Service:       "next",774					ServiceSubset: "bypassed",775				},776			},777		},778		&structs.ServiceSplitterConfigEntry{779			Kind: "service-splitter",780			Name: "next",781			Splits: []structs.ServiceSplit{782				{783					Weight:        100,784					ServiceSubset: "not-bypassed",785				},786			},787		},788	)789	entries.AddResolvers(790		&structs.ServiceResolverConfigEntry{791			Kind: "service-resolver",792			Name: "next",793			Subsets: map[string]structs.ServiceResolverSubset{794				"bypassed": {795					Filter: "Service.Meta.version == bypass",796				},797				"not-bypassed": {798					Filter: "Service.Meta.version != bypass",799				},800			},801		},802	)803	expect := &structs.CompiledDiscoveryChain{804		Protocol:  "http",805		StartNode: "splitter:main.default",806		Nodes: map[string]*structs.DiscoveryGraphNode{807			"splitter:main.default": {808				Type: structs.DiscoveryGraphNodeTypeSplitter,809				Name: "main.default",810				Splits: []*structs.DiscoverySplit{811					{812						Weight:   100,813						NextNode: "resolver:bypassed.next.default.dc1",814					},815				},816			},817			"resolver:bypassed.next.default.dc1": {818				Type: structs.DiscoveryGraphNodeTypeResolver,819				Name: "bypassed.next.default.dc1",820				Resolver: &structs.DiscoveryResolver{821					ConnectTimeout: 5 * time.Second,822					Target:         "bypassed.next.default.dc1",823				},824			},825		},826		Targets: map[string]*structs.DiscoveryTarget{827			"bypassed.next.default.dc1": newTarget("next", "bypassed", "default", "dc1", func(t *structs.DiscoveryTarget) {828				t.Subset = structs.ServiceResolverSubset{829					Filter: "Service.Meta.version == bypass",830				}831			}),832		},833	}834	return compileTestCase{entries: entries, expect: expect}835}836func testcase_ServiceRedirect() compileTestCase {837	entries := newEntries()838	entries.AddResolvers(839		&structs.ServiceResolverConfigEntry{840			Kind: "service-resolver",841			Name: "main",842			Redirect: &structs.ServiceResolverRedirect{843				Service: "other",844			},845		},846	)847	expect := &structs.CompiledDiscoveryChain{848		Protocol:  "tcp",849		StartNode: "resolver:other.default.dc1",850		Nodes: map[string]*structs.DiscoveryGraphNode{851			"resolver:other.default.dc1": {852				Type: structs.DiscoveryGraphNodeTypeResolver,853				Name: "other.default.dc1",854				Resolver: &structs.DiscoveryResolver{855					Default:        true,856					ConnectTimeout: 5 * time.Second,857					Target:         "other.default.dc1",858				},859			},860		},861		Targets: map[string]*structs.DiscoveryTarget{862			"other.default.dc1": newTarget("other", "", "default", "dc1", nil),863		},864	}865	return compileTestCase{entries: entries, expect: expect}866}867func testcase_ServiceAndSubsetRedirect() compileTestCase {868	entries := newEntries()869	entries.AddResolvers(870		&structs.ServiceResolverConfigEntry{871			Kind: "service-resolver",872			Name: "main",873			Redirect: &structs.ServiceResolverRedirect{874				Service:       "other",875				ServiceSubset: "v2",876			},877		},878		&structs.ServiceResolverConfigEntry{879			Kind: "service-resolver",880			Name: "other",881			Subsets: map[string]structs.ServiceResolverSubset{882				"v1": {883					Filter: "Service.Meta.version == 1",884				},885				"v2": {886					Filter: "Service.Meta.version == 2",887				},888			},889		},890	)891	expect := &structs.CompiledDiscoveryChain{892		Protocol:  "tcp",893		StartNode: "resolver:v2.other.default.dc1",894		Nodes: map[string]*structs.DiscoveryGraphNode{895			"resolver:v2.other.default.dc1": {896				Type: structs.DiscoveryGraphNodeTypeResolver,897				Name: "v2.other.default.dc1",898				Resolver: &structs.DiscoveryResolver{899					ConnectTimeout: 5 * time.Second,900					Target:         "v2.other.default.dc1",901				},902			},903		},904		Targets: map[string]*structs.DiscoveryTarget{905			"v2.other.default.dc1": newTarget("other", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) {906				t.Subset = structs.ServiceResolverSubset{907					Filter: "Service.Meta.version == 2",908				}909			}),910		},911	}912	return compileTestCase{entries: entries, expect: expect}913}914func testcase_DatacenterRedirect() compileTestCase {915	entries := newEntries()916	entries.AddResolvers(917		&structs.ServiceResolverConfigEntry{918			Kind: "service-resolver",919			Name: "main",920			Redirect: &structs.ServiceResolverRedirect{921				Datacenter: "dc9",922			},923		},924	)925	expect := &structs.CompiledDiscoveryChain{926		Protocol:  "tcp",927		StartNode: "resolver:main.default.dc9",928		Nodes: map[string]*structs.DiscoveryGraphNode{929			"resolver:main.default.dc9": {930				Type: structs.DiscoveryGraphNodeTypeResolver,931				Name: "main.default.dc9",932				Resolver: &structs.DiscoveryResolver{933					ConnectTimeout: 5 * time.Second,934					Target:         "main.default.dc9",935				},936			},937		},938		Targets: map[string]*structs.DiscoveryTarget{939			"main.default.dc9": newTarget("main", "", "default", "dc9", nil),940		},941	}942	return compileTestCase{entries: entries, expect: expect}943}944func testcase_DatacenterRedirect_WithMeshGateways() compileTestCase {945	entries := newEntries()946	entries.GlobalProxy = &structs.ProxyConfigEntry{947		Kind: structs.ProxyDefaults,948		Name: structs.ProxyConfigGlobal,949		MeshGateway: structs.MeshGatewayConfig{950			Mode: structs.MeshGatewayModeRemote,951		},952	}953	entries.AddResolvers(954		&structs.ServiceResolverConfigEntry{955			Kind: "service-resolver",956			Name: "main",957			Redirect: &structs.ServiceResolverRedirect{958				Datacenter: "dc9",959			},960		},961	)962	expect := &structs.CompiledDiscoveryChain{963		Protocol:  "tcp",964		StartNode: "resolver:main.default.dc9",965		Nodes: map[string]*structs.DiscoveryGraphNode{966			"resolver:main.default.dc9": {967				Type: structs.DiscoveryGraphNodeTypeResolver,968				Name: "main.default.dc9",969				Resolver: &structs.DiscoveryResolver{970					ConnectTimeout: 5 * time.Second,971					Target:         "main.default.dc9",972				},973			},974		},975		Targets: map[string]*structs.DiscoveryTarget{976			"main.default.dc9": newTarget("main", "", "default", "dc9", func(t *structs.DiscoveryTarget) {977				t.MeshGateway = structs.MeshGatewayConfig{978					Mode: structs.MeshGatewayModeRemote,979				}980			}),981		},982	}983	return compileTestCase{entries: entries, expect: expect}984}985func testcase_ServiceFailover() compileTestCase {986	entries := newEntries()987	entries.AddResolvers(988		&structs.ServiceResolverConfigEntry{989			Kind: "service-resolver",990			Name: "main",991			Failover: map[string]structs.ServiceResolverFailover{992				"*": {Service: "backup"},993			},994		},995	)996	expect := &structs.CompiledDiscoveryChain{997		Protocol:  "tcp",998		StartNode: "resolver:main.default.dc1",999		Nodes: map[string]*structs.DiscoveryGraphNode{1000			"resolver:main.default.dc1": {1001				Type: structs.DiscoveryGraphNodeTypeResolver,1002				Name: "main.default.dc1",1003				Resolver: &structs.DiscoveryResolver{1004					ConnectTimeout: 5 * time.Second,1005					Target:         "main.default.dc1",1006					Failover: &structs.DiscoveryFailover{1007						Targets: []string{"backup.default.dc1"},1008					},1009				},1010			},1011		},1012		Targets: map[string]*structs.DiscoveryTarget{1013			"main.default.dc1":   newTarget("main", "", "default", "dc1", nil),1014			"backup.default.dc1": newTarget("backup", "", "default", "dc1", nil),1015		},1016	}1017	return compileTestCase{entries: entries, expect: expect}1018}1019func testcase_ServiceFailoverThroughRedirect() compileTestCase {1020	entries := newEntries()1021	entries.AddResolvers(1022		&structs.ServiceResolverConfigEntry{1023			Kind: "service-resolver",1024			Name: "backup",1025			Redirect: &structs.ServiceResolverRedirect{1026				Service: "actual",1027			},1028		},1029		&structs.ServiceResolverConfigEntry{1030			Kind: "service-resolver",1031			Name: "main",1032			Failover: map[string]structs.ServiceResolverFailover{1033				"*": {Service: "backup"},1034			},1035		},1036	)1037	expect := &structs.CompiledDiscoveryChain{1038		Protocol:  "tcp",1039		StartNode: "resolver:main.default.dc1",1040		Nodes: map[string]*structs.DiscoveryGraphNode{1041			"resolver:main.default.dc1": {1042				Type: structs.DiscoveryGraphNodeTypeResolver,1043				Name: "main.default.dc1",1044				Resolver: &structs.DiscoveryResolver{1045					ConnectTimeout: 5 * time.Second,1046					Target:         "main.default.dc1",1047					Failover: &structs.DiscoveryFailover{1048						Targets: []string{"actual.default.dc1"},1049					},1050				},1051			},1052		},1053		Targets: map[string]*structs.DiscoveryTarget{1054			"main.default.dc1":   newTarget("main", "", "default", "dc1", nil),1055			"actual.default.dc1": newTarget("actual", "", "default", "dc1", nil),1056		},1057	}1058	return compileTestCase{entries: entries, expect: expect}1059}1060func testcase_Resolver_CircularFailover() compileTestCase {1061	entries := newEntries()1062	entries.AddResolvers(1063		&structs.ServiceResolverConfigEntry{1064			Kind: "service-resolver",1065			Name: "backup",1066			Failover: map[string]structs.ServiceResolverFailover{1067				"*": {Service: "main"},1068			},1069		},1070		&structs.ServiceResolverConfigEntry{1071			Kind: "service-resolver",1072			Name: "main",1073			Failover: map[string]structs.ServiceResolverFailover{1074				"*": {Service: "backup"},1075			},1076		},1077	)1078	expect := &structs.CompiledDiscoveryChain{1079		Protocol:  "tcp",1080		StartNode: "resolver:main.default.dc1",1081		Nodes: map[string]*structs.DiscoveryGraphNode{1082			"resolver:main.default.dc1": {1083				Type: structs.DiscoveryGraphNodeTypeResolver,1084				Name: "main.default.dc1",1085				Resolver: &structs.DiscoveryResolver{1086					ConnectTimeout: 5 * time.Second,1087					Target:         "main.default.dc1",1088					Failover: &structs.DiscoveryFailover{1089						Targets: []string{"backup.default.dc1"},1090					},1091				},1092			},1093		},1094		Targets: map[string]*structs.DiscoveryTarget{1095			"main.default.dc1":   newTarget("main", "", "default", "dc1", nil),1096			"backup.default.dc1": newTarget("backup", "", "default", "dc1", nil),1097		},1098	}1099	return compileTestCase{entries: entries, expect: expect}1100}1101func testcase_ServiceAndSubsetFailover() compileTestCase {1102	entries := newEntries()1103	entries.AddResolvers(1104		&structs.ServiceResolverConfigEntry{1105			Kind: "service-resolver",1106			Name: "main",1107			Subsets: map[string]structs.ServiceResolverSubset{1108				"backup": {1109					Filter: "Service.Meta.version == backup",1110				},1111			},1112			Failover: map[string]structs.ServiceResolverFailover{1113				"*": {ServiceSubset: "backup"},1114			},1115		},1116	)1117	expect := &structs.CompiledDiscoveryChain{1118		Protocol:  "tcp",1119		StartNode: "resolver:main.default.dc1",1120		Nodes: map[string]*structs.DiscoveryGraphNode{1121			"resolver:main.default.dc1": {1122				Type: structs.DiscoveryGraphNodeTypeResolver,1123				Name: "main.default.dc1",1124				Resolver: &structs.DiscoveryResolver{1125					ConnectTimeout: 5 * time.Second,1126					Target:         "main.default.dc1",1127					Failover: &structs.DiscoveryFailover{1128						Targets: []string{"backup.main.default.dc1"},1129					},1130				},1131			},1132		},1133		Targets: map[string]*structs.DiscoveryTarget{1134			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1135			"backup.main.default.dc1": newTarget("main", "backup", "default", "dc1", func(t *structs.DiscoveryTarget) {1136				t.Subset = structs.ServiceResolverSubset{1137					Filter: "Service.Meta.version == backup",1138				}1139			}),1140		},1141	}1142	return compileTestCase{entries: entries, expect: expect}1143}1144func testcase_DatacenterFailover() compileTestCase {1145	entries := newEntries()1146	entries.AddResolvers(1147		&structs.ServiceResolverConfigEntry{1148			Kind: "service-resolver",1149			Name: "main",1150			Failover: map[string]structs.ServiceResolverFailover{1151				"*": {Datacenters: []string{"dc2", "dc4"}},1152			},1153		},1154	)1155	expect := &structs.CompiledDiscoveryChain{1156		Protocol:  "tcp",1157		StartNode: "resolver:main.default.dc1",1158		Nodes: map[string]*structs.DiscoveryGraphNode{1159			"resolver:main.default.dc1": {1160				Type: structs.DiscoveryGraphNodeTypeResolver,1161				Name: "main.default.dc1",1162				Resolver: &structs.DiscoveryResolver{1163					ConnectTimeout: 5 * time.Second,1164					Target:         "main.default.dc1",1165					Failover: &structs.DiscoveryFailover{1166						Targets: []string{"main.default.dc2", "main.default.dc4"},1167					},1168				},1169			},1170		},1171		Targets: map[string]*structs.DiscoveryTarget{1172			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1173			"main.default.dc2": newTarget("main", "", "default", "dc2", nil),1174			"main.default.dc4": newTarget("main", "", "default", "dc4", nil),1175		},1176	}1177	return compileTestCase{entries: entries, expect: expect}1178}1179func testcase_DatacenterFailover_WithMeshGateways() compileTestCase {1180	entries := newEntries()1181	entries.GlobalProxy = &structs.ProxyConfigEntry{1182		Kind: structs.ProxyDefaults,1183		Name: structs.ProxyConfigGlobal,1184		MeshGateway: structs.MeshGatewayConfig{1185			Mode: structs.MeshGatewayModeRemote,1186		},1187	}1188	entries.AddResolvers(1189		&structs.ServiceResolverConfigEntry{1190			Kind: "service-resolver",1191			Name: "main",1192			Failover: map[string]structs.ServiceResolverFailover{1193				"*": {Datacenters: []string{"dc2", "dc4"}},1194			},1195		},1196	)1197	expect := &structs.CompiledDiscoveryChain{1198		Protocol:  "tcp",1199		StartNode: "resolver:main.default.dc1",1200		Nodes: map[string]*structs.DiscoveryGraphNode{1201			"resolver:main.default.dc1": {1202				Type: structs.DiscoveryGraphNodeTypeResolver,1203				Name: "main.default.dc1",1204				Resolver: &structs.DiscoveryResolver{1205					ConnectTimeout: 5 * time.Second,1206					Target:         "main.default.dc1",1207					Failover: &structs.DiscoveryFailover{1208						Targets: []string{1209							"main.default.dc2",1210							"main.default.dc4",1211						},1212					},1213				},1214			},1215		},1216		Targets: map[string]*structs.DiscoveryTarget{1217			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1218			"main.default.dc2": newTarget("main", "", "default", "dc2", func(t *structs.DiscoveryTarget) {1219				t.MeshGateway = structs.MeshGatewayConfig{1220					Mode: structs.MeshGatewayModeRemote,1221				}1222			}),1223			"main.default.dc4": newTarget("main", "", "default", "dc4", func(t *structs.DiscoveryTarget) {1224				t.MeshGateway = structs.MeshGatewayConfig{1225					Mode: structs.MeshGatewayModeRemote,1226				}1227			}),1228		},1229	}1230	return compileTestCase{entries: entries, expect: expect}1231}1232func testcase_NoopSplit_WithDefaultSubset() compileTestCase {1233	entries := newEntries()1234	setServiceProtocol(entries, "main", "http")1235	entries.AddSplitters(1236		&structs.ServiceSplitterConfigEntry{1237			Kind: "service-splitter",1238			Name: "main",1239			Splits: []structs.ServiceSplit{1240				{Weight: 100},1241			},1242		},1243	)1244	entries.AddResolvers(1245		&structs.ServiceResolverConfigEntry{1246			Kind:          "service-resolver",1247			Name:          "main",1248			DefaultSubset: "v2",1249			Subsets: map[string]structs.ServiceResolverSubset{1250				"v1": {Filter: "Service.Meta.version == 1"},1251				"v2": {Filter: "Service.Meta.version == 2"},1252			},1253		},1254	)1255	expect := &structs.CompiledDiscoveryChain{1256		Protocol:  "http",1257		StartNode: "splitter:main.default",1258		Nodes: map[string]*structs.DiscoveryGraphNode{1259			"splitter:main.default": {1260				Type: structs.DiscoveryGraphNodeTypeSplitter,1261				Name: "main.default",1262				Splits: []*structs.DiscoverySplit{1263					{1264						Weight:   100,1265						NextNode: "resolver:v2.main.default.dc1",1266					},1267				},1268			},1269			"resolver:v2.main.default.dc1": {1270				Type: structs.DiscoveryGraphNodeTypeResolver,1271				Name: "v2.main.default.dc1",1272				Resolver: &structs.DiscoveryResolver{1273					ConnectTimeout: 5 * time.Second,1274					Target:         "v2.main.default.dc1",1275				},1276			},1277		},1278		Targets: map[string]*structs.DiscoveryTarget{1279			"v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) {1280				t.Subset = structs.ServiceResolverSubset{1281					Filter: "Service.Meta.version == 2",1282				}1283			}),1284		},1285	}1286	return compileTestCase{entries: entries, expect: expect}1287}1288func testcase_DefaultResolver() compileTestCase {1289	entries := newEntries()1290	expect := &structs.CompiledDiscoveryChain{1291		Protocol:  "tcp",1292		StartNode: "resolver:main.default.dc1",1293		Nodes: map[string]*structs.DiscoveryGraphNode{1294			"resolver:main.default.dc1": {1295				Type: structs.DiscoveryGraphNodeTypeResolver,1296				Name: "main.default.dc1",1297				Resolver: &structs.DiscoveryResolver{1298					Default:        true,1299					ConnectTimeout: 5 * time.Second,1300					Target:         "main.default.dc1",1301				},1302			},1303		},1304		Targets: map[string]*structs.DiscoveryTarget{1305			// TODO-TARGET1306			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1307		},1308	}1309	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true}1310}1311func testcase_DefaultResolver_WithProxyDefaults() compileTestCase {1312	entries := newEntries()1313	entries.GlobalProxy = &structs.ProxyConfigEntry{1314		Kind: structs.ProxyDefaults,1315		Name: structs.ProxyConfigGlobal,1316		Config: map[string]interface{}{1317			"protocol": "grpc",1318		},1319		MeshGateway: structs.MeshGatewayConfig{1320			Mode: structs.MeshGatewayModeRemote,1321		},1322	}1323	expect := &structs.CompiledDiscoveryChain{1324		Protocol:  "grpc",1325		StartNode: "resolver:main.default.dc1",1326		Nodes: map[string]*structs.DiscoveryGraphNode{1327			"resolver:main.default.dc1": {1328				Type: structs.DiscoveryGraphNodeTypeResolver,1329				Name: "main.default.dc1",1330				Resolver: &structs.DiscoveryResolver{1331					Default:        true,1332					ConnectTimeout: 5 * time.Second,1333					Target:         "main.default.dc1",1334				},1335			},1336		},1337		Targets: map[string]*structs.DiscoveryTarget{1338			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1339		},1340	}1341	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true}1342}1343func testcase_RedirectToDefaultResolverIsNotDefaultChain() compileTestCase {1344	entries := newEntries()1345	entries.AddResolvers(1346		&structs.ServiceResolverConfigEntry{1347			Kind: structs.ServiceResolver,1348			Name: "main",1349			Redirect: &structs.ServiceResolverRedirect{1350				Service: "other",1351			},1352		},1353	)1354	expect := &structs.CompiledDiscoveryChain{1355		Protocol:  "tcp",1356		StartNode: "resolver:other.default.dc1",1357		Nodes: map[string]*structs.DiscoveryGraphNode{1358			"resolver:other.default.dc1": {1359				Type: structs.DiscoveryGraphNodeTypeResolver,1360				Name: "other.default.dc1",1361				Resolver: &structs.DiscoveryResolver{1362					Default:        true,1363					ConnectTimeout: 5 * time.Second,1364					Target:         "other.default.dc1",1365				},1366			},1367		},1368		Targets: map[string]*structs.DiscoveryTarget{1369			"other.default.dc1": newTarget("other", "", "default", "dc1", nil),1370		},1371	}1372	return compileTestCase{entries: entries, expect: expect, expectIsDefault: false /*being explicit here because this is the whole point of this test*/}1373}1374func testcase_Resolve_WithDefaultSubset() compileTestCase {1375	entries := newEntries()1376	entries.AddResolvers(1377		&structs.ServiceResolverConfigEntry{1378			Kind:          "service-resolver",1379			Name:          "main",1380			DefaultSubset: "v2",1381			Subsets: map[string]structs.ServiceResolverSubset{1382				"v1": {Filter: "Service.Meta.version == 1"},1383				"v2": {Filter: "Service.Meta.version == 2"},1384			},1385		},1386	)1387	expect := &structs.CompiledDiscoveryChain{1388		Protocol:  "tcp",1389		StartNode: "resolver:v2.main.default.dc1",1390		Nodes: map[string]*structs.DiscoveryGraphNode{1391			"resolver:v2.main.default.dc1": {1392				Type: structs.DiscoveryGraphNodeTypeResolver,1393				Name: "v2.main.default.dc1",1394				Resolver: &structs.DiscoveryResolver{1395					ConnectTimeout: 5 * time.Second,1396					Target:         "v2.main.default.dc1",1397				},1398			},1399		},1400		Targets: map[string]*structs.DiscoveryTarget{1401			"v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) {1402				t.Subset = structs.ServiceResolverSubset{1403					Filter: "Service.Meta.version == 2",1404				}1405			}),1406		},1407	}1408	return compileTestCase{entries: entries, expect: expect}1409}1410func testcase_DefaultResolver_ExternalSNI() compileTestCase {1411	entries := newEntries()1412	entries.AddServices(&structs.ServiceConfigEntry{1413		Kind:        structs.ServiceDefaults,1414		Name:        "main",1415		ExternalSNI: "main.some.other.service.mesh",1416	})1417	expect := &structs.CompiledDiscoveryChain{1418		Protocol:  "tcp",1419		StartNode: "resolver:main.default.dc1",1420		Nodes: map[string]*structs.DiscoveryGraphNode{1421			"resolver:main.default.dc1": {1422				Type: structs.DiscoveryGraphNodeTypeResolver,1423				Name: "main.default.dc1",1424				Resolver: &structs.DiscoveryResolver{1425					Default:        true,1426					ConnectTimeout: 5 * time.Second,1427					Target:         "main.default.dc1",1428				},1429			},1430		},1431		Targets: map[string]*structs.DiscoveryTarget{1432			"main.default.dc1": newTarget("main", "", "default", "dc1", func(t *structs.DiscoveryTarget) {1433				t.SNI = "main.some.other.service.mesh"1434				t.External = true1435			}),1436		},1437	}1438	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true}1439}1440func testcase_Resolver_ExternalSNI_FailoverNotAllowed() compileTestCase {1441	entries := newEntries()1442	entries.AddServices(&structs.ServiceConfigEntry{1443		Kind:        structs.ServiceDefaults,1444		Name:        "main",1445		ExternalSNI: "main.some.other.service.mesh",1446	})1447	entries.AddResolvers(&structs.ServiceResolverConfigEntry{1448		Kind:           "service-resolver",1449		Name:           "main",1450		ConnectTimeout: 33 * time.Second,1451		Failover: map[string]structs.ServiceResolverFailover{1452			"*": {Service: "backup"},1453		},1454	})1455	return compileTestCase{1456		entries:        entries,1457		expectErr:      `service "main" has an external SNI set; cannot define failover for external services`,1458		expectGraphErr: true,1459	}1460}1461func testcase_Resolver_ExternalSNI_SubsetsNotAllowed() compileTestCase {1462	entries := newEntries()1463	entries.AddServices(&structs.ServiceConfigEntry{1464		Kind:        structs.ServiceDefaults,1465		Name:        "main",1466		ExternalSNI: "main.some.other.service.mesh",1467	})1468	entries.AddResolvers(&structs.ServiceResolverConfigEntry{1469		Kind:           "service-resolver",1470		Name:           "main",1471		ConnectTimeout: 33 * time.Second,1472		Subsets: map[string]structs.ServiceResolverSubset{1473			"canary": {1474				Filter: "Service.Meta.version == canary",1475			},1476		},1477	})1478	return compileTestCase{1479		entries:        entries,1480		expectErr:      `service "main" has an external SNI set; cannot define subsets for external services`,1481		expectGraphErr: true,1482	}1483}1484func testcase_Resolver_ExternalSNI_RedirectNotAllowed() compileTestCase {1485	entries := newEntries()1486	entries.AddServices(&structs.ServiceConfigEntry{1487		Kind:        structs.ServiceDefaults,1488		Name:        "main",1489		ExternalSNI: "main.some.other.service.mesh",1490	})1491	entries.AddResolvers(&structs.ServiceResolverConfigEntry{1492		Kind:           "service-resolver",1493		Name:           "main",1494		ConnectTimeout: 33 * time.Second,1495		Redirect: &structs.ServiceResolverRedirect{1496			Datacenter: "dc2",1497		},1498	})1499	return compileTestCase{1500		entries:        entries,1501		expectErr:      `service "main" has an external SNI set; cannot define redirects for external services`,1502		expectGraphErr: true,1503	}1504}1505func testcase_MultiDatacenterCanary() compileTestCase {1506	entries := newEntries()1507	setServiceProtocol(entries, "main", "http")1508	setServiceProtocol(entries, "main-dc2", "http")1509	setServiceProtocol(entries, "main-dc3", "http")1510	entries.AddSplitters(1511		&structs.ServiceSplitterConfigEntry{1512			Kind: "service-splitter",1513			Name: "main",1514			Splits: []structs.ServiceSplit{1515				{Weight: 60, Service: "main-dc2"},1516				{Weight: 40, Service: "main-dc3"},1517			},1518		},1519	)1520	entries.AddResolvers(1521		&structs.ServiceResolverConfigEntry{1522			Kind: "service-resolver",1523			Name: "main-dc2",1524			Redirect: &structs.ServiceResolverRedirect{1525				Service:    "main",1526				Datacenter: "dc2",1527			},1528		},1529		&structs.ServiceResolverConfigEntry{1530			Kind: "service-resolver",1531			Name: "main-dc3",1532			Redirect: &structs.ServiceResolverRedirect{1533				Service:    "main",1534				Datacenter: "dc3",1535			},1536		},1537		&structs.ServiceResolverConfigEntry{1538			Kind:           "service-resolver",1539			Name:           "main",1540			ConnectTimeout: 33 * time.Second,1541		},1542	)1543	expect := &structs.CompiledDiscoveryChain{1544		Protocol:  "http",1545		StartNode: "splitter:main.default",1546		Nodes: map[string]*structs.DiscoveryGraphNode{1547			"splitter:main.default": {1548				Type: structs.DiscoveryGraphNodeTypeSplitter,1549				Name: "main.default",1550				Splits: []*structs.DiscoverySplit{1551					{1552						Weight:   60,1553						NextNode: "resolver:main.default.dc2",1554					},1555					{1556						Weight:   40,1557						NextNode: "resolver:main.default.dc3",1558					},1559				},1560			},1561			"resolver:main.default.dc2": {1562				Type: structs.DiscoveryGraphNodeTypeResolver,1563				Name: "main.default.dc2",1564				Resolver: &structs.DiscoveryResolver{1565					ConnectTimeout: 33 * time.Second,1566					Target:         "main.default.dc2",1567				},1568			},1569			"resolver:main.default.dc3": {1570				Type: structs.DiscoveryGraphNodeTypeResolver,1571				Name: "main.default.dc3",1572				Resolver: &structs.DiscoveryResolver{1573					ConnectTimeout: 33 * time.Second,1574					Target:         "main.default.dc3",1575				},1576			},1577		},1578		Targets: map[string]*structs.DiscoveryTarget{1579			"main.default.dc2": newTarget("main", "", "default", "dc2", nil),1580			"main.default.dc3": newTarget("main", "", "default", "dc3", nil),1581		},1582	}1583	return compileTestCase{entries: entries, expect: expect}1584}1585func testcase_AllBellsAndWhistles() compileTestCase {1586	entries := newEntries()1587	setServiceProtocol(entries, "main", "http")1588	setServiceProtocol(entries, "svc-redirect", "http")1589	setServiceProtocol(entries, "svc-redirect-again", "http")1590	setServiceProtocol(entries, "svc-split", "http")1591	setServiceProtocol(entries, "svc-split-again", "http")1592	setServiceProtocol(entries, "svc-split-one-more-time", "http")1593	setServiceProtocol(entries, "redirected", "http")1594	entries.AddRouters(1595		&structs.ServiceRouterConfigEntry{1596			Kind: "service-router",1597			Name: "main",1598			Routes: []structs.ServiceRoute{1599				newSimpleRoute("svc-redirect"), // double redirected to a default subset1600				newSimpleRoute("svc-split"),    // one split is split further1601			},1602		},1603	)1604	entries.AddSplitters(1605		&structs.ServiceSplitterConfigEntry{1606			Kind: "service-splitter",1607			Name: "svc-split",1608			Splits: []structs.ServiceSplit{1609				{Weight: 60, Service: "svc-redirect"},    // double redirected to a default subset1610				{Weight: 40, Service: "svc-split-again"}, // split again1611			},1612		},1613		&structs.ServiceSplitterConfigEntry{1614			Kind: "service-splitter",1615			Name: "svc-split-again",1616			Splits: []structs.ServiceSplit{1617				{Weight: 75, Service: "main", ServiceSubset: "v1"},1618				{Weight: 25, Service: "svc-split-one-more-time"},1619			},1620		},1621		&structs.ServiceSplitterConfigEntry{1622			Kind: "service-splitter",1623			Name: "svc-split-one-more-time",1624			Splits: []structs.ServiceSplit{1625				{Weight: 80, Service: "main", ServiceSubset: "v2"},1626				{Weight: 20, Service: "main", ServiceSubset: "v3"},1627			},1628		},1629	)1630	entries.AddResolvers(1631		&structs.ServiceResolverConfigEntry{1632			Kind: "service-resolver",1633			Name: "svc-redirect",1634			Redirect: &structs.ServiceResolverRedirect{1635				Service: "svc-redirect-again",1636			},1637		},1638		&structs.ServiceResolverConfigEntry{1639			Kind: "service-resolver",1640			Name: "svc-redirect-again",1641			Redirect: &structs.ServiceResolverRedirect{1642				Service: "redirected",1643			},1644		},1645		&structs.ServiceResolverConfigEntry{1646			Kind:          "service-resolver",1647			Name:          "redirected",1648			DefaultSubset: "prod",1649			Subsets: map[string]structs.ServiceResolverSubset{1650				"prod": {Filter: "ServiceMeta.env == prod"},1651				"qa":   {Filter: "ServiceMeta.env == qa"},1652			},1653			LoadBalancer: &structs.LoadBalancer{1654				Policy: "ring_hash",1655				RingHashConfig: &structs.RingHashConfig{1656					MaximumRingSize: 100,1657				},1658				HashPolicies: []structs.HashPolicy{1659					{1660						SourceIP: true,1661					},1662				},1663			},1664		},1665		&structs.ServiceResolverConfigEntry{1666			Kind:          "service-resolver",1667			Name:          "main",1668			DefaultSubset: "default-subset",1669			Subsets: map[string]structs.ServiceResolverSubset{1670				"v1":             {Filter: "Service.Meta.version == 1"},1671				"v2":             {Filter: "Service.Meta.version == 2"},1672				"v3":             {Filter: "Service.Meta.version == 3"},1673				"default-subset": {OnlyPassing: true},1674			},1675		},1676	)1677	var (1678		router = entries.GetRouter(structs.NewServiceID("main", nil))1679	)1680	expect := &structs.CompiledDiscoveryChain{1681		Protocol:  "http",1682		StartNode: "router:main.default",1683		Nodes: map[string]*structs.DiscoveryGraphNode{1684			"router:main.default": {1685				Type: structs.DiscoveryGraphNodeTypeRouter,1686				Name: "main.default",1687				Routes: []*structs.DiscoveryRoute{1688					{1689						Definition: &router.Routes[0],1690						NextNode:   "resolver:prod.redirected.default.dc1",1691					},1692					{1693						Definition: &router.Routes[1],1694						NextNode:   "splitter:svc-split.default",1695					},1696					{1697						Definition: newDefaultServiceRoute("main", "default"),1698						NextNode:   "resolver:default-subset.main.default.dc1",1699					},1700				},1701			},1702			"splitter:svc-split.default": {1703				Type: structs.DiscoveryGraphNodeTypeSplitter,1704				Name: "svc-split.default",1705				Splits: []*structs.DiscoverySplit{1706					{1707						Weight:   60,1708						NextNode: "resolver:prod.redirected.default.dc1",1709					},1710					{1711						Weight:   30,1712						NextNode: "resolver:v1.main.default.dc1",1713					},1714					{1715						Weight:   8,1716						NextNode: "resolver:v2.main.default.dc1",1717					},1718					{1719						Weight:   2,1720						NextNode: "resolver:v3.main.default.dc1",1721					},1722				},1723				LoadBalancer: &structs.LoadBalancer{1724					Policy: "ring_hash",1725					RingHashConfig: &structs.RingHashConfig{1726						MaximumRingSize: 100,1727					},1728					HashPolicies: []structs.HashPolicy{1729						{1730							SourceIP: true,1731						},1732					},1733				},1734			},1735			"resolver:prod.redirected.default.dc1": {1736				Type: structs.DiscoveryGraphNodeTypeResolver,1737				Name: "prod.redirected.default.dc1",1738				Resolver: &structs.DiscoveryResolver{1739					ConnectTimeout: 5 * time.Second,1740					Target:         "prod.redirected.default.dc1",1741				},1742				LoadBalancer: &structs.LoadBalancer{1743					Policy: "ring_hash",1744					RingHashConfig: &structs.RingHashConfig{1745						MaximumRingSize: 100,1746					},1747					HashPolicies: []structs.HashPolicy{1748						{1749							SourceIP: true,1750						},1751					},1752				},1753			},1754			"resolver:v1.main.default.dc1": {1755				Type: structs.DiscoveryGraphNodeTypeResolver,1756				Name: "v1.main.default.dc1",1757				Resolver: &structs.DiscoveryResolver{1758					ConnectTimeout: 5 * time.Second,1759					Target:         "v1.main.default.dc1",1760				},1761			},1762			"resolver:v2.main.default.dc1": {1763				Type: structs.DiscoveryGraphNodeTypeResolver,1764				Name: "v2.main.default.dc1",1765				Resolver: &structs.DiscoveryResolver{1766					ConnectTimeout: 5 * time.Second,1767					Target:         "v2.main.default.dc1",1768				},1769			},1770			"resolver:v3.main.default.dc1": {1771				Type: structs.DiscoveryGraphNodeTypeResolver,1772				Name: "v3.main.default.dc1",1773				Resolver: &structs.DiscoveryResolver{1774					ConnectTimeout: 5 * time.Second,1775					Target:         "v3.main.default.dc1",1776				},1777			},1778			"resolver:default-subset.main.default.dc1": {1779				Type: structs.DiscoveryGraphNodeTypeResolver,1780				Name: "default-subset.main.default.dc1",1781				Resolver: &structs.DiscoveryResolver{1782					ConnectTimeout: 5 * time.Second,1783					Target:         "default-subset.main.default.dc1",1784				},1785			},1786		},1787		Targets: map[string]*structs.DiscoveryTarget{1788			"prod.redirected.default.dc1": newTarget("redirected", "prod", "default", "dc1", func(t *structs.DiscoveryTarget) {1789				t.Subset = structs.ServiceResolverSubset{1790					Filter: "ServiceMeta.env == prod",1791				}1792			}),1793			"v1.main.default.dc1": newTarget("main", "v1", "default", "dc1", func(t *structs.DiscoveryTarget) {1794				t.Subset = structs.ServiceResolverSubset{1795					Filter: "Service.Meta.version == 1",1796				}1797			}),1798			"v2.main.default.dc1": newTarget("main", "v2", "default", "dc1", func(t *structs.DiscoveryTarget) {1799				t.Subset = structs.ServiceResolverSubset{1800					Filter: "Service.Meta.version == 2",1801				}1802			}),1803			"v3.main.default.dc1": newTarget("main", "v3", "default", "dc1", func(t *structs.DiscoveryTarget) {1804				t.Subset = structs.ServiceResolverSubset{1805					Filter: "Service.Meta.version == 3",1806				}1807			}),1808			"default-subset.main.default.dc1": newTarget("main", "default-subset", "default", "dc1", func(t *structs.DiscoveryTarget) {1809				t.Subset = structs.ServiceResolverSubset{OnlyPassing: true}1810			}),1811		},1812	}1813	return compileTestCase{entries: entries, expect: expect}1814}1815func testcase_SplitterRequiresValidProtocol() compileTestCase {1816	entries := newEntries()1817	setServiceProtocol(entries, "main", "tcp")1818	entries.AddSplitters(1819		&structs.ServiceSplitterConfigEntry{1820			Kind: structs.ServiceSplitter,1821			Name: "main",1822			Splits: []structs.ServiceSplit{1823				{Weight: 90, Namespace: "v1"},1824				{Weight: 10, Namespace: "v2"},1825			},1826		},1827	)1828	return compileTestCase{1829		entries:        entries,1830		expectErr:      "does not permit advanced routing or splitting behavior",1831		expectGraphErr: true,1832	}1833}1834func testcase_RouterRequiresValidProtocol() compileTestCase {1835	entries := newEntries()1836	setServiceProtocol(entries, "main", "tcp")1837	entries.AddRouters(1838		&structs.ServiceRouterConfigEntry{1839			Kind: structs.ServiceRouter,1840			Name: "main",1841			Routes: []structs.ServiceRoute{1842				{1843					Match: &structs.ServiceRouteMatch{1844						HTTP: &structs.ServiceRouteHTTPMatch{1845							PathExact: "/other",1846						},1847					},1848					Destination: &structs.ServiceRouteDestination{1849						Namespace: "other",1850					},1851				},1852			},1853		},1854	)1855	return compileTestCase{1856		entries:        entries,1857		expectErr:      "does not permit advanced routing or splitting behavior",1858		expectGraphErr: true,1859	}1860}1861func testcase_SplitToUnsplittableProtocol() compileTestCase {1862	entries := newEntries()1863	setServiceProtocol(entries, "main", "tcp")1864	setServiceProtocol(entries, "other", "tcp")1865	entries.AddSplitters(1866		&structs.ServiceSplitterConfigEntry{1867			Kind: structs.ServiceSplitter,1868			Name: "main",1869			Splits: []structs.ServiceSplit{1870				{Weight: 90},1871				{Weight: 10, Service: "other"},1872			},1873		},1874	)1875	return compileTestCase{1876		entries:        entries,1877		expectErr:      "does not permit advanced routing or splitting behavior",1878		expectGraphErr: true,1879	}1880}1881func testcase_RouteToUnroutableProtocol() compileTestCase {1882	entries := newEntries()1883	setServiceProtocol(entries, "main", "tcp")1884	setServiceProtocol(entries, "other", "tcp")1885	entries.AddRouters(1886		&structs.ServiceRouterConfigEntry{1887			Kind: structs.ServiceRouter,1888			Name: "main",1889			Routes: []structs.ServiceRoute{1890				{1891					Match: &structs.ServiceRouteMatch{1892						HTTP: &structs.ServiceRouteHTTPMatch{1893							PathExact: "/other",1894						},1895					},1896					Destination: &structs.ServiceRouteDestination{1897						Service: "other",1898					},1899				},1900			},1901		},1902	)1903	return compileTestCase{1904		entries:        entries,1905		expectErr:      "does not permit advanced routing or splitting behavior",1906		expectGraphErr: true,1907	}1908}1909func testcase_FailoverCrossesProtocols() compileTestCase {1910	entries := newEntries()1911	setServiceProtocol(entries, "main", "grpc")1912	setServiceProtocol(entries, "other", "tcp")1913	entries.AddResolvers(1914		&structs.ServiceResolverConfigEntry{1915			Kind: structs.ServiceResolver,1916			Name: "main",1917			Failover: map[string]structs.ServiceResolverFailover{1918				"*": {1919					Service: "other",1920				},1921			},1922		},1923	)1924	return compileTestCase{1925		entries:        entries,1926		expectErr:      "uses inconsistent protocols",1927		expectGraphErr: true,1928	}1929}1930func testcase_RedirectCrossesProtocols() compileTestCase {1931	entries := newEntries()1932	setServiceProtocol(entries, "main", "grpc")1933	setServiceProtocol(entries, "other", "tcp")1934	entries.AddResolvers(1935		&structs.ServiceResolverConfigEntry{1936			Kind: structs.ServiceResolver,1937			Name: "main",1938			Redirect: &structs.ServiceResolverRedirect{1939				Service: "other",1940			},1941		},1942	)1943	return compileTestCase{1944		entries:        entries,1945		expectErr:      "uses inconsistent protocols",1946		expectGraphErr: true,1947	}1948}1949func testcase_RedirectToMissingSubset() compileTestCase {1950	entries := newEntries()1951	entries.AddResolvers(1952		&structs.ServiceResolverConfigEntry{1953			Kind:           structs.ServiceResolver,1954			Name:           "other",1955			ConnectTimeout: 33 * time.Second,1956		},1957		&structs.ServiceResolverConfigEntry{1958			Kind: structs.ServiceResolver,1959			Name: "main",1960			Redirect: &structs.ServiceResolverRedirect{1961				Service:       "other",1962				ServiceSubset: "v1",1963			},1964		},1965	)1966	return compileTestCase{1967		entries:        entries,1968		expectErr:      `does not have a subset named "v1"`,1969		expectGraphErr: true,1970	}1971}1972func testcase_ResolverProtocolOverride() compileTestCase {1973	entries := newEntries()1974	setServiceProtocol(entries, "main", "grpc")1975	expect := &structs.CompiledDiscoveryChain{1976		Protocol:  "http2",1977		StartNode: "resolver:main.default.dc1",1978		Nodes: map[string]*structs.DiscoveryGraphNode{1979			"resolver:main.default.dc1": {1980				Type: structs.DiscoveryGraphNodeTypeResolver,1981				Name: "main.default.dc1",1982				Resolver: &structs.DiscoveryResolver{1983					Default:        true,1984					ConnectTimeout: 5 * time.Second,1985					Target:         "main.default.dc1",1986				},1987			},1988		},1989		Targets: map[string]*structs.DiscoveryTarget{1990			// TODO-TARGET1991			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),1992		},1993	}1994	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true,1995		expectCustom: true,1996		setup: func(req *CompileRequest) {1997			req.OverrideProtocol = "http2"1998		},1999	}2000}2001func testcase_ResolverProtocolOverrideIgnored() compileTestCase {2002	// This shows that if you try to override the protocol to its current value2003	// the override is completely ignored.2004	entries := newEntries()2005	setServiceProtocol(entries, "main", "http2")2006	expect := &structs.CompiledDiscoveryChain{2007		Protocol:  "http2",2008		StartNode: "resolver:main.default.dc1",2009		Nodes: map[string]*structs.DiscoveryGraphNode{2010			"resolver:main.default.dc1": {2011				Type: structs.DiscoveryGraphNodeTypeResolver,2012				Name: "main.default.dc1",2013				Resolver: &structs.DiscoveryResolver{2014					Default:        true,2015					ConnectTimeout: 5 * time.Second,2016					Target:         "main.default.dc1",2017				},2018			},2019		},2020		Targets: map[string]*structs.DiscoveryTarget{2021			// TODO-TARGET2022			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),2023		},2024	}2025	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true,2026		setup: func(req *CompileRequest) {2027			req.OverrideProtocol = "http2"2028		},2029	}2030}2031func testcase_RouterIgnored_ResolverProtocolOverride() compileTestCase {2032	entries := newEntries()2033	setServiceProtocol(entries, "main", "grpc")2034	entries.AddRouters(2035		&structs.ServiceRouterConfigEntry{2036			Kind: "service-router",2037			Name: "main",2038		},2039	)2040	expect := &structs.CompiledDiscoveryChain{2041		Protocol:  "tcp",2042		StartNode: "resolver:main.default.dc1",2043		Nodes: map[string]*structs.DiscoveryGraphNode{2044			"resolver:main.default.dc1": {2045				Type: structs.DiscoveryGraphNodeTypeResolver,2046				Name: "main.default.dc1",2047				Resolver: &structs.DiscoveryResolver{2048					Default:        true,2049					ConnectTimeout: 5 * time.Second,2050					Target:         "main.default.dc1",2051				},2052			},2053		},2054		Targets: map[string]*structs.DiscoveryTarget{2055			// TODO-TARGET2056			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),2057		},2058	}2059	return compileTestCase{entries: entries, expect: expect, expectIsDefault: true,2060		expectCustom: true,2061		setup: func(req *CompileRequest) {2062			req.OverrideProtocol = "tcp"2063		},2064	}2065}2066func testcase_Resolver_CircularRedirect() compileTestCase {2067	entries := newEntries()2068	entries.AddResolvers(2069		&structs.ServiceResolverConfigEntry{2070			Kind: "service-resolver",2071			Name: "main",2072			Redirect: &structs.ServiceResolverRedirect{2073				Service: "other",2074			},2075		},2076		&structs.ServiceResolverConfigEntry{2077			Kind: "service-resolver",2078			Name: "other",2079			Redirect: &structs.ServiceResolverRedirect{2080				Service: "main",2081			},2082		},2083	)2084	return compileTestCase{entries: entries,2085		expectErr:      "detected circular resolver redirect",2086		expectGraphErr: true,2087	}2088}2089func testcase_CircularSplit() compileTestCase {2090	entries := newEntries()2091	setGlobalProxyProtocol(entries, "http")2092	entries.AddSplitters(2093		&structs.ServiceSplitterConfigEntry{2094			Kind: "service-splitter",2095			Name: "main",2096			Splits: []structs.ServiceSplit{2097				{Weight: 100, Service: "other"},2098			},2099		},2100		&structs.ServiceSplitterConfigEntry{2101			Kind: "service-splitter",2102			Name: "other",2103			Splits: []structs.ServiceSplit{2104				{Weight: 100, Service: "main"},2105			},2106		},2107	)2108	return compileTestCase{entries: entries,2109		expectErr:      "detected circular reference",2110		expectGraphErr: true,2111	}2112}2113func testcase_LBSplitterAndResolver() compileTestCase {2114	entries := newEntries()2115	setServiceProtocol(entries, "foo", "http")2116	setServiceProtocol(entries, "bar", "http")2117	setServiceProtocol(entries, "baz", "http")2118	entries.AddSplitters(2119		&structs.ServiceSplitterConfigEntry{2120			Kind: "service-splitter",2121			Name: "main",2122			Splits: []structs.ServiceSplit{2123				{Weight: 60, Service: "foo"},2124				{Weight: 20, Service: "bar"},2125				{Weight: 20, Service: "baz"},2126			},2127		},2128	)2129	entries.AddResolvers(2130		&structs.ServiceResolverConfigEntry{2131			Kind: "service-resolver",2132			Name: "foo",2133			LoadBalancer: &structs.LoadBalancer{2134				Policy: "least_request",2135				LeastRequestConfig: &structs.LeastRequestConfig{2136					ChoiceCount: 3,2137				},2138			},2139		},2140		&structs.ServiceResolverConfigEntry{2141			Kind: "service-resolver",2142			Name: "bar",2143			LoadBalancer: &structs.LoadBalancer{2144				Policy: "ring_hash",2145				RingHashConfig: &structs.RingHashConfig{2146					MaximumRingSize: 101,2147				},2148				HashPolicies: []structs.HashPolicy{2149					{2150						SourceIP: true,2151					},2152				},2153			},2154		},2155		&structs.ServiceResolverConfigEntry{2156			Kind: "service-resolver",2157			Name: "baz",2158			LoadBalancer: &structs.LoadBalancer{2159				Policy: "maglev",2160				HashPolicies: []structs.HashPolicy{2161					{2162						Field:      "cookie",2163						FieldValue: "chocolate-chip",2164						CookieConfig: &structs.CookieConfig{2165							TTL:  2 * time.Minute,2166							Path: "/bowl",2167						},2168						Terminal: true,2169					},2170				},2171			},2172		},2173	)2174	expect := &structs.CompiledDiscoveryChain{2175		Protocol:  "http",2176		StartNode: "splitter:main.default",2177		Nodes: map[string]*structs.DiscoveryGraphNode{2178			"splitter:main.default": {2179				Type: structs.DiscoveryGraphNodeTypeSplitter,2180				Name: "main.default",2181				Splits: []*structs.DiscoverySplit{2182					{2183						Weight:   60,2184						NextNode: "resolver:foo.default.dc1",2185					},2186					{2187						Weight:   20,2188						NextNode: "resolver:bar.default.dc1",2189					},2190					{2191						Weight:   20,2192						NextNode: "resolver:baz.default.dc1",2193					},2194				},2195				// The LB config from bar is attached because splitters only care about hash-based policies,2196				// and it's the config from bar not baz because we pick the first one we encounter in the Splits.2197				LoadBalancer: &structs.LoadBalancer{2198					Policy: "ring_hash",2199					RingHashConfig: &structs.RingHashConfig{2200						MaximumRingSize: 101,2201					},2202					HashPolicies: []structs.HashPolicy{2203						{2204							SourceIP: true,2205						},2206					},2207				},2208			},2209			// Each service's LB config is passed down from the service-resolver to the resolver node2210			"resolver:foo.default.dc1": {2211				Type: structs.DiscoveryGraphNodeTypeResolver,2212				Name: "foo.default.dc1",2213				Resolver: &structs.DiscoveryResolver{2214					Default:        false,2215					ConnectTimeout: 5 * time.Second,2216					Target:         "foo.default.dc1",2217				},2218				LoadBalancer: &structs.LoadBalancer{2219					Policy: "least_request",2220					LeastRequestConfig: &structs.LeastRequestConfig{2221						ChoiceCount: 3,2222					},2223				},2224			},2225			"resolver:bar.default.dc1": {2226				Type: structs.DiscoveryGraphNodeTypeResolver,2227				Name: "bar.default.dc1",2228				Resolver: &structs.DiscoveryResolver{2229					Default:        false,2230					ConnectTimeout: 5 * time.Second,2231					Target:         "bar.default.dc1",2232				},2233				LoadBalancer: &structs.LoadBalancer{2234					Policy: "ring_hash",2235					RingHashConfig: &structs.RingHashConfig{2236						MaximumRingSize: 101,2237					},2238					HashPolicies: []structs.HashPolicy{2239						{2240							SourceIP: true,2241						},2242					},2243				},2244			},2245			"resolver:baz.default.dc1": {2246				Type: structs.DiscoveryGraphNodeTypeResolver,2247				Name: "baz.default.dc1",2248				Resolver: &structs.DiscoveryResolver{2249					Default:        false,2250					ConnectTimeout: 5 * time.Second,2251					Target:         "baz.default.dc1",2252				},2253				LoadBalancer: &structs.LoadBalancer{2254					Policy: "maglev",2255					HashPolicies: []structs.HashPolicy{2256						{2257							Field:      "cookie",2258							FieldValue: "chocolate-chip",2259							CookieConfig: &structs.CookieConfig{2260								TTL:  2 * time.Minute,2261								Path: "/bowl",2262							},2263							Terminal: true,2264						},2265					},2266				},2267			},2268		},2269		Targets: map[string]*structs.DiscoveryTarget{2270			"foo.default.dc1": newTarget("foo", "", "default", "dc1", nil),2271			"bar.default.dc1": newTarget("bar", "", "default", "dc1", nil),2272			"baz.default.dc1": newTarget("baz", "", "default", "dc1", nil),2273		},2274	}2275	return compileTestCase{entries: entries, expect: expect}2276}2277// ensure chain with LB cfg in resolver isn't a default chain (!IsDefault)2278func testcase_LBResolver() compileTestCase {2279	entries := newEntries()2280	setServiceProtocol(entries, "main", "http")2281	entries.AddResolvers(2282		&structs.ServiceResolverConfigEntry{2283			Kind: "service-resolver",2284			Name: "main",2285			LoadBalancer: &structs.LoadBalancer{2286				Policy: "ring_hash",2287				RingHashConfig: &structs.RingHashConfig{2288					MaximumRingSize: 101,2289				},2290				HashPolicies: []structs.HashPolicy{2291					{2292						SourceIP: true,2293					},2294				},2295			},2296		},2297	)2298	expect := &structs.CompiledDiscoveryChain{2299		Protocol:  "http",2300		StartNode: "resolver:main.default.dc1",2301		Nodes: map[string]*structs.DiscoveryGraphNode{2302			"resolver:main.default.dc1": {2303				Type: structs.DiscoveryGraphNodeTypeResolver,2304				Name: "main.default.dc1",2305				Resolver: &structs.DiscoveryResolver{2306					Default:        false,2307					ConnectTimeout: 5 * time.Second,2308					Target:         "main.default.dc1",2309				},2310				LoadBalancer: &structs.LoadBalancer{2311					Policy: "ring_hash",2312					RingHashConfig: &structs.RingHashConfig{2313						MaximumRingSize: 101,2314					},2315					HashPolicies: []structs.HashPolicy{2316						{2317							SourceIP: true,2318						},2319					},2320				},2321			},2322		},2323		Targets: map[string]*structs.DiscoveryTarget{2324			"main.default.dc1": newTarget("main", "", "default", "dc1", nil),2325		},2326	}2327	return compileTestCase{entries: entries, expect: expect}2328}2329func newSimpleRoute(name string, muts ...func(*structs.ServiceRoute)) structs.ServiceRoute {2330	r := structs.ServiceRoute{2331		Match: &structs.ServiceRouteMatch{2332			HTTP: &structs.ServiceRouteHTTPMatch{PathPrefix: "/" + name},2333		},2334		Destination: &structs.ServiceRouteDestination{Service: name},2335	}2336	for _, mut := range muts {2337		mut(&r)2338	}2339	return r2340}2341func setGlobalProxyProtocol(entries *structs.DiscoveryChainConfigEntries, protocol string) {2342	entries.GlobalProxy = &structs.ProxyConfigEntry{2343		Kind: structs.ProxyDefaults,2344		Name: structs.ProxyConfigGlobal,2345		Config: map[string]interface{}{2346			"protocol": protocol,2347		},2348	}2349}2350func setServiceProtocol(entries *structs.DiscoveryChainConfigEntries, name, protocol string) {2351	entries.AddServices(&structs.ServiceConfigEntry{2352		Kind:     structs.ServiceDefaults,2353		Name:     name,2354		Protocol: protocol,2355	})2356}2357func newEntries() *structs.DiscoveryChainConfigEntries {2358	return &structs.DiscoveryChainConfigEntries{2359		Routers:   make(map[structs.ServiceID]*structs.ServiceRouterConfigEntry),2360		Splitters: make(map[structs.ServiceID]*structs.ServiceSplitterConfigEntry),2361		Resolvers: make(map[structs.ServiceID]*structs.ServiceResolverConfigEntry),2362	}2363}2364func newTarget(service, serviceSubset, namespace, datacenter string, modFn func(t *structs.DiscoveryTarget)) *structs.DiscoveryTarget {2365	t := structs.NewDiscoveryTarget(service, serviceSubset, namespace, datacenter)2366	t.SNI = connect.TargetSNI(t, "trustdomain.consul")2367	t.Name = t.SNI2368	if modFn != nil {2369		modFn(t)2370	}2371	return t2372}...