add UseTransactionCallback and mark UseSessionCallback obsolete

Author: smdn

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/IMuninNodeBuilderExtensions.cs

@@ -123,6 +123,22 @@ Func<IServiceProvider, INodeSessionCallback> buildSessionCallback
       buildSessionCallback: buildSessionCallback ?? throw new ArgumentNullException(nameof(buildSessionCallback))
     );
 
+#pragma warning disable CS0419
+  /// <remarks>
+  /// If <see cref="UsePluginProvider"/> is called, the configurations made by this method will be overridden.
+  /// </remarks>
+  public static IMuninNodeBuilder UseTransactionCallback(
+    this IMuninNodeBuilder builder,
+    Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc,
+    Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc
+  )
+#pragma warning restore CS0419
+    => MuninNodeBuilderExtensions.UseTransactionCallback(
+      builder: ThrowIfBuilderTypeIsNotSupported(builder ?? throw new ArgumentNullException(nameof(builder))),
+      onStartTransactionAsyncFunc: onStartTransactionAsyncFunc,
+      onEndTransactionAsyncFunc: onEndTransactionAsyncFunc
+    );
+
   public static IMuninNodeBuilder UseListenerFactory(
     this IMuninNodeBuilder builder,
     IMuninNodeListenerFactory listenerFactory

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/MuninNodeBuilder.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -24,6 +26,8 @@ public class MuninNodeBuilder : IMuninNodeBuilder {
   private readonly List<Func<IServiceProvider, IPlugin>> pluginFactories = new(capacity: 4);
   private Func<IServiceProvider, IPluginProvider>? buildPluginProvider;
   [Obsolete] private Func<IServiceProvider, INodeSessionCallback>? buildSessionCallback;
+  private Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc;
+  private Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc;
   private Func<IServiceProvider, IMuninNodeListenerFactory>? buildListenerFactory;
 
   /// <summary>
@@ -75,6 +79,15 @@ Func<IServiceProvider, INodeSessionCallback> buildSessionCallback
     this.buildSessionCallback = buildSessionCallback;
   }
 
+  internal void SetTransactionCallback(
+    Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc,
+    Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc
+  )
+  {
+    this.onStartTransactionAsyncFunc = onStartTransactionAsyncFunc;
+    this.onEndTransactionAsyncFunc = onEndTransactionAsyncFunc;
+  }
+
   internal void SetListenerFactory(
     Func<IServiceProvider, IMuninNodeListenerFactory> buildListenerFactory
   )
@@ -102,34 +115,50 @@ public IMuninNode Build(IServiceProvider serviceProvider)
         ? new PluginProvider(
             plugins: pluginFactories.Select(factory => factory(serviceProvider)).ToList(),
 #pragma warning disable CS0612
-            sessionCallback: buildSessionCallback?.Invoke(serviceProvider)
+            sessionCallback: buildSessionCallback?.Invoke(serviceProvider),
 #pragma warning restore CS0612
+            onStartTransactionAsyncFunc: onStartTransactionAsyncFunc,
+            onEndTransactionAsyncFunc: onEndTransactionAsyncFunc
           )
         : buildPluginProvider.Invoke(serviceProvider),
       listenerFactory: buildListenerFactory?.Invoke(serviceProvider),
       serviceProvider: serviceProvider
     );
   }
 
-  private sealed class PluginProvider : IPluginProvider {
+  private sealed class PluginProvider : IPluginProvider, ITransactionCallback {
     public IReadOnlyCollection<IPlugin> Plugins { get; }
 
     [Obsolete]
     public INodeSessionCallback? SessionCallback { get; }
 
+    private readonly Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc;
+    private readonly Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc;
+
     public PluginProvider(
       IReadOnlyCollection<IPlugin> plugins,
 #pragma warning disable CS0618
-      INodeSessionCallback? sessionCallback
+      INodeSessionCallback? sessionCallback,
 #pragma warning restore CS0618
+      Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc,
+      Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc
     )
     {
       Plugins = plugins ?? throw new ArgumentNullException(nameof(plugins));
 
 #pragma warning disable CS0612
       SessionCallback = sessionCallback;
 #pragma warning restore CS0612
+
+      this.onStartTransactionAsyncFunc = onStartTransactionAsyncFunc;
+      this.onEndTransactionAsyncFunc = onEndTransactionAsyncFunc;
     }
+
+    public ValueTask StartTransactionAsync(CancellationToken cancellationToken)
+      => onStartTransactionAsyncFunc?.Invoke(cancellationToken) ?? default;
+
+    public ValueTask EndTransactionAsync(CancellationToken cancellationToken)
+      => onEndTransactionAsyncFunc?.Invoke(cancellationToken) ?? default;
   }
 
   protected virtual IMuninNode Build(

src/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/MuninNodeBuilderExtensions.cs

@@ -100,15 +100,20 @@ Func<IServiceProvider, IPluginProvider> buildPluginProvider
     return builder;
   }
 
+#pragma warning disable CS0618
+  private const string ObsoleteMessageForUseSessionCallback =
+      $"{nameof(INodeSessionCallback)} is deprecated and will be removed in the next major version release. " +
+      $"Use ${nameof(UseTransactionCallback)} instead of {nameof(UseSessionCallback)}.";
+#pragma warning restore CS0618
+
 #pragma warning disable CS0419
   /// <remarks>
   /// If <see cref="UsePluginProvider"/> is called, the configurations made by this method will be overridden.
   /// </remarks>
+  [Obsolete(ObsoleteMessageForUseSessionCallback)]
   public static TMuninNodeBuilder UseSessionCallback<TMuninNodeBuilder>(
     this TMuninNodeBuilder builder,
-#pragma warning disable CS0618
     INodeSessionCallback sessionCallback
-#pragma warning restore CS0618
   )
     where TMuninNodeBuilder : MuninNodeBuilder
 #pragma warning restore CS0419
@@ -128,6 +133,7 @@ INodeSessionCallback sessionCallback
   /// <remarks>
   /// If <see cref="UsePluginProvider"/> is called, the configurations made by this method will be overridden.
   /// </remarks>
+  [Obsolete(ObsoleteMessageForUseSessionCallback)]
   public static TMuninNodeBuilder UseSessionCallback<TMuninNodeBuilder>(
     this TMuninNodeBuilder builder,
     Func<string, CancellationToken, ValueTask>? reportSessionStartedAsyncFunc,
@@ -137,12 +143,10 @@ public static TMuninNodeBuilder UseSessionCallback<TMuninNodeBuilder>(
 #pragma warning restore CS0419
     => UseSessionCallback(
       builder: builder,
-#pragma warning disable CS0612
       buildSessionCallback: _ => new SessionCallbackFuncWrapper(
         reportSessionStartedAsyncFunc,
         reportSessionClosedAsyncFunc
       )
-#pragma warning restore CS0612
     );
 
   [Obsolete]
@@ -165,11 +169,10 @@ public ValueTask ReportSessionClosedAsync(string sessionId, CancellationToken ca
   /// <remarks>
   /// If <see cref="UsePluginProvider"/> is called, the configurations made by this method will be overridden.
   /// </remarks>
+  [Obsolete(ObsoleteMessageForUseSessionCallback)]
   public static TMuninNodeBuilder UseSessionCallback<TMuninNodeBuilder>(
     this TMuninNodeBuilder builder,
-#pragma warning disable CS0618
     Func<IServiceProvider, INodeSessionCallback> buildSessionCallback
-#pragma warning restore CS0618
   )
     where TMuninNodeBuilder : MuninNodeBuilder
 #pragma warning restore CS0419
@@ -179,9 +182,30 @@ Func<IServiceProvider, INodeSessionCallback> buildSessionCallback
     if (buildSessionCallback is null)
       throw new ArgumentNullException(nameof(buildSessionCallback));
 
-#pragma warning disable CS0612
     builder.SetSessionCallbackFactory(buildSessionCallback);
-#pragma warning restore CS0612
+
+    return builder;
+  }
+
+#pragma warning disable CS0419
+  /// <remarks>
+  /// If <see cref="UsePluginProvider"/> is called, the configurations made by this method will be overridden.
+  /// </remarks>
+  public static TMuninNodeBuilder UseTransactionCallback<TMuninNodeBuilder>(
+    this TMuninNodeBuilder builder,
+    Func<CancellationToken, ValueTask>? onStartTransactionAsyncFunc,
+    Func<CancellationToken, ValueTask>? onEndTransactionAsyncFunc
+  )
+    where TMuninNodeBuilder : MuninNodeBuilder
+#pragma warning restore CS0419
+  {
+    if (builder is null)
+      throw new ArgumentNullException(nameof(builder));
+
+    builder.SetTransactionCallback(
+      onStartTransactionAsyncFunc,
+      onEndTransactionAsyncFunc
+    );
 
     return builder;
   }

tests/Smdn.Net.MuninNode/Smdn.Net.MuninNode.DependencyInjection/IMuninNodeBuilderExtensions.cs

@@ -454,6 +454,83 @@ public void UseSessionCallback_FuncBuildSessionCallback()
   }
 #pragma warning restore CS0618
 
+  [Test]
+  [CancelAfter(1000)]
+  public void UseTransactionCallback(
+    [Values] bool setOnStartTransactionAsyncFunc,
+    [Values] bool setOnEndTransactionAsyncFunc,
+    CancellationToken cancellationToken
+  )
+  {
+    var numberOfInvocationOfStartTransactionAsync = 0;
+    var numberOfInvocationOfEndTransactionAsync = 0;
+
+    var services = new ServiceCollection();
+
+    services.AddMunin(
+      builder =>
+        builder
+          .AddNode(option => { })
+          .UseTransactionCallback(
+            onStartTransactionAsyncFunc: setOnStartTransactionAsyncFunc
+              ? StartTransactionAsync
+              : null,
+            onEndTransactionAsyncFunc: setOnEndTransactionAsyncFunc
+              ? EndTransactionAsync
+              : null
+          )
+    );
+
+    ValueTask StartTransactionAsync(CancellationToken ct)
+    {
+      numberOfInvocationOfStartTransactionAsync++;
+
+      Assert.That(ct, Is.EqualTo(cancellationToken));
+
+      return default;
+    }
+
+    ValueTask EndTransactionAsync(CancellationToken ct)
+    {
+      numberOfInvocationOfEndTransactionAsync++;
+
+      Assert.That(ct, Is.EqualTo(cancellationToken));
+
+      return default;
+    }
+
+    var serviceProvider = services.BuildServiceProvider();
+    var node = (NodeBase)serviceProvider.GetRequiredService<IMuninNode>();
+
+    Assert.That(node.PluginProvider, Is.InstanceOf<ITransactionCallback>());
+
+    var transactionCallback = (ITransactionCallback)node.PluginProvider;
+
+    Assert.That(
+      async () => await transactionCallback.StartTransactionAsync(cancellationToken),
+      Throws.Nothing
+    );
+
+    Assert.That(
+      numberOfInvocationOfStartTransactionAsync,
+      setOnStartTransactionAsyncFunc
+        ? Is.EqualTo(1)
+        : Is.Zero
+    );
+
+    Assert.That(
+      async () => await transactionCallback.EndTransactionAsync(cancellationToken),
+      Throws.Nothing
+    );
+
+    Assert.That(
+      numberOfInvocationOfEndTransactionAsync,
+      setOnEndTransactionAsyncFunc
+        ? Is.EqualTo(1)
+        : Is.Zero
+    );
+  }
+
   [Test]
   public void UseListenerFactory_IMuninNodeListenerFactory_ArgumentNull()
   {