Feature/poll consul (#392)

* WIP - implement a consul service discovery poller, lots of shared code with existing, refactor next and a todo in the docs to finish

* #374 implement polling for consul as option

* #374 updated docs to remove todo

* #374 fixed failing unit test

* #374 fixed failing unit test

* #374 fixed failing acceptance test

test/Ocelot.AcceptanceTests/ServiceDiscoveryTests.cs

@@ -458,6 +458,64 @@ namespace Ocelot.AcceptanceTests
                 .BDDfy();
         }
 
+        [Fact]
+        public void should_handle_request_to_poll_consul_for_downstream_service_and_make_request()
+        {
+            const int consulPort = 8518;
+            const string serviceName = "web";
+            const int downstreamServicePort = 8082;
+            var downstreamServiceOneUrl = $"http://localhost:{downstreamServicePort}";
+            var fakeConsulServiceDiscoveryUrl = $"http://localhost:{consulPort}";
+            var serviceEntryOne = new ServiceEntry()
+            {
+                Service = new AgentService()
+                {
+                    Service = serviceName,
+                    Address = "localhost",
+                    Port = downstreamServicePort,
+                    ID = $"web_90_0_2_224_{downstreamServicePort}",
+                    Tags = new[] {"version-v1"}
+                },
+            };
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/api/home",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/home",
+                            UpstreamHttpMethod = new List<string> { "Get", "Options" },
+                            ServiceName = serviceName,
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
+                            UseServiceDiscovery = true,
+                        }
+                    },
+                    GlobalConfiguration = new FileGlobalConfiguration()
+                    {
+                        ServiceDiscoveryProvider = new FileServiceDiscoveryProvider()
+                        {
+                            Host = "localhost",
+                            Port = consulPort,
+                            Type = "PollConsul",
+                            PollingInterval = 0
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn(downstreamServiceOneUrl, "/api/home", 200, "Hello from Laura"))                
+            .And(x => x.GivenThereIsAFakeConsulServiceDiscoveryProvider(fakeConsulServiceDiscoveryUrl, serviceName))
+            .And(x => x.GivenTheServicesAreRegisteredWithConsul(serviceEntryOne))
+            .And(x => _steps.GivenThereIsAConfiguration(configuration))
+            .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayWaitingForTheResponseToBeOk("/home"))
+            .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+            .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+            .BDDfy();
+        }
+
         private void WhenIAddAServiceBackIn(ServiceEntry serviceEntryTwo)
         {
             _consulServices.Add(serviceEntryTwo);

test/Ocelot.AcceptanceTests/Steps.cs

@@ -27,6 +27,7 @@ using System.Text;
 using static Ocelot.AcceptanceTests.HttpDelegatingHandlersTests;
 using Ocelot.Requester;
 using Ocelot.Middleware.Multiplexer;
+using static Ocelot.Infrastructure.Wait;
 
 namespace Ocelot.AcceptanceTests
 {
@@ -675,6 +676,24 @@ namespace Ocelot.AcceptanceTests
             _response = _ocelotClient.GetAsync(url).Result;
         }
 
+        public void WhenIGetUrlOnTheApiGatewayWaitingForTheResponseToBeOk(string url)
+        {
+            var result = WaitFor(2000).Until(() => {
+                try
+                {
+                    _response = _ocelotClient.GetAsync(url).Result;
+                    _response.EnsureSuccessStatusCode();
+                    return true;
+                }
+                catch(Exception)
+                {
+                    return false;
+                }
+            });
+
+            result.ShouldBeTrue();
+        }
+
         public void WhenIGetUrlOnTheApiGateway(string url, string cookie, string value)
         {
             var request = _ocelotServer.CreateRequest(url);

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs

@@ -26,7 +26,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         {
             _factory = new Mock<ILoadBalancerFactory>();
             _loadBalancerHouse = new LoadBalancerHouse(_factory.Object);
-            _serviceProviderConfig = new ServiceProviderConfiguration("myType","myHost",123, string.Empty, "configKey");
+            _serviceProviderConfig = new ServiceProviderConfiguration("myType","myHost",123, string.Empty, "configKey", 0);
         }
 
         [Fact]

test/Ocelot.UnitTests/ServiceDiscovery/PollingConsulServiceDiscoveryProviderTests.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Consul;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Moq;
+using Ocelot.Infrastructure.Consul;
+using Ocelot.Logging;
+using Ocelot.ServiceDiscovery.Configuration;
+using Ocelot.ServiceDiscovery.Providers;
+using Ocelot.Values;
+using Xunit;
+using TestStack.BDDfy;
+using Shouldly;
+using static Ocelot.Infrastructure.Wait;
+
+namespace Ocelot.UnitTests.ServiceDiscovery
+{
+    public class PollingConsulServiceDiscoveryProviderTests
+    {
+        private readonly int _delay;
+        private PollingConsulServiceDiscoveryProvider _provider;
+        private readonly string _serviceName;
+        private List<Service> _services;
+        private readonly Mock<IOcelotLoggerFactory> _factory;
+        private readonly Mock<IOcelotLogger> _logger;
+        private Mock<IServiceDiscoveryProvider> _consulServiceDiscoveryProvider;
+        private List<Service> _result;
+
+        public PollingConsulServiceDiscoveryProviderTests()
+        {
+            _services = new List<Service>();
+            _delay = 1;
+            _factory = new Mock<IOcelotLoggerFactory>();
+            _logger = new Mock<IOcelotLogger>();
+            _factory.Setup(x => x.CreateLogger<PollingConsulServiceDiscoveryProvider>()).Returns(_logger.Object);
+            _consulServiceDiscoveryProvider = new Mock<IServiceDiscoveryProvider>();
+        }
+
+        [Fact]
+        public void should_return_service_from_consul()
+        {
+            var service = new Service("", new ServiceHostAndPort("", 0), "", "", new List<string>());
+
+            this.Given(x => GivenConsulReturns(service))
+                .When(x => WhenIGetTheServices(1))
+                .Then(x => ThenTheCountIs(1))
+                .BDDfy();
+        }
+
+        private void GivenConsulReturns(Service service)
+        {
+            _services.Add(service);
+            _consulServiceDiscoveryProvider.Setup(x => x.Get()).ReturnsAsync(_services);
+        }
+
+        private void ThenTheCountIs(int count)
+        {
+            _result.Count.ShouldBe(count);
+        }
+
+        private void WhenIGetTheServices(int expected)
+        {
+            _provider = new PollingConsulServiceDiscoveryProvider(_delay, _serviceName, _factory.Object, _consulServiceDiscoveryProvider.Object);
+
+            var result = WaitFor(3000).Until(() => {
+                try
+                {
+                    _result = _provider.Get().GetAwaiter().GetResult();
+                    if(_result.Count == expected)
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+                catch(Exception)
+                {
+                    return false;
+                }
+            });
+
+            result.ShouldBeTrue();
+        }
+    }
+}

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -1,154 +1,177 @@
-using System;
-using System.Collections.Generic;
-using Moq;
-using Ocelot.Configuration;
-using Ocelot.Configuration.Builder;
-using Ocelot.Infrastructure.Consul;
-using Ocelot.Logging;
-using Ocelot.ServiceDiscovery;
-using Ocelot.ServiceDiscovery.Providers;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.ServiceDiscovery
-{
+using System;
+using System.Collections.Generic;
+using Moq;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.Infrastructure.Consul;
+using Ocelot.Logging;
+using Ocelot.ServiceDiscovery;
+using Ocelot.ServiceDiscovery.Providers;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.ServiceDiscovery
+{
     using Pivotal.Discovery.Client;
     using Steeltoe.Common.Discovery;
 
-    public class ServiceProviderFactoryTests
-    {
-        private ServiceProviderConfiguration _serviceConfig;
-        private IServiceDiscoveryProvider _result;
-        private readonly ServiceDiscoveryProviderFactory _factory;
-        private DownstreamReRoute _reRoute;
-        private Mock<IOcelotLoggerFactory> _loggerFactory;
-        private Mock<IDiscoveryClient> _discoveryClient;
-
-        public ServiceProviderFactoryTests()
-        {
-            _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _discoveryClient = new Mock<IDiscoveryClient>();
-            _factory = new ServiceDiscoveryProviderFactory(_loggerFactory.Object, new ConsulClientFactory(), _discoveryClient.Object);
-        }
-        
-        [Fact]
-        public void should_return_no_service_provider()
-        {
-            var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            var reRoute = new DownstreamReRouteBuilder().Build();
-
-            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
-                .When(x => x.WhenIGetTheServiceProvider())
-                .Then(x => x.ThenTheServiceProviderIs<ConfigurationServiceProvider>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_list_of_configuration_services()
-        {
-            var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            var downstreamAddresses = new List<DownstreamHostAndPort>()
-            {
-                new DownstreamHostAndPort("asdf.com", 80),
-                new DownstreamHostAndPort("abc.com", 80)
-            };
-
-            var reRoute = new DownstreamReRouteBuilder().WithDownstreamAddresses(downstreamAddresses).Build();
-
-            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
-                .When(x => x.WhenIGetTheServiceProvider())
-                .Then(x => x.ThenTheServiceProviderIs<ConfigurationServiceProvider>())
-                .Then(x => ThenTheFollowingServicesAreReturned(downstreamAddresses))
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_consul_service_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithServiceName("product")
-                .WithUseServiceDiscovery(true)
-                .Build();
-
-            var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
-                .When(x => x.WhenIGetTheServiceProvider())
-                .Then(x => x.ThenTheServiceProviderIs<ConsulServiceDiscoveryProvider>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_service_fabric_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithServiceName("product")
-                .WithUseServiceDiscovery(true)
-                .Build();
-
-            var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .WithType("ServiceFabric")
-                .Build();
-
-            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
-                .When(x => x.WhenIGetTheServiceProvider())
-                .Then(x => x.ThenTheServiceProviderIs<ServiceFabricServiceDiscoveryProvider>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_eureka_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithServiceName("product")
-                .WithUseServiceDiscovery(true)
-                .Build();
-
-            var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .WithType("Eureka")
-                .Build();
-
-            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
-                .When(x => x.WhenIGetTheServiceProvider())
-                .Then(x => x.ThenTheServiceProviderIs<EurekaServiceDiscoveryProvider>())
-                .BDDfy();
-        }
-
-        private void ThenTheFollowingServicesAreReturned(List<DownstreamHostAndPort> downstreamAddresses)
-        {
-            var result = (ConfigurationServiceProvider)_result;
-            var services = result.Get().Result;
-            
-            for (int i = 0; i < services.Count; i++)
-            {
-                var service = services[i];
-                var downstreamAddress = downstreamAddresses[i];
-
-                service.HostAndPort.DownstreamHost.ShouldBe(downstreamAddress.Host);
-                service.HostAndPort.DownstreamPort.ShouldBe(downstreamAddress.Port);
-            }
-        }
-
-        private void GivenTheReRoute(ServiceProviderConfiguration serviceConfig, DownstreamReRoute reRoute)
-        {
-            _serviceConfig = serviceConfig;
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheServiceProvider()
-        {
-            _result = _factory.Get(_serviceConfig, _reRoute);
-        }
-
-        private void ThenTheServiceProviderIs<T>()
-        {
-            _result.ShouldBeOfType<T>();
-        }
-    }
-}
+    public class ServiceProviderFactoryTests
+    {
+        private ServiceProviderConfiguration _serviceConfig;
+        private IServiceDiscoveryProvider _result;
+        private readonly ServiceDiscoveryProviderFactory _factory;
+        private DownstreamReRoute _reRoute;
+        private Mock<IOcelotLoggerFactory> _loggerFactory;
+        private Mock<IDiscoveryClient> _discoveryClient;
+        private Mock<IOcelotLogger> _logger;
+
+        public ServiceProviderFactoryTests()
+        {
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+            _logger = new Mock<IOcelotLogger>();
+            _loggerFactory.Setup(x => x.CreateLogger<PollingConsulServiceDiscoveryProvider>()).Returns(_logger.Object);
+            _discoveryClient = new Mock<IDiscoveryClient>();
+            var consulClient = new Mock<IConsulClientFactory>();
+            _factory = new ServiceDiscoveryProviderFactory(_loggerFactory.Object, consulClient.Object, _discoveryClient.Object);
+        }
+        
+        [Fact]
+        public void should_return_no_service_provider()
+        {
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            var reRoute = new DownstreamReRouteBuilder().Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<ConfigurationServiceProvider>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_list_of_configuration_services()
+        {
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            var downstreamAddresses = new List<DownstreamHostAndPort>()
+            {
+                new DownstreamHostAndPort("asdf.com", 80),
+                new DownstreamHostAndPort("abc.com", 80)
+            };
+
+            var reRoute = new DownstreamReRouteBuilder().WithDownstreamAddresses(downstreamAddresses).Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<ConfigurationServiceProvider>())
+                .Then(x => ThenTheFollowingServicesAreReturned(downstreamAddresses))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_consul_service_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .Build();
+
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<ConsulServiceDiscoveryProvider>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_polling_consul_service_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .Build();
+
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .WithType("PollConsul")
+                .WithPollingInterval(100000)
+                .Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<PollingConsulServiceDiscoveryProvider>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_service_fabric_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .Build();
+
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .WithType("ServiceFabric")
+                .Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<ServiceFabricServiceDiscoveryProvider>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_eureka_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .Build();
+
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .WithType("Eureka")
+                .Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<EurekaServiceDiscoveryProvider>())
+                .BDDfy();
+        }
+
+        private void ThenTheFollowingServicesAreReturned(List<DownstreamHostAndPort> downstreamAddresses)
+        {
+            var result = (ConfigurationServiceProvider)_result;
+            var services = result.Get().Result;
+            
+            for (int i = 0; i < services.Count; i++)
+            {
+                var service = services[i];
+                var downstreamAddress = downstreamAddresses[i];
+
+                service.HostAndPort.DownstreamHost.ShouldBe(downstreamAddress.Host);
+                service.HostAndPort.DownstreamPort.ShouldBe(downstreamAddress.Port);
+            }
+        }
+
+        private void GivenTheReRoute(ServiceProviderConfiguration serviceConfig, DownstreamReRoute reRoute)
+        {
+            _serviceConfig = serviceConfig;
+            _reRoute = reRoute;
+        }
+
+        private void WhenIGetTheServiceProvider()
+        {
+            _result = _factory.Get(_serviceConfig, _reRoute);
+        }
+
+        private void ThenTheServiceProviderIs<T>()
+        {
+            _result.ShouldBeOfType<T>();
+        }
+    }
+}