Add IDiscoveryClient.InstancesFetched event

Author: bart-vmware

src/Common/src/Common/Discovery/DiscoveryInstancesFetchedEventArgs.cs

@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information.
+
+namespace Steeltoe.Common.Discovery;
+
+/// <summary>
+/// Provides data for the <see cref="IDiscoveryClient.InstancesFetched" /> event.
+/// </summary>
+public sealed class DiscoveryInstancesFetchedEventArgs : EventArgs
+{
+    /// <summary>
+    /// Gets the updated list of service instances, grouped by service ID.
+    /// </summary>
+    public IReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> InstancesByServiceId { get; }
+
+    public DiscoveryInstancesFetchedEventArgs(IReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> instancesByServiceId)
+    {
+        ArgumentNullException.ThrowIfNull(instancesByServiceId);
+
+        InstancesByServiceId = instancesByServiceId;
+    }
+}

src/Common/src/Common/Discovery/IDiscoveryClient.cs

@@ -14,6 +14,11 @@ public interface IDiscoveryClient
     /// </summary>
     string Description { get; }
 
+    /// <summary>
+    /// Occurs when service instances have been fetched from the discovery server.
+    /// </summary>
+    public event EventHandler<DiscoveryInstancesFetchedEventArgs> InstancesFetched;
+
     /// <summary>
     /// Gets information used to register the local service instance (this app) to the discovery server.
     /// </summary>

src/Common/src/Common/PublicAPI.Unshipped.txt

@@ -1 +1,5 @@
 #nullable enable
+Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs
+Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs.DiscoveryInstancesFetchedEventArgs(System.Collections.Generic.IReadOnlyDictionary<string!, System.Collections.Generic.IReadOnlyList<Steeltoe.Common.Discovery.IServiceInstance!>!>! instancesByServiceId) -> void
+Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs.InstancesByServiceId.get -> System.Collections.Generic.IReadOnlyDictionary<string!, System.Collections.Generic.IReadOnlyList<Steeltoe.Common.Discovery.IServiceInstance!>!>!
+Steeltoe.Common.Discovery.IDiscoveryClient.InstancesFetched -> System.EventHandler<Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs!>!

src/Configuration/test/ConfigServer.Discovery.Test/ConfigServerDiscoveryServiceTest.cs

@@ -114,6 +114,10 @@ private sealed class TestDiscoveryClient : IDiscoveryClient
     {
         public string Description => throw new NotImplementedException();
 
+#pragma warning disable CS0067 // The event is never used
+        public event EventHandler<DiscoveryInstancesFetchedEventArgs>? InstancesFetched;
+#pragma warning restore CS0067 // The event is never used
+
         public Task<ISet<string>> GetServiceIdsAsync(CancellationToken cancellationToken)
         {
             throw new NotImplementedException();

src/Discovery/src/Configuration/ConfigurationDiscoveryClient.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.ObjectModel;
 using Microsoft.Extensions.Options;
 using Steeltoe.Common.Discovery;
 
@@ -10,17 +11,69 @@ namespace Steeltoe.Discovery.Configuration;
 /// <summary>
 /// A discovery client that reads service instances from app configuration.
 /// </summary>
-public sealed class ConfigurationDiscoveryClient : IDiscoveryClient
+public sealed class ConfigurationDiscoveryClient : IDiscoveryClient, IDisposable
 {
     private readonly IOptionsMonitor<ConfigurationDiscoveryOptions> _optionsMonitor;
+    private readonly IDisposable? _changeTokenRegistration;
 
     public string Description => "A discovery client that returns service instances from app configuration.";
 
+    /// <summary>
+    /// Occurs when the configuration of service instances has been reloaded.
+    /// </summary>
+    public event EventHandler<DiscoveryInstancesFetchedEventArgs>? InstancesFetched;
+
     public ConfigurationDiscoveryClient(IOptionsMonitor<ConfigurationDiscoveryOptions> optionsMonitor)
     {
         ArgumentNullException.ThrowIfNull(optionsMonitor);
 
         _optionsMonitor = optionsMonitor;
+        _changeTokenRegistration = optionsMonitor.OnChange(OnOptionsChanged);
+    }
+
+    private void OnOptionsChanged(ConfigurationDiscoveryOptions options)
+    {
+        if (InstancesFetched != null)
+        {
+            ReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> instancesByServiceId = ToServiceInstanceMap(options.Services);
+            var eventArgs = new DiscoveryInstancesFetchedEventArgs(instancesByServiceId);
+            RaiseFetchEvent(eventArgs);
+        }
+    }
+
+    private static ReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> ToServiceInstanceMap(IList<ConfigurationServiceInstance> services)
+    {
+        // @formatter:wrap_chained_method_calls chop_always
+        // @formatter:wrap_before_first_method_call true
+
+        return services
+            .Where(service => service.ServiceId != null)
+            .GroupBy(service => service.ServiceId!, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(grouping => grouping.Key, grouping => (IReadOnlyList<IServiceInstance>)grouping
+                .Select(instance => (IServiceInstance)instance)
+                .ToList()
+                .AsReadOnly())
+            .AsReadOnly();
+
+        // @formatter:wrap_before_first_method_call restore
+        // @formatter:wrap_chained_method_calls restore
+    }
+
+    private void RaiseFetchEvent(DiscoveryInstancesFetchedEventArgs eventArgs)
+    {
+        // Execute on separate thread, so we won't block the configuration system in case the handler logic is expensive.
+        ThreadPool.QueueUserWorkItem(_ =>
+        {
+            try
+            {
+                InstancesFetched?.Invoke(this, eventArgs);
+            }
+            catch (Exception)
+            {
+                // Intentionally left empty. Adding a logger to the constructor is a breaking change.
+                // Adding an extra constructor confuses the service container.
+            }
+        });
     }
 
     /// <inheritdoc />
@@ -54,4 +107,10 @@ public Task ShutdownAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _changeTokenRegistration?.Dispose();
+    }
 }

src/Discovery/src/Configuration/PublicAPI.Unshipped.txt

@@ -1 +1,3 @@
 #nullable enable
+Steeltoe.Discovery.Configuration.ConfigurationDiscoveryClient.Dispose() -> void
+Steeltoe.Discovery.Configuration.ConfigurationDiscoveryClient.InstancesFetched -> System.EventHandler<Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs!>?

src/Discovery/src/Consul/ConsulDiscoveryClient.cs

@@ -30,6 +30,13 @@ public sealed class ConsulDiscoveryClient : IDiscoveryClient
     /// <inheritdoc />
     public string Description => "A discovery client for HashiCorp Consul.";
 
+    /// <summary>
+    /// This event is never raised. The Consul client doesn't implement caching.
+    /// </summary>
+#pragma warning disable CS0067 // The event is never used
+    public event EventHandler<DiscoveryInstancesFetchedEventArgs>? InstancesFetched;
+#pragma warning restore CS0067 // The event is never used
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ConsulDiscoveryClient" /> class.
     /// </summary>

src/Discovery/src/Consul/PublicAPI.Unshipped.txt

@@ -1 +1,2 @@
 #nullable enable
+Steeltoe.Discovery.Consul.ConsulDiscoveryClient.InstancesFetched -> System.EventHandler<Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs!>?

src/Discovery/src/Eureka/EurekaDiscoveryClient.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.ObjectModel;
 using System.Text;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -69,6 +70,9 @@ internal ApplicationInfoCollection Applications
     /// </summary>
     public event EventHandler<ApplicationsFetchedEventArgs>? ApplicationsFetched;
 
+    /// <inheritdoc />
+    public event EventHandler<DiscoveryInstancesFetchedEventArgs>? InstancesFetched;
+
     public EurekaDiscoveryClient(EurekaApplicationInfoManager appInfoManager, EurekaClient eurekaClient,
         IOptionsMonitor<EurekaClientOptions> clientOptionsMonitor, HealthCheckHandlerProvider healthCheckHandlerProvider, TimeProvider timeProvider,
         ILogger<EurekaDiscoveryClient> logger)
@@ -326,7 +330,8 @@ internal async Task FetchRegistryAsync(bool doFullUpdate, CancellationToken canc
 
         await _registryFetchAsyncLock.WaitAsync(cancellationToken);
 
-        ApplicationsFetchedEventArgs eventArgs;
+        ApplicationsFetchedEventArgs? applicationsEventArgs = null;
+        DiscoveryInstancesFetchedEventArgs? instancesEventArgs = null;
 
         try
         {
@@ -344,33 +349,75 @@ internal async Task FetchRegistryAsync(bool doFullUpdate, CancellationToken canc
 
             UpdateLastRemoteInstanceStatusFromCache();
 
-            eventArgs = new ApplicationsFetchedEventArgs(_remoteApps);
+            if (ApplicationsFetched != null)
+            {
+                applicationsEventArgs = new ApplicationsFetchedEventArgs(_remoteApps);
+            }
+
+            if (InstancesFetched != null)
+            {
+                ReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> instancesByServiceId = ToServiceInstanceMap(_remoteApps);
+                instancesEventArgs = new DiscoveryInstancesFetchedEventArgs(instancesByServiceId);
+            }
         }
         finally
         {
             _registryFetchAsyncLock.Release();
         }
 
-        OnApplicationsFetched(eventArgs);
+        if (applicationsEventArgs != null || instancesEventArgs != null)
+        {
+            RaiseFetchEvents(applicationsEventArgs, instancesEventArgs);
+        }
     }
 
-    private void OnApplicationsFetched(ApplicationsFetchedEventArgs? args)
+    private static ReadOnlyDictionary<string, IReadOnlyList<IServiceInstance>> ToServiceInstanceMap(ApplicationInfoCollection apps)
     {
-        if (args != null)
+        // @formatter:wrap_chained_method_calls chop_always
+        // @formatter:wrap_before_first_method_call true
+
+        return apps
+            .SelectMany(app => app.Instances)
+            .GroupBy(instance => instance.AppName, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(grouping => grouping.Key, grouping => (IReadOnlyList<IServiceInstance>)grouping
+                .Select(instance => instance.ToServiceInstance())
+                .ToList()
+                .AsReadOnly())
+            .AsReadOnly();
+
+        // @formatter:wrap_before_first_method_call restore
+        // @formatter:wrap_chained_method_calls restore
+    }
+
+    private void RaiseFetchEvents(ApplicationsFetchedEventArgs? applicationsEventArgs, DiscoveryInstancesFetchedEventArgs? instancesEventArgs)
+    {
+        // Execute on separate thread, so we won't block the periodic refresh in case the handler logic is expensive.
+        ThreadPool.QueueUserWorkItem(_ =>
         {
-            // Execute on separate thread, so we won't block the periodic refresh in case the handler logic is expensive.
-            ThreadPool.QueueUserWorkItem(_ =>
+            try
             {
-                try
+                if (applicationsEventArgs != null)
                 {
-                    ApplicationsFetched?.Invoke(this, args);
+                    ApplicationsFetched?.Invoke(this, applicationsEventArgs);
                 }
-                catch (Exception exception)
+            }
+            catch (Exception exception)
+            {
+                LogFailedToHandleEvent(exception, nameof(ApplicationsFetched));
+            }
+
+            try
+            {
+                if (instancesEventArgs != null)
                 {
-                    LogFailedToHandleEvent(exception, nameof(ApplicationsFetched));
+                    InstancesFetched?.Invoke(this, instancesEventArgs);
                 }
-            });
-        }
+            }
+            catch (Exception exception)
+            {
+                LogFailedToHandleEvent(exception, nameof(InstancesFetched));
+            }
+        });
     }
 
     internal async Task<ApplicationInfoCollection> FetchFullRegistryAsync(CancellationToken cancellationToken)

src/Discovery/src/Eureka/PublicAPI.Unshipped.txt

@@ -1,3 +1,4 @@
 #nullable enable
 Steeltoe.Discovery.Eureka.Configuration.EurekaInstanceOptions.UseAspNetCoreUrls.get -> bool
 Steeltoe.Discovery.Eureka.Configuration.EurekaInstanceOptions.UseAspNetCoreUrls.set -> void
+Steeltoe.Discovery.Eureka.EurekaDiscoveryClient.InstancesFetched -> System.EventHandler<Steeltoe.Common.Discovery.DiscoveryInstancesFetchedEventArgs!>?