Add CounterGrain

Author: RehanSaeed

Source/Content/OrleansTemplate/Source/OrleansTemplate.Abstractions/Grains/ICounterGrain.cs

@@ -0,0 +1,17 @@
+namespace OrleansTemplate.Abstractions.Grains
+{
+    using System.Threading.Tasks;
+    using Orleans;
+
+    /// <summary>
+    /// Holds the total count.
+    /// </summary>
+    /// <remarks>Implemented using the 'Reduce' pattern (See https://github.com/OrleansContrib/DesignPatterns/blob/master/Reduce.md).</remarks>
+    /// <seealso cref="IGrainWithGuidKey" />
+    public interface ICounterGrain : IGrainWithGuidKey
+    {
+        Task<long> AddCount(long value);
+
+        Task<long> GetCount();
+    }
+}

Source/Content/OrleansTemplate/Source/OrleansTemplate.Abstractions/Grains/IStatelessCounterGrain.cs

@@ -0,0 +1,15 @@
+namespace OrleansTemplate.Abstractions.Grains
+{
+    using System.Threading.Tasks;
+    using Orleans;
+
+    /// <summary>
+    /// Holds the total count on a given silo and then feeds this forward to the <see cref="ICounterGrain"/>.
+    /// </summary>
+    /// <remarks>Implemented using the 'Reduce' pattern (See https://github.com/OrleansContrib/DesignPatterns/blob/master/Reduce.md).</remarks>
+    /// <seealso cref="IGrain" />
+    public interface ICounterStatelessGrain : IGrainWithIntegerKey
+    {
+        Task Increment();
+    }
+}

Source/Content/OrleansTemplate/Source/OrleansTemplate.Client/Program.cs

@@ -43,7 +43,7 @@ private static IClientBuilder CreateClientBuilder() =>
                 })
                 .ConfigureApplicationParts(
                     parts => parts
-                        .AddApplicationPart(typeof(IHelloGrain).Assembly)
+                        .AddApplicationPart(typeof(ICounterGrain).Assembly)
                         .WithReferences())
                 .AddSimpleMessageStreamProvider(StreamProviderName.Default);
     }

Source/Content/OrleansTemplate/Source/OrleansTemplate.Grains/CounterGrain.cs

@@ -0,0 +1,18 @@
+namespace OrleansTemplate.Grains
+{
+    using System.Threading.Tasks;
+    using Orleans;
+    using OrleansTemplate.Abstractions.Grains;
+
+    public class CounterGrain : Grain<long>, ICounterGrain
+    {
+        public async Task<long> AddCount(long value)
+        {
+            this.State += value;
+            await this.WriteStateAsync();
+            return this.State;
+        }
+
+        public Task<long> GetCount() => Task.FromResult(this.State);
+    }
+}

Source/Content/OrleansTemplate/Source/OrleansTemplate.Grains/CounterStatelessGrain.cs

@@ -0,0 +1,39 @@
+namespace OrleansTemplate.Grains
+{
+    using System;
+    using System.Threading.Tasks;
+    using Orleans;
+    using Orleans.Concurrency;
+    using OrleansTemplate.Abstractions.Grains;
+
+    /// <summary>
+    /// An implementation of the 'Reduce' pattern (See https://github.com/OrleansContrib/DesignPatterns/blob/master/Reduce.md).
+    /// </summary>
+    /// <seealso cref="Grain" />
+    /// <seealso cref="ICounterStatelessGrain" />
+    [StatelessWorker]
+    public class CounterStatelessGrain : Grain, ICounterStatelessGrain
+    {
+        private long count = 0;
+
+        public Task Increment()
+        {
+            this.count += 1;
+            return Task.CompletedTask;
+        }
+
+        public override Task OnActivateAsync()
+        {
+            this.RegisterTimer(this.OnTimerTick, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
+            return base.OnActivateAsync();
+        }
+
+        private Task OnTimerTick(object arg)
+        {
+            var count = this.count;
+            this.count = 0;
+            var counter = this.GrainFactory.GetGrain<ICounterGrain>(Guid.Empty);
+            return counter.AddCount(count);
+        }
+    }
+}

Source/Content/OrleansTemplate/Source/OrleansTemplate.Grains/HelloGrain.cs

@@ -6,6 +6,12 @@ namespace OrleansTemplate.Grains
 
     public class HelloGrain : Grain, IHelloGrain
     {
-        public Task<string> SayHello(string name) => Task.FromResult($"Hello {name}!");
+        public async Task<string> SayHello(string name)
+        {
+            var counter = this.GrainFactory.GetGrain<ICounterStatelessGrain>(0L);
+            await counter.Increment();
+
+            return $"Hello {name}!";
+        }
     }
 }

Source/Content/OrleansTemplate/Tests/OrleansTemplate.Server.IntegrationTest/CounterGrainTest.cs

@@ -0,0 +1,37 @@
+namespace OrleansTemplate.Server.IntegrationTest
+{
+    using System;
+    using System.Threading.Tasks;
+    using OrleansTemplate.Abstractions.Grains;
+    using OrleansTemplate.Server.IntegrationTest.Fixtures;
+    using Xunit;
+
+    public class CounterGrainTest
+    {
+        [Fact]
+        public async Task AddCount_PassValue_ReturnsTotalCount()
+        {
+            using (var fixture = new ClusterFixture())
+            {
+                var grain = fixture.Cluster.GrainFactory.GetGrain<ICounterGrain>(Guid.Empty);
+
+                var count = await grain.AddCount(10L);
+
+                Assert.Equal(10L, count);
+            }
+        }
+
+        [Fact]
+        public async Task GetCount_Default_ReturnsTotalCount()
+        {
+            using (var fixture = new ClusterFixture())
+            {
+                var grain = fixture.Cluster.GrainFactory.GetGrain<ICounterGrain>(Guid.Empty);
+
+                var count = await grain.GetCount();
+
+                Assert.Equal(0L, count);
+            }
+        }
+    }
+}

Source/Content/OrleansTemplate/Tests/OrleansTemplate.Server.IntegrationTest/CounterStatelessGrainTest.cs

@@ -0,0 +1,30 @@
+namespace OrleansTemplate.Server.IntegrationTest
+{
+    using System;
+    using System.Threading.Tasks;
+    using OrleansTemplate.Abstractions.Grains;
+    using OrleansTemplate.Server.IntegrationTest.Fixtures;
+    using Xunit;
+
+    public class CounterStatelessGrainTest
+    {
+        [Fact]
+        public async Task Increment_Default_EventuallyIncrementsTotalCount()
+        {
+            using (var fixture = new ClusterFixture())
+            {
+                var grain = fixture.Cluster.GrainFactory.GetGrain<ICounterStatelessGrain>(0L);
+                var counterGrain = fixture.Cluster.GrainFactory.GetGrain<ICounterGrain>(Guid.Empty);
+
+                await grain.Increment();
+                var countBefore = await counterGrain.GetCount();
+
+                Assert.Equal(0L, countBefore);
+
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
+                var countAfter = await counterGrain.GetCount();
+            }
+        }
+    }
+}

Source/Content/OrleansTemplate/Tests/OrleansTemplate.Server.IntegrationTest/HelloGrainTest.cs

@@ -16,9 +16,9 @@ public class HelloGrainTest : IClassFixture<ClusterFixture>
         [Fact]
         public async Task SayHello_PassName_ReturnsGreeting()
         {
-            var helloGrain = this.cluster.GrainFactory.GetGrain<IHelloGrain>(Guid.NewGuid());
+            var grain = this.cluster.GrainFactory.GetGrain<IHelloGrain>(Guid.NewGuid());
 
-            var greeting = await helloGrain.SayHello("Rehan");
+            var greeting = await grain.SayHello("Rehan");
 
             Assert.Equal("Hello Rehan!", greeting);
         }