Added GET GatewayService endpoint, tests for it

Consul.Test/CatalogTest.cs

@@ -317,5 +317,102 @@ public async Task Catalog_ServicesForNodes()
             Assert.Contains(services.Response.Services, n => n.ID == svcID);
             Assert.DoesNotContain(services.Response.Services, n => n.ID == svcID2);
         }
+
+        [Fact]
+        public async Task Catalog_GatewayServices()
+        {
+            using (IConsulClient client = new ConsulClient(c =>
+            {
+                c.Token = TestHelper.MasterToken;
+                c.Address = TestHelper.HttpUri;
+            }))
+            {
+                var terminatingGatewayName = "terminating-gateway";
+                var ingressGatewayName = "ingress-gateway";
+
+                var terminatingGatewayEntry = new CatalogRegistration
+                {
+                    Datacenter = "dc1",
+                    Node = "bar",
+                    Address = "192.168.10.11",
+                    Service = new AgentService
+                    {
+                        ID = "redis",
+                        Service = "redis",
+                        Port = 6379
+                    }
+                };
+                await client.Catalog.Register(terminatingGatewayEntry);
+
+                var terminatingGatewayConfigEntry = new TerminatingGatewayConfigEntry
+                {
+                    Kind = ServiceKind.TerminatingGateway.ToString(),
+                    Name = terminatingGatewayName,
+                    Services = new List<LinkedServiceGateway>
+                    {
+                        new LinkedServiceGateway
+                        {
+                            Name = "api",
+                            CAFile = "api/ca.crt",
+                            CertFile = "api/client.crt",
+                            KeyFile = "api/client.key",
+                            SNI = "my-domain"
+                        },
+                        new LinkedServiceGateway
+                        {
+                            Name = "*",
+                            CAFile = "ca.crt",
+                            CertFile = "client.crt",
+                            KeyFile = "client.key",
+                            SNI = "my-alt-domain"
+                        }
+                    }
+                };
+                await client.Configuration.ApplyConfig(terminatingGatewayConfigEntry);
+
+                var ingressGatewayConfigEntry = new IngressGatewayConfigEntry
+                {
+                    Kind = ServiceKind.IngressGateway.ToString(),
+                    Name = ingressGatewayName,
+                    Listeners = new List<IngressListener>
+                    {
+                        new IngressListener
+                        {
+                            Port = 8888,
+                            Services = new List<IngressService>
+                            {
+                                new IngressService
+                                {
+                                    Name = "api"
+                                }
+                            }
+                        },
+                        new IngressListener
+                        {
+                            Port = 9999,
+                            Services = new List<IngressService>
+                            {
+                                new IngressService
+                                {
+                                    Name = "redis"
+                                }
+                            }
+                        }
+                    }
+                };
+
+                await client.Configuration.ApplyConfig(ingressGatewayConfigEntry);
+
+                var gatewayServices = await client.Catalog.GatewayService(terminatingGatewayName);
+
+                Assert.NotEmpty(gatewayServices.Response);
+                Assert.Equal(ServiceKind.TerminatingGateway, gatewayServices.Response[0].GatewayKind);
+
+                gatewayServices = await client.Catalog.GatewayService(ingressGatewayName);
+
+                Assert.NotEmpty(gatewayServices.Response);
+                Assert.Equal(ServiceKind.IngressGateway, gatewayServices.Response[0].GatewayKind);
+            }
+        }
     }
 }

Consul/Catalog.cs

@@ -118,6 +118,62 @@ public class ServiceAddress
         public int Port { get; set; }
     }
 
+    public class CompoundServiceName
+    {
+        public string Namespace { get; set; }
+        public string Partition { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class GatewayService
+    {
+        public CompoundServiceName Gateway { get; set; }
+        public CompoundServiceName Service { get; set; }
+        public ServiceKind GatewayKind { get; set; }
+        public int Port { get; set; }
+        public string Protocol { get; set; }
+        public List<string> Hosts { get; set; }
+        public string CAFile { get; set; }
+        public string CertFile { get; set; }
+        public string KeyFile { get; set; }
+        public string SNI { get; set; }
+        public bool FromWildcard { get; set; }
+    }
+
+    public class TerminatingGatewayConfigEntry : IConfigurationEntry
+    {
+        public string Kind { get; set; }
+        public string Name { get; set; }
+        public List<LinkedServiceGateway> Services { get; set; }
+    }
+
+    public class LinkedServiceGateway
+    {
+        public string Name { get; set; }
+        public string CAFile { get; set; }
+        public string CertFile { get; set; }
+        public string KeyFile { get; set; }
+        public string SNI { get; set; }
+    }
+
+    public class IngressGatewayConfigEntry : IConfigurationEntry
+    {
+        public string Kind { get; set; }
+        public string Name { get; set; }
+        public List<IngressListener> Listeners { get; set; }
+    }
+
+    public class IngressListener
+    {
+        public int Port { get; set; }
+        public List<IngressService> Services { get; set; }
+    }
+
+    public class IngressService
+    {
+        public string Name { get; set; }
+    }
+
     /// <summary>
     /// Catalog can be used to query the Catalog endpoints
     /// </summary>
@@ -352,6 +408,30 @@ public Task<QueryResult<NodeService>> ServicesForNode(string node, QueryOptions
         {
             return _client.Get<NodeService>(string.Format("/v1/catalog/node-services/{0}", node), q).Execute(ct);
         }
+
+
+        /// <summary>
+        /// GatewayServices is used to query for the services associated with an ingress gateway or terminating gateway
+        /// </summary>
+        /// <param name="gateway">Gateway name</param>
+        /// <param name="q">Query Parameters</param>
+        /// <param name="ct">Cancellation Token</param>
+        /// <returns>Gateway services</returns>
+        public Task<QueryResult<GatewayService[]>> GatewayService(string gateway, QueryOptions q, CancellationToken ct = default)
+        {
+            return _client.Get<GatewayService[]>($"/v1/catalog/gateway-services/{gateway}", q).Execute(ct);
+        }
+
+        /// <summary>
+        /// GatewayServices is used to query for the services associated with an ingress gateway or terminating gateway
+        /// </summary>
+        /// <param name="gateway">Gateway name</param>
+        /// <param name="ct">Cancellation Token</param>
+        /// <returns>Gateway services</returns>
+        public Task<QueryResult<GatewayService[]>> GatewayService(string gateway, CancellationToken ct = default)
+        {
+            return GatewayService(gateway, QueryOptions.Default, ct);
+        }
     }
 
     public partial class ConsulClient : IConsulClient

Consul/Interfaces/ICatalogEndpoint.cs

@@ -50,5 +50,7 @@ public interface ICatalogEndpoint
         Task<QueryResult<CatalogService[]>> NodesForMeshCapableService(string service, CancellationToken ct = default);
         Task<QueryResult<NodeService>> ServicesForNode(string node, QueryOptions q, CancellationToken ct = default);
         Task<QueryResult<NodeService>> ServicesForNode(string node, CancellationToken ct = default);
+        Task<QueryResult<GatewayService[]>> GatewayService(string gateway, QueryOptions q, CancellationToken ct = default);
+        Task<QueryResult<GatewayService[]>> GatewayService(string gateway, CancellationToken ct = default);
     }
 }