Adding Discovery Chain GET and POST and tests for it

Consul.Test/ConfigurationTest.cs

@@ -22,6 +22,7 @@
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
+using NuGet.Versioning;
 using Xunit;
 
 namespace Consul.Test
@@ -112,5 +113,74 @@ public async Task Configuration_DeleteConfig()
             Assert.Equal(HttpStatusCode.NotFound, getDeletedConfigResult.StatusCode);
             Assert.Null(getDeletedConfigResult.Response);
         }
+
+        [Fact]
+        public async Task Configuration_ServiceResolverEntry()
+        {
+            var cutOffVersion = SemanticVersion.Parse("1.8.0");
+            var entry = new ServiceResolverEntry
+            {
+                Name = "test-failover",
+                DefaultSubset = "v1",
+                Subsets = new Dictionary<string, ServiceResolverSubset>()
+                {
+                    { "v1", new ServiceResolverSubset { Filter = "Service.Meta.version == v1"} },
+                    { "v2", new ServiceResolverSubset { Filter = "Service.Meta.version == v2"} }
+                },
+                Failover = new Dictionary<string, ServiceResolverFailover>()
+                {
+                    { "*", new ServiceResolverFailover { Datacenters = new List<string> { "dc2" } } },
+                    { "v1", new ServiceResolverFailover { Service = "alternate" } }
+                },
+                ConnectTimeout = new TimeSpan(0, 0, 5),
+                Meta = new Dictionary<string, string>()
+                {
+                    { "foo", "bar" },
+                    { "gir", "zim" }
+                }
+            };
+            if (AgentVersion < cutOffVersion) entry.Meta = null;
+            entry.Meta = null;
+            await _client.Configuration.ApplyConfig(entry);
+
+            var result = await _client.Configuration.GetConfig<ServiceResolverEntry>("service-resolver", entry.Name);
+            var returned = result.Response;
+
+            Assert.Equal(entry.Name, returned.Name);
+            Assert.Equal(entry.DefaultSubset, returned.DefaultSubset);
+            Assert.Equal(entry.Subsets.Count, returned.Subsets.Count);
+            Assert.Equal(entry.Subsets["v1"].Filter, returned.Subsets["v1"].Filter);
+            Assert.Equal(entry.Subsets["v2"].Filter, returned.Subsets["v2"].Filter);
+            Assert.Equal(entry.Failover.Count, returned.Failover.Count);
+            Assert.Equal(entry.Failover["*"].Datacenters[0], returned.Failover["*"].Datacenters[0]);
+            Assert.Equal(entry.Failover["v1"].Service, returned.Failover["v1"].Service);
+            Assert.Equal(entry.ConnectTimeout.ToString(), returned.ConnectTimeout.ToString());
+            if (entry.Meta != null)
+            {
+                Assert.Equal(entry.Meta.Count, returned.Meta.Count);
+                Assert.Equal(entry.Meta["foo"], returned.Meta["foo"]);
+                Assert.Equal(entry.Meta["gir"], returned.Meta["gir"]);
+            }
+
+            entry = new ServiceResolverEntry
+            {
+                Name = "test-redirect",
+                Redirect = new ServiceResolverRedirect
+                {
+                    Service = "test-failover",
+                    ServiceSubset = "v2",
+                    Datacenter = "d"
+                }
+            };
+            await _client.Configuration.ApplyConfig(entry);
+
+            result = await _client.Configuration.GetConfig<ServiceResolverEntry>("service-resolver", entry.Name);
+            returned = result.Response;
+
+            Assert.Equal(entry.Name, returned.Name);
+            Assert.Equal(entry.Redirect.Service, returned.Redirect.Service);
+            Assert.Equal(entry.Redirect.ServiceSubset, returned.Redirect.ServiceSubset);
+            Assert.Equal(entry.Redirect.Datacenter, returned.Redirect.Datacenter);
+        }
     }
 }

Consul.Test/DiscoveryChainTest.cs

@@ -0,0 +1,308 @@
+// -----------------------------------------------------------------------
+//  <copyright file="DiscoveryChainTest.cs" company="PlayFab Inc">
+//    Copyright 2015 PlayFab Inc.
+//    Copyright 2020 G-Research Limited
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//  </copyright>
+// -----------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NuGet.Versioning;
+using Xunit;
+
+namespace Consul.Test
+{
+    public class DiscoveryChainTest : BaseFixture
+    {
+        public const string TestClusterID = "11111111-2222-3333-4444-555555555555";
+
+        [Fact]
+        public async Task DiscoveryChain_Get()
+        {
+            var cutOffVersion = SemanticVersion.Parse("1.11.0");
+            string defaultPart = "default";
+            if (AgentVersion >= cutOffVersion) defaultPart = "default.default";
+
+            var check = new CompiledDiscoveryChain
+            {
+                ServiceName = "web",
+                Namespace = "default",
+                Datacenter = "dc1",
+                Protocol = "tcp",
+                StartNode = "resolver:web." + defaultPart + ".dc1",
+                Nodes = new Dictionary<string, DiscoveryGraphNode>()
+                {
+                    { "resolver:web." + defaultPart + ".dc1",
+                        new DiscoveryGraphNode {
+                            Type = DiscoveryChain.DiscoveryGraphNodeTypeResolver,
+                            Name = "web." + defaultPart + ".dc1",
+                            Resolver = new DiscoveryResolver
+                            {
+                                Default = true,
+                                ConnectTimeout = new TimeSpan(0, 0, 5),
+                                Target = "web." + defaultPart + ".dc1"
+                            }
+                        }
+                    }
+                },
+                Targets = new Dictionary<string, DiscoveryTarget>()
+                {
+                    { "web." + defaultPart + ".dc1",
+                        new DiscoveryTarget
+                        {
+                            ID = "web." + defaultPart + ".dc1",
+                            Service = "web",
+                            Namespace = "default",
+                            Datacenter = "dc1",
+                            SNI = "web.default.dc1.internal." + TestClusterID + ".consul",
+                            Name = "web.default.dc1.internal." + TestClusterID + ".consul"
+                        }
+                    }
+                }
+            };
+
+            var response = await _client.DiscoveryChain.Get("web");
+            Assert.NotNull(response.Response);
+            var chain = response.Response.Chain;
+            Assert.Equal(check.ServiceName, chain.ServiceName);
+            Assert.Equal(check.Namespace, chain.Namespace);
+            Assert.Equal(check.Datacenter, chain.Datacenter);
+            Assert.Equal(check.Protocol, chain.Protocol);
+            Assert.Equal(check.StartNode, chain.StartNode);
+            var nodeCheck = check.Nodes["resolver:web." + defaultPart + ".dc1"];
+            var nodeChain = chain.Nodes["resolver:web." + defaultPart + ".dc1"];
+            Assert.Equal(nodeCheck.Type, nodeChain.Type);
+            Assert.Equal(nodeCheck.Name, nodeChain.Name);
+            Assert.Equal(nodeCheck.Resolver.Default, nodeChain.Resolver.Default);
+            Assert.Equal(nodeCheck.Resolver.Target, nodeChain.Resolver.Target);
+            Assert.Equal(nodeCheck.Resolver.ConnectTimeout.ToString(), nodeChain.Resolver.ConnectTimeout.ToString());
+            var targetCheck = check.Targets["web." + defaultPart + ".dc1"];
+            var targetChain = chain.Targets["web." + defaultPart + ".dc1"];
+            Assert.Equal(targetCheck.ID, targetChain.ID);
+            Assert.Equal(targetCheck.Service, targetChain.Service);
+            Assert.Equal(targetCheck.Namespace, targetChain.Namespace);
+            Assert.Equal(targetCheck.Datacenter, targetChain.Datacenter);
+            Assert.Equal(targetCheck.SNI, targetChain.SNI);
+            Assert.Equal(targetCheck.Name, targetChain.Name);
+
+            check = new CompiledDiscoveryChain
+            {
+                ServiceName = "web",
+                Namespace = "default",
+                Datacenter = "dc2",
+                Protocol = "tcp",
+                StartNode = "resolver:web." + defaultPart + ".dc2",
+                Nodes = new Dictionary<string, DiscoveryGraphNode>()
+                {
+                    { "resolver:web." + defaultPart + ".dc2",
+                        new DiscoveryGraphNode {
+                            Type = DiscoveryChain.DiscoveryGraphNodeTypeResolver,
+                            Name = "web." + defaultPart + ".dc2",
+                            Resolver = new DiscoveryResolver
+                            {
+                                Default = true,
+                                ConnectTimeout = new TimeSpan(0, 0, 5),
+                                Target = "web." + defaultPart + ".dc2"
+                            }
+                        }
+                    }
+                },
+                Targets = new Dictionary<string, DiscoveryTarget>()
+                {
+                    { "web." + defaultPart + ".dc2",
+                        new DiscoveryTarget
+                        {
+                            ID = "web." + defaultPart + ".dc2",
+                            Service = "web",
+                            Namespace = "default",
+                            Datacenter = "dc2",
+                            SNI = "web.default.dc2.internal." + TestClusterID + ".consul",
+                            Name = "web.default.dc2.internal." + TestClusterID + ".consul"
+                        }
+                    }
+                }
+            };
+            var options = new DiscoveryChainOptions { EvaluateInDatacenter = "dc2" };
+            var responsePost = await _client.DiscoveryChain.Get("web", options);
+            Assert.NotNull(response.Response);
+
+            chain = responsePost.Response.Chain;
+            Assert.Equal(check.ServiceName, chain.ServiceName);
+            Assert.Equal(check.Namespace, chain.Namespace);
+            Assert.Equal(check.Datacenter, chain.Datacenter);
+            Assert.Equal(check.Protocol, chain.Protocol);
+            Assert.Equal(check.StartNode, chain.StartNode);
+            nodeCheck = check.Nodes["resolver:web." + defaultPart + ".dc2"];
+            nodeChain = chain.Nodes["resolver:web." + defaultPart + ".dc2"];
+            Assert.Equal(nodeCheck.Type, nodeChain.Type);
+            Assert.Equal(nodeCheck.Name, nodeChain.Name);
+            Assert.Equal(nodeCheck.Resolver.Default, nodeChain.Resolver.Default);
+            Assert.Equal(nodeCheck.Resolver.Target, nodeChain.Resolver.Target);
+            Assert.Equal(nodeCheck.Resolver.ConnectTimeout.ToString(), nodeChain.Resolver.ConnectTimeout.ToString());
+            targetCheck = check.Targets["web." + defaultPart + ".dc2"];
+            targetChain = chain.Targets["web." + defaultPart + ".dc2"];
+            Assert.Equal(targetCheck.ID, targetChain.ID);
+            Assert.Equal(targetCheck.Service, targetChain.Service);
+            Assert.Equal(targetCheck.Namespace, targetChain.Namespace);
+            Assert.Equal(targetCheck.Datacenter, targetChain.Datacenter);
+            Assert.Equal(targetCheck.SNI, targetChain.SNI);
+            Assert.Equal(targetCheck.Name, targetChain.Name);
+
+            var config = new ServiceResolverEntry
+            {
+                Name = "web",
+                ConnectTimeout = new TimeSpan(0, 0, 33)
+            };
+            await _client.Configuration.ApplyConfig(config);
+
+            check = new CompiledDiscoveryChain
+            {
+                ServiceName = "web",
+                Namespace = "default",
+                Datacenter = "dc1",
+                Protocol = "tcp",
+                StartNode = "resolver:web." + defaultPart + ".dc1",
+                Nodes = new Dictionary<string, DiscoveryGraphNode>()
+                {
+                    { "resolver:web." + defaultPart + ".dc1",
+                        new DiscoveryGraphNode {
+                            Type = DiscoveryChain.DiscoveryGraphNodeTypeResolver,
+                            Name = "web." + defaultPart + ".dc1",
+                            Resolver = new DiscoveryResolver
+                            {
+                                Default = false,
+                                ConnectTimeout = new TimeSpan(0, 0, 33),
+                                Target = "web." + defaultPart + ".dc1"
+                            }
+                        }
+                    }
+                },
+                Targets = new Dictionary<string, DiscoveryTarget>()
+                {
+                    { "web." + defaultPart + ".dc1",
+                        new DiscoveryTarget
+                        {
+                            ID = "web." + defaultPart + ".dc1",
+                            Service = "web",
+                            Namespace = "default",
+                            Datacenter = "dc1",
+                            SNI = "web.default.dc1.internal." + TestClusterID + ".consul",
+                            Name = "web.default.dc1.internal." + TestClusterID + ".consul"
+                        }
+                    }
+                }
+            };
+            response = await _client.DiscoveryChain.Get("web");
+            Assert.NotNull(response.Response);
+
+            chain = response.Response.Chain;
+            Assert.Equal(check.ServiceName, chain.ServiceName);
+            Assert.Equal(check.Namespace, chain.Namespace);
+            Assert.Equal(check.Datacenter, chain.Datacenter);
+            Assert.Equal(check.Protocol, chain.Protocol);
+            Assert.Equal(check.StartNode, chain.StartNode);
+            nodeCheck = check.Nodes["resolver:web." + defaultPart + ".dc1"];
+            nodeChain = chain.Nodes["resolver:web." + defaultPart + ".dc1"];
+            Assert.Equal(nodeCheck.Type, nodeChain.Type);
+            Assert.Equal(nodeCheck.Name, nodeChain.Name);
+            Assert.Equal(nodeCheck.Resolver.Default, nodeChain.Resolver.Default);
+            Assert.Equal(nodeCheck.Resolver.Target, nodeChain.Resolver.Target);
+            Assert.Equal(nodeCheck.Resolver.ConnectTimeout.ToString(), nodeChain.Resolver.ConnectTimeout.ToString());
+            targetCheck = check.Targets["web." + defaultPart + ".dc1"];
+            targetChain = chain.Targets["web." + defaultPart + ".dc1"];
+            Assert.Equal(targetCheck.ID, targetChain.ID);
+            Assert.Equal(targetCheck.Service, targetChain.Service);
+            Assert.Equal(targetCheck.Namespace, targetChain.Namespace);
+            Assert.Equal(targetCheck.Datacenter, targetChain.Datacenter);
+            Assert.Equal(targetCheck.SNI, targetChain.SNI);
+            Assert.Equal(targetCheck.Name, targetChain.Name);
+
+            check = new CompiledDiscoveryChain
+            {
+                ServiceName = "web",
+                Namespace = "default",
+                Datacenter = "dc2",
+                Protocol = "grpc",
+                CustomizationHash = "98809527",
+                StartNode = "resolver:web." + defaultPart + ".dc2",
+                Nodes = new Dictionary<string, DiscoveryGraphNode>()
+                {
+                    { "resolver:web." + defaultPart + ".dc2",
+                        new DiscoveryGraphNode {
+                            Type = DiscoveryChain.DiscoveryGraphNodeTypeResolver,
+                            Name = "web." + defaultPart + ".dc2",
+                            Resolver = new DiscoveryResolver
+                            {
+                                Default = false,
+                                ConnectTimeout = new TimeSpan(0, 0, 22),
+                                Target = "web." + defaultPart + ".dc2"
+                            }
+                        }
+                    }
+                },
+                Targets = new Dictionary<string, DiscoveryTarget>()
+                {
+                    { "web." + defaultPart + ".dc2",
+                        new DiscoveryTarget
+                        {
+                            ID = "web." + defaultPart + ".dc2",
+                            Service = "web",
+                            Namespace = "default",
+                            Datacenter = "dc2",
+                            MeshGateway = new MeshGatewayConfig { Mode = "local" },
+                            SNI = "web.default.dc2.internal." + TestClusterID + ".consul",
+                            Name = "web.default.dc2.internal." + TestClusterID + ".consul"
+                        }
+                    }
+                }
+            };
+            options = new DiscoveryChainOptions
+            {
+                EvaluateInDatacenter = "dc2",
+                OverrideMeshGateway = new MeshGatewayConfig { Mode = "local" },
+                OverrideProtocol = "grpc",
+                OverrideConnectTimeout = new TimeSpan(0, 0, 22)
+            };
+            responsePost = await _client.DiscoveryChain.Get("web", options);
+            Assert.NotNull(response.Response);
+
+            chain = responsePost.Response.Chain;
+            Assert.Equal(check.ServiceName, chain.ServiceName);
+            Assert.Equal(check.Namespace, chain.Namespace);
+            Assert.Equal(check.Datacenter, chain.Datacenter);
+            Assert.Equal(check.Protocol, chain.Protocol);
+            Assert.Equal(check.StartNode, chain.StartNode);
+            nodeCheck = check.Nodes["resolver:web." + defaultPart + ".dc2"];
+            nodeChain = chain.Nodes["resolver:web." + defaultPart + ".dc2"];
+            Assert.Equal(nodeCheck.Type, nodeChain.Type);
+            Assert.Equal(nodeCheck.Name, nodeChain.Name);
+            Assert.Equal(nodeCheck.Resolver.Default, nodeChain.Resolver.Default);
+            Assert.Equal(nodeCheck.Resolver.Target, nodeChain.Resolver.Target);
+            Assert.Equal(nodeCheck.Resolver.ConnectTimeout.ToString(), nodeChain.Resolver.ConnectTimeout.ToString());
+            targetCheck = check.Targets["web." + defaultPart + ".dc2"];
+            targetChain = chain.Targets["web." + defaultPart + ".dc2"];
+            Assert.Equal(targetCheck.ID, targetChain.ID);
+            Assert.Equal(targetCheck.Service, targetChain.Service);
+            Assert.Equal(targetCheck.Namespace, targetChain.Namespace);
+            Assert.Equal(targetCheck.Datacenter, targetChain.Datacenter);
+            Assert.Equal(targetCheck.SNI, targetChain.SNI);
+            Assert.Equal(targetCheck.Name, targetChain.Name);
+        }
+    }
+}

Consul/Client.cs

@@ -458,6 +458,7 @@ private void InitializeEndpoints()
             _catalog = new Lazy<Catalog>(() => new Catalog(this));
             _coordinate = new Lazy<Coordinate>(() => new Coordinate(this));
             _configuration = new Lazy<Configuration>(() => new Configuration(this));
+            _discoveryChain = new Lazy<DiscoveryChain>(() => new DiscoveryChain(this));
             _event = new Lazy<Event>(() => new Event(this));
             _health = new Lazy<Health>(() => new Health(this));
             _kv = new Lazy<KV>(() => new KV(this));