1771 lines
49 KiB
Go
1771 lines
49 KiB
Go
package discoverychain
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hashicorp/consul/agent/structs"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestCompile_NoEntries_NoInferDefaults(t *testing.T) {
|
|
entries := newEntries()
|
|
|
|
res, err := Compile(CompileRequest{
|
|
ServiceName: "main",
|
|
CurrentNamespace: "default",
|
|
CurrentDatacenter: "dc1",
|
|
InferDefaults: false,
|
|
Entries: entries,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Nil(t, res)
|
|
}
|
|
|
|
type compileTestCase struct {
|
|
entries *structs.DiscoveryChainConfigEntries
|
|
expect *structs.CompiledDiscoveryChain // the GroupResolverNodes map should have nil values
|
|
expectErr string
|
|
expectGraphErr bool
|
|
}
|
|
|
|
func TestCompile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// TODO(rb): test circular dependency?
|
|
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(),
|
|
"route bypasses splitter": testcase_RouteBypassesSplit(),
|
|
"noop split": testcase_NoopSplit_DefaultResolver(),
|
|
"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(),
|
|
"service failover": testcase_ServiceFailover(),
|
|
"service and subset failover": testcase_ServiceAndSubsetFailover(),
|
|
"datacenter failover": testcase_DatacenterFailover(),
|
|
"noop split to resolver with default subset": testcase_NoopSplit_WithDefaultSubset(),
|
|
"resolver with default subset": testcase_Resolve_WithDefaultSubset(),
|
|
"resolver with no entries and inferring defaults": testcase_DefaultResolver(),
|
|
|
|
// TODO(rb): handle this case better: "circular split": testcase_CircularSplit(),
|
|
"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(),
|
|
}
|
|
|
|
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())
|
|
}
|
|
|
|
res, err := Compile(CompileRequest{
|
|
ServiceName: "main",
|
|
CurrentNamespace: "default",
|
|
CurrentDatacenter: "dc1",
|
|
InferDefaults: true,
|
|
Entries: tc.entries,
|
|
})
|
|
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"
|
|
|
|
// These nodes are duplicated elsewhere in the results, so we only
|
|
// care that the keys are present. Walk the results and nil out the
|
|
// value payloads so that the require.Equal will still do the work
|
|
// for us.
|
|
if len(res.GroupResolverNodes) > 0 {
|
|
for target, _ := range res.GroupResolverNodes {
|
|
res.GroupResolverNodes[target] = nil
|
|
}
|
|
}
|
|
|
|
require.Equal(t, tc.expect, res)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func testcase_JustRouterWithDefaults() compileTestCase {
|
|
entries := newEntries()
|
|
setServiceProtocol(entries, "main", "http")
|
|
|
|
entries.AddRouters(
|
|
&structs.ServiceRouterConfigEntry{
|
|
Kind: "service-router",
|
|
Name: "main",
|
|
},
|
|
)
|
|
|
|
resolver := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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,
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 33 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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,
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 33 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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("main")
|
|
|
|
resolverOther := entries.GetResolver("other")
|
|
resolverMain := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: &router.Routes[0],
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "other",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverOther,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("other", "bypass", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"other": resolverOther,
|
|
"main": resolverMain,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
newTarget("other", "bypass", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc1"): nil,
|
|
newTarget("other", "bypass", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
|
|
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},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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,
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 33 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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",
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 60,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 40,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v1", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "v1", "default", "dc1"),
|
|
newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "v1", "default", "dc1"): nil,
|
|
newTarget("main", "v2", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
|
|
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"},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolverFoo := newDefaultServiceResolver("foo")
|
|
resolverBar := newDefaultServiceResolver("bar")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 60,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "foo",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverFoo,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("foo", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 40,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "bar",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverBar,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("bar", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"foo": resolverFoo,
|
|
"bar": resolverBar,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("bar", "", "default", "dc1"),
|
|
newTarget("foo", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("bar", "", "default", "dc1"): nil,
|
|
newTarget("foo", "", "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",
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolverNext := entries.GetResolver("next")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "next",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverNext,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("next", "bypassed", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"next": resolverNext,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("next", "bypassed", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("next", "bypassed", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
|
|
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",
|
|
},
|
|
},
|
|
)
|
|
|
|
resolverOther := newDefaultServiceResolver("other")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "other",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverOther,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("other", "", "default", "dc1"),
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"other": resolverOther,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("other", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
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",
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("other")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "other",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("other", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"other": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("other", "v2", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("other", "v2", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
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",
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc9"),
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc9"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc9"): nil,
|
|
},
|
|
}
|
|
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"},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolverMain := entries.GetResolver("main")
|
|
resolverBackup := newDefaultServiceResolver("backup")
|
|
|
|
wildFail := resolverMain.Failover["*"]
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
Failover: &structs.DiscoveryFailover{
|
|
Definition: &wildFail,
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("backup", "", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolverMain,
|
|
"backup": resolverBackup,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("backup", "", "default", "dc1"),
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "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"},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
wildFail := resolver.Failover["*"]
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
Failover: &structs.DiscoveryFailover{
|
|
Definition: &wildFail,
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "backup", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
newTarget("main", "backup", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
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"}},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
wildFail := resolver.Failover["*"]
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
Failover: &structs.DiscoveryFailover{
|
|
Definition: &wildFail,
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc2"),
|
|
newTarget("main", "", "default", "dc4"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
newTarget("main", "", "default", "dc2"),
|
|
newTarget("main", "", "default", "dc4"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
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"},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 100,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "v2", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
return compileTestCase{entries: entries, expect: expect}
|
|
}
|
|
|
|
func testcase_DefaultResolver() compileTestCase {
|
|
entries := newEntries()
|
|
|
|
resolver := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
Default: true,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc1"),
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
return compileTestCase{entries: entries, expect: expect}
|
|
}
|
|
|
|
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"},
|
|
},
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "tcp",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "v2", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
return compileTestCase{entries: entries, expect: expect}
|
|
}
|
|
|
|
func testcase_CircularSplit() compileTestCase {
|
|
entries := newEntries()
|
|
setServiceProtocol(entries, "main", "http")
|
|
setServiceProtocol(entries, "other", "http")
|
|
|
|
entries.AddSplitters(
|
|
&structs.ServiceSplitterConfigEntry{
|
|
Kind: "service-splitter",
|
|
Name: "main",
|
|
Splits: []structs.ServiceSplit{
|
|
{Weight: 60, Service: "other"},
|
|
{Weight: 40, Service: "main"}, // goes straight to resolver
|
|
},
|
|
},
|
|
&structs.ServiceSplitterConfigEntry{
|
|
Kind: "service-splitter",
|
|
Name: "other",
|
|
Splits: []structs.ServiceSplit{
|
|
{Weight: 60, Service: "main"},
|
|
{Weight: 40, Service: "other"}, // goes straight to resolver
|
|
},
|
|
},
|
|
)
|
|
|
|
resolveMain := newDefaultServiceResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 60,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolveMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolveMain,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "v2", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
return compileTestCase{entries: entries, expect: expect}
|
|
}
|
|
|
|
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,
|
|
},
|
|
)
|
|
|
|
resolver := entries.GetResolver("main")
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "main",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 60,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 33 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc2"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 40,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolver,
|
|
ConnectTimeout: 33 * time.Second,
|
|
Target: newTarget("main", "", "default", "dc3"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolver,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "", "default", "dc2"),
|
|
newTarget("main", "", "default", "dc3"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "", "default", "dc2"): nil,
|
|
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"},
|
|
},
|
|
},
|
|
&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("main")
|
|
resolverMain = entries.GetResolver("main")
|
|
resolverRedirected = entries.GetResolver("redirected")
|
|
)
|
|
|
|
expect := &structs.CompiledDiscoveryChain{
|
|
Protocol: "http",
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeRouter,
|
|
Name: "main",
|
|
Routes: []*structs.DiscoveryRoute{
|
|
{
|
|
Definition: &router.Routes[0],
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "redirected",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverRedirected,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("redirected", "prod", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Definition: &router.Routes[1],
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeSplitter,
|
|
Name: "svc-split",
|
|
Splits: []*structs.DiscoverySplit{
|
|
{
|
|
Weight: 60,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "redirected",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverRedirected,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("redirected", "prod", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 30,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v1", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 8,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v2", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Weight: 2,
|
|
Node: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "v3", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Definition: newDefaultServiceRoute("main"),
|
|
DestinationNode: &structs.DiscoveryGraphNode{
|
|
Type: structs.DiscoveryGraphNodeTypeGroupResolver,
|
|
Name: "main",
|
|
GroupResolver: &structs.DiscoveryGroupResolver{
|
|
Definition: resolverMain,
|
|
ConnectTimeout: 5 * time.Second,
|
|
Target: newTarget("main", "default-subset", "default", "dc1"),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Resolvers: map[string]*structs.ServiceResolverConfigEntry{
|
|
"main": resolverMain,
|
|
"redirected": resolverRedirected,
|
|
},
|
|
Targets: []structs.DiscoveryTarget{
|
|
newTarget("main", "default-subset", "default", "dc1"),
|
|
newTarget("main", "v1", "default", "dc1"),
|
|
newTarget("main", "v2", "default", "dc1"),
|
|
newTarget("main", "v3", "default", "dc1"),
|
|
newTarget("redirected", "prod", "default", "dc1"),
|
|
},
|
|
GroupResolverNodes: map[structs.DiscoveryTarget]*structs.DiscoveryGraphNode{
|
|
newTarget("main", "default-subset", "default", "dc1"): nil,
|
|
newTarget("main", "v1", "default", "dc1"): nil,
|
|
newTarget("main", "v2", "default", "dc1"): nil,
|
|
newTarget("main", "v3", "default", "dc1"): nil,
|
|
newTarget("redirected", "prod", "default", "dc1"): nil,
|
|
},
|
|
}
|
|
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{
|
|
"*": 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 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 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[string]*structs.ServiceRouterConfigEntry),
|
|
Splitters: make(map[string]*structs.ServiceSplitterConfigEntry),
|
|
Resolvers: make(map[string]*structs.ServiceResolverConfigEntry),
|
|
}
|
|
}
|
|
|
|
func newTarget(service, serviceSubset, namespace, datacenter string) structs.DiscoveryTarget {
|
|
return structs.DiscoveryTarget{
|
|
Service: service,
|
|
ServiceSubset: serviceSubset,
|
|
Namespace: namespace,
|
|
Datacenter: datacenter,
|
|
}
|
|
}
|