Refactor: Agent Accessor Chain (#39)

* refactor: use singleton instead of scoped

need to use async local to avoid collisions

* refactor: rename NoAgent to UnknownAgent, make publicly usable

* feat: agent accessor chain

an implementation of the IAgentAccessor that expects to handle multiple implementations of IAgentAccessor in a private service collection.

Author: the-avid-engineer

src/EntityDb.Abstractions/Agents/IAgentAccessor.cs

@@ -1,13 +1,13 @@
 namespace EntityDb.Abstractions.Agents;
 
 /// <summary>
-///     Represents a type that can access an instance of <see cref="IAgent" /> within a service scope.
+///     Represents a type that can access an instance of <see cref="IAgent" />.
 /// </summary>
 public interface IAgentAccessor
 {
     /// <summary>
-    ///     Returns the agent of the service scope.
+    ///     Returns the agent.
     /// </summary>
-    /// <returns>The agent of the service scope.</returns>
+    /// <returns>The agent.</returns>
     IAgent GetAgent();
 }

src/EntityDb.Common/Agents/AgentAccessorBase.cs

@@ -1,15 +1,16 @@
 using EntityDb.Abstractions.Agents;
+using System.Threading;
 
 namespace EntityDb.Common.Agents;
 
 internal abstract class AgentAccessorBase : IAgentAccessor
 {
-    private IAgent? _agent;
+    private readonly AsyncLocal<IAgent?> _agent = new();
 
     protected abstract IAgent CreateAgent();
 
     public IAgent GetAgent()
     {
-        return _agent ??= CreateAgent();
+        return _agent.Value ??= CreateAgent();
     }
 }

src/EntityDb.Common/Agents/AgentAccessorChain.cs

@@ -0,0 +1,56 @@
+using EntityDb.Abstractions.Agents;
+using EntityDb.Common.Exceptions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System;
+using System.Linq;
+
+namespace EntityDb.Common.Agents;
+
+/// <summary>
+///     Represents a type that chains together multiple instances of <see cref="IAgentAccessor" /> and returns the
+///     <see cref="IAgent"/> returned by the first <see cref="IAgentAccessor" /> that does not throw an exception.
+///
+///     If all instances of <see cref="IAgentAccessor"/> throw an exception, this type will throw a
+///     <see cref="NoAgentException"/>.
+/// </summary>
+public class AgentAccessorChain : IAgentAccessor
+{
+    private readonly ILogger<AgentAccessorChain> _logger;
+    private readonly IAgentAccessor[] _agentAccessors;
+    
+    /// <ignore/>
+    public AgentAccessorChain(ILogger<AgentAccessorChain> logger, IOptions<AgentAccessorChainOptions> options) : this(logger, options.Value)
+    {
+    }
+    
+    internal AgentAccessorChain(ILogger<AgentAccessorChain> logger, AgentAccessorChainOptions options)
+    {
+        var serviceProvider = options.ServiceCollection
+            .BuildServiceProvider();
+        
+        _logger = logger;
+        _agentAccessors = serviceProvider
+            .GetServices<IAgentAccessor>()
+            .ToArray();
+    }
+
+    /// <inheritdoc />
+    public IAgent GetAgent()
+    {
+        foreach (var agentAccessor in _agentAccessors)
+        {
+            try
+            {
+                return agentAccessor.GetAgent();
+            }
+            catch (Exception exception)
+            {
+                _logger.LogDebug(exception, "Agent accessor threw an exception. Moving on to next agent accessor");
+            }
+        }
+
+        throw new NoAgentException();
+    }
+}

src/EntityDb.Common/Agents/AgentAccessorChainOptions.cs

@@ -0,0 +1,15 @@
+using EntityDb.Abstractions.Agents;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EntityDb.Common.Agents;
+
+/// <summary>
+///     Options for configuring the <see cref="AgentAccessorChain"/>.
+/// </summary>
+public sealed class AgentAccessorChainOptions
+{
+    /// <summary>
+    ///     A service collection used to resolve multiple instances of <see cref="IAgentAccessor"/>.
+    /// </summary>
+    public IServiceCollection ServiceCollection { get; } = new ServiceCollection();
+}

src/EntityDb.Common/Agents/UnknownAgent.cs

@@ -0,0 +1,22 @@
+using EntityDb.Abstractions.Agents;
+using EntityDb.Abstractions.ValueObjects;
+
+namespace EntityDb.Common.Agents;
+
+/// <summary>
+///     Represents an unknown actor who can interact with transactions.
+/// </summary>
+public class UnknownAgent : IAgent
+{
+    /// <inheritdoc/>
+    public TimeStamp GetTimeStamp()
+    {
+        return TimeStamp.UtcNow;
+    }
+
+    /// <inheritdoc/>
+    public object GetSignature(string signatureOptionsName)
+    {
+        return new UnknownAgentSignature();
+    }
+}

src/EntityDb.Common/Agents/UnknownAgentAccessor.cs

@@ -0,0 +1,15 @@
+using EntityDb.Abstractions.Agents;
+
+namespace EntityDb.Common.Agents;
+
+/// <summary>
+///     Represents a type that indicates there is no known actor.
+/// </summary>
+public class UnknownAgentAccessor : IAgentAccessor
+{
+    /// <inheritdoc/>
+    public IAgent GetAgent()
+    {
+        return new UnknownAgent();
+    }
+}

src/EntityDb.Common/Agents/UnknownAgentSignature.cs

@@ -0,0 +1,6 @@
+namespace EntityDb.Common.Agents;
+
+/// <summary>
+///     Represents the signature of an unknown actor.
+/// </summary>
+public record UnknownAgentSignature;

src/EntityDb.Common/Extensions/ServiceCollectionExtensions.cs

@@ -68,7 +68,7 @@ public static void AddLifoTypeResolver(this IServiceCollection serviceCollection
     public static void AddAgentAccessor<TAgentAccessor>(this IServiceCollection serviceCollection)
         where TAgentAccessor : class, IAgentAccessor
     {
-        serviceCollection.AddScoped<IAgentAccessor, TAgentAccessor>();
+        serviceCollection.AddSingleton<IAgentAccessor, TAgentAccessor>();
     }
 
     /// <summary>