Merge branch 'dev'

RELEASE_NOTES.md

@@ -1,6 +1,29 @@
+#### 1.4.30 December 13 2021 ####
+Akka.NET v1.4.30 is a minor release that contains some enhancements for Akka.Streams and some bug fixes.
+
+New features:
+* [Akka: Added StringBuilder pooling in NewtonsoftJsonSerializer](https://github.com/akkadotnet/akka.net/pull/4929)
+* [Akka.TestKint: Added InverseFishForMessage](https://github.com/akkadotnet/akka.net/pull/5430)
+* [Akka.Streams: Added custom frame sized Flow to Framing](https://github.com/akkadotnet/akka.net/pull/5444)
+* [Akka.Streams: Allow Stream to be consumed as IAsyncEnumerable](https://github.com/akkadotnet/akka.net/pull/4742) 
+
+Bug fixes:
+* [Akka.Cluster: Reverted startup sequence change](https://github.com/akkadotnet/akka.net/pull/5437)
+
+If you want to see the [full set of changes made in Akka.NET v1.4.30, click here](https://github.com/akkadotnet/akka.net/milestone/61).
+
+| COMMITS | LOC+ | LOC- | AUTHOR |
+| --- | --- | --- | --- |
+| 6 | 75 | 101 | Aaron Stannard |
+| 2 | 53 | 5 | Brah McDude |
+| 2 | 493 | 12 | Drew |
+| 1 | 289 | 383 | Andreas Dirnberger |
+| 1 | 220 | 188 | Gregorius Soedharmo |
+| 1 | 173 | 28 | Ismael Hamed |
+
 #### 1.4.29 December 13 2021 ####
 **Maintenance Release for Akka.NET 1.4**
-Akka.NET v1.4.28 is a minor release that contains some enhancements for Akka.Streams and some bug fixes.
+Akka.NET v1.4.29 is a minor release that contains some enhancements for Akka.Streams and some bug fixes.
 
 New features:
 * [Akka: Added a channel based task scheduler](https://github.com/akkadotnet/akka.net/pull/5403)

src/benchmark/SerializationBenchmarks/Program.cs

@@ -6,20 +6,100 @@
 //-----------------------------------------------------------------------
 
 using System;
+using System.IO;
+using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 using Akka.Actor;
 using Akka.Configuration;
 using Akka.Serialization;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Running;
+using Newtonsoft.Json;
 
 namespace SerializationBenchmarks
 {
     class Program
     {
         static void Main(string[] args)
         {
-            BenchmarkRunner.Run<SerializationTests>();
+            BenchmarkRunner.Run<JsonSerializerTests>();
+        }
+    }
+
+    public class TestSer
+    {
+        public int Id { get; set; }
+        public string someStr { get; set; }
+        public string someStr2 { get; set; }
+        public string someStr3 { get; set; }
+        public Guid IDK { get; set; }
+    }
+        [MemoryDiagnoser]
+    public class JsonSerializerTests
+    {
+        public JsonSerializerTests()
+        {
+            _sys_noPool = ActorSystem.Create("bench-serialization-json-nopool",ConfigurationFactory.ParseString(@"
+akka.actor {{
+                        
+serialization-settings {{
+  json {{
+    use-pooled-string-builder = false
+ }}
+}}
+                    }}"));
+            _sys_pool = ActorSystem.Create("bench-serialization-json-pool");
+            _noPoolSer =
+                _sys_noPool.Serialization.FindSerializerForType(typeof(object));
+            _poolSer = 
+            _sys_pool.Serialization.FindSerializerForType(typeof(object));
+        }
+        private static TestSer testObj = new TestSer()
+        {
+            Id = 124,
+            someStr =
+                "412tgieoargj4a9349u2u-03jf3290rjf2390ja209fj1099u42n0f92qm93df3m-032jfq-102",
+            someStr2 =
+                "412tgieoargj4a9349u2u-03jf3290rjf2390ja209fj1099u42n0f92qm93df3m-032jfq-102",
+            someStr3 =
+                new string(Enumerable.Repeat('l',512).ToArray()),
+            IDK = Guid.Empty
+        };
+
+        private ActorSystem _sys_noPool;
+        private ActorSystem _sys_pool;
+        private Serializer _noPoolSer;
+        private Serializer _poolSer;
+        private const int _numIters = 10000; 
+        [Benchmark]
+        public void Pooling()
+        {
+            for (int i = 0; i < _numIters; i++)
+            {
+                _poolSer.ToBinary(testObj);
+            }
+        }
+        [Benchmark]
+        public void NoPooling()
+        {
+            for (int i = 0; i < _numIters; i++)
+            {
+                _noPoolSer.ToBinary(testObj);
+            }
+        }
+
+        [Benchmark]
+        public void Pooling_MultiTasks()
+        {
+            Task.WaitAll(Enumerable.Repeat(0, 10)
+                .Select((l) => Task.Run(Pooling)).ToArray());
+        }
+        [Benchmark]
+        public void NoPooling_MultiTasks()
+        {
+            Task.WaitAll(Enumerable.Repeat(0, 10)
+                .Select((l) => Task.Run(NoPooling)).ToArray());
         }
     }
 

src/contrib/dependencyinjection/Akka.DI.Core/DIActorProducer.cs

@@ -13,12 +13,13 @@ namespace Akka.DI.Core
     /// <summary>
     /// This class represents an actor creation strategy that uses dependency injection (DI) to resolve and instantiate actors based on their type.
     /// </summary>
-    public class DIActorProducer : IIndirectActorProducer
+    public sealed class DIActorProducer : IIndirectActorProducerWithActorType
     {
-        private IDependencyResolver dependencyResolver;
-        private Type actorType;
+        private readonly IDependencyResolver _dependencyResolver;
+        private readonly Type _actorType;
+        private readonly Func<ActorBase> _actorFactory;
 
-        readonly Func<ActorBase> actorFactory;
+        public Type ActorType => _actorType;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DIActorProducer"/> class.
@@ -33,26 +34,20 @@ public DIActorProducer(IDependencyResolver dependencyResolver, Type actorType)
             if (dependencyResolver == null) throw new ArgumentNullException(nameof(dependencyResolver), $"DIActorProducer requires {nameof(dependencyResolver)} to be provided");
             if (actorType == null) throw new ArgumentNullException(nameof(actorType), $"DIActorProducer requires {nameof(actorType)} to be provided");
 
-            this.dependencyResolver = dependencyResolver;
-            this.actorType = actorType;
-            this.actorFactory = dependencyResolver.CreateActorFactory(actorType);
+            _dependencyResolver = dependencyResolver;
+            _actorType = actorType;
+            _actorFactory = dependencyResolver.CreateActorFactory(actorType);
         }
-
-        /// <summary>
-        /// Retrieves the type of the actor to produce.
-        /// </summary>
-        public Type ActorType
-        {
-            get { return this.actorType; }
-        }
-
+
         /// <summary>
         /// Creates an actor based on the container's implementation specific actor factory.
         /// </summary>
         /// <returns>An actor created by the container.</returns>
-        public ActorBase Produce()
+        public ActorBase Produce(Props props)
         {
-            return actorFactory();
+            if (props.Type != _actorType)
+                throw new InvalidOperationException($"invalid actor type {props.Type}");
+            return _actorFactory();
         }
 
         /// <summary>
@@ -61,7 +56,7 @@ public ActorBase Produce()
         /// <param name="actor">The actor to remove from the container.</param>
         public void Release(ActorBase actor)
         {
-            dependencyResolver.Release(actor);
+            _dependencyResolver.Release(actor);
         }
     }
 }

src/contrib/dependencyinjection/Akka.DI.Core/DIExt.cs

@@ -38,7 +38,7 @@ public void Initialize(IDependencyResolver dependencyResolver)
         /// <returns>A <see cref="Akka.Actor.Props"/> configuration object for the given actor type.</returns>
         public Props Props(Type actorType)
         {
-            return new Props(typeof(DIActorProducer), new object[] { dependencyResolver, actorType });
+            return Akka.Actor.Props.CreateBy(new DIActorProducer(dependencyResolver, actorType), actorType);
         }
     }
 }

src/contrib/dependencyinjection/Akka.DependencyInjection/ServiceProvider.cs

@@ -63,7 +63,7 @@ public static ServiceProvider For(ActorSystem actorSystem)
         /// <returns>A new <see cref="Akka.Actor.Props"/> instance which uses DI internally.</returns>
         public Props Props<T>(params object[] args) where T : ActorBase
         {
-            return Akka.Actor.Props.CreateBy(new ServiceProviderActorProducer<T>(Provider, args));
+            return Akka.Actor.Props.CreateBy(new ServiceProviderActorProducer(Provider), typeof(T), args);
         }
     }
 
@@ -93,43 +93,23 @@ public override ServiceProvider CreateExtension(ExtendedActorSystem system)
     ///
     /// Used to create actors via the <see cref="ActivatorUtilities"/>.
     /// </summary>
-    internal class ServiceProviderActorProducer : IIndirectActorProducer
+    internal sealed class ServiceProviderActorProducer : IIndirectActorProducer
     {
         private readonly IServiceProvider _provider;
-        private readonly object[] _args;
-
-        public ServiceProviderActorProducer(IServiceProvider provider, Type actorType, object[] args)
+
+        public ServiceProviderActorProducer(IServiceProvider provider)
         {
             _provider = provider;
-            _args = args;
-            ActorType = actorType;
         }
 
-        public ActorBase Produce()
+        public ActorBase Produce(Props props)
         {
-            return (ActorBase)ActivatorUtilities.CreateInstance(_provider, ActorType, _args);
+            return (ActorBase)ActivatorUtilities.CreateInstance(_provider, props.Type, props.Arguments);
         }
 
-        public Type ActorType { get; }
-
         public void Release(ActorBase actor)
         {
             // no-op
         }
     }
-
-    /// <summary>
-    /// INTERNAL API
-    ///
-    /// Used to create actors via the <see cref="ActivatorUtilities"/>.
-    /// </summary>
-    /// <typeparam name="TActor">the actor type</typeparam>
-    internal class ServiceProviderActorProducer<TActor> : ServiceProviderActorProducer where TActor:ActorBase
-    {
-
-        public ServiceProviderActorProducer(IServiceProvider provider, object[] args)
-             : base(provider, typeof(TActor), args)
-        {
-        }
-    }
 }

src/contrib/dependencyinjection/Akka.DependencyInjection/ServiceProviderDependencyResolver.cs

@@ -18,11 +18,14 @@ namespace Akka.DependencyInjection
     /// </summary>
     public class ServiceProviderDependencyResolver : IDependencyResolver
     {
+        private readonly ServiceProviderActorProducer _producer;
+
         public IServiceProvider ServiceProvider { get; }
 
         public ServiceProviderDependencyResolver(IServiceProvider serviceProvider)
         {
             ServiceProvider = serviceProvider;
+            _producer = new ServiceProviderActorProducer(ServiceProvider);
         }
 
         public IResolverScope CreateScope()
@@ -43,7 +46,7 @@ public object GetService(Type type)
         public Props Props(Type type, params object[] args)
         {
             if(typeof(ActorBase).IsAssignableFrom(type))
-                return Akka.Actor.Props.CreateBy(new ServiceProviderActorProducer(ServiceProvider, type, args));
+                return Akka.Actor.Props.CreateBy(_producer, type, args);
             throw new ArgumentException(nameof(type), $"[{type}] does not implement Akka.Actor.ActorBase.");
         }
 
@@ -54,7 +57,7 @@ public Props Props(Type type)
 
         public Props Props<T>(params object[] args) where T : ActorBase
         {
-            return Akka.Actor.Props.CreateBy(new ServiceProviderActorProducer<T>(ServiceProvider, args));
+            return Akka.Actor.Props.CreateBy(_producer, typeof(T), args);
         }
     }