Implemented replica's function ownership method

stidsborg · stidsborg · commit a2fab73b77d8 · 2025-06-12T14:53:01.000+02:00
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/WatchDogsTests/ReplicaWatchdogTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/WatchDogsTests/ReplicaWatchdogTests.cs
@@ -45,4 +45,8 @@ public override Task StrikedOutReplicasFunctionIsPostponedAfterCrash()
     [TestMethod]
     public override Task ReplicaWatchdogUpdatesHeartbeat()
         => ReplicaWatchdogUpdatesHeartbeat(FunctionStoreFactory.Create());
+
+    [TestMethod]
+    public override Task WorkIsDividedBetweenReplicas()
+        => WorkIsDividedBetweenReplicas(FunctionStoreFactory.Create());
 }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/ReplicaWatchdogTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/ReplicaWatchdogTests.cs
@@ -168,11 +168,11 @@ public async Task ReplicaIdOffsetIfCalculatedCorrectly(Task<IFunctionStore> stor
         await watchdog3.Initialize();
         
         await watchdog3.PerformIteration();
-        replicaId3.Offset.ShouldBe(2);
+        replicaId3.Offset.ShouldBe((ulong) 2);
         await watchdog2.PerformIteration();
-        replicaId2.Offset.ShouldBe(1);
+        replicaId2.Offset.ShouldBe((ulong) 1);
         await watchdog1.PerformIteration();
-        replicaId1.Offset.ShouldBe(0);
+        replicaId1.Offset.ShouldBe((ulong) 0);
     }
     
     public abstract Task ReplicaIdOffsetIsUpdatedWhenNodeIsAddedAndDeleted();
@@ -190,38 +190,38 @@ public async Task ReplicaIdOffsetIsUpdatedWhenNodeIsAddedAndDeleted(Task<IFuncti
         var watchdog3 = new ReplicaWatchdog(cluster3, functionStore, checkFrequency: TimeSpan.FromHours(1), default(UnhandledExceptionHandler)!);
 
         await watchdog3.Initialize();
-        cluster3.Offset.ShouldBe(0);
-        cluster3.ReplicaCount.ShouldBe(1);
+        cluster3.Offset.ShouldBe((ulong) 0);
+        cluster3.ReplicaCount.ShouldBe((ulong) 1);
 
         await watchdog2.Initialize();
         await watchdog3.PerformIteration();
-        cluster3.Offset.ShouldBe(1);
-        cluster3.ReplicaCount.ShouldBe(2);
-        cluster2.Offset.ShouldBe(0);
-        cluster2.ReplicaCount.ShouldBe(2);
+        cluster3.Offset.ShouldBe((ulong) 1);
+        cluster3.ReplicaCount.ShouldBe((ulong) 2);
+        cluster2.Offset.ShouldBe((ulong) 0);
+        cluster2.ReplicaCount.ShouldBe((ulong) 2);
         
         await watchdog1.Initialize();
         await watchdog2.PerformIteration();
         await watchdog3.PerformIteration();
-        cluster3.Offset.ShouldBe(2);
-        cluster3.ReplicaCount.ShouldBe(3);
-        cluster2.Offset.ShouldBe(1);
-        cluster2.ReplicaCount.ShouldBe(3);
-        cluster1.Offset.ShouldBe(0);
-        cluster1.ReplicaCount.ShouldBe(3);
+        cluster3.Offset.ShouldBe((ulong) 2);
+        cluster3.ReplicaCount.ShouldBe((ulong) 3);
+        cluster2.Offset.ShouldBe((ulong) 1);
+        cluster2.ReplicaCount.ShouldBe((ulong) 3);
+        cluster1.Offset.ShouldBe((ulong) 0);
+        cluster1.ReplicaCount.ShouldBe((ulong) 3);
 
         await store.Delete(cluster1.ReplicaId);
         await watchdog3.PerformIteration();
         await watchdog2.PerformIteration();
-        cluster3.Offset.ShouldBe(1);
-        cluster3.ReplicaCount.ShouldBe(2);
-        cluster2.Offset.ShouldBe(0);
-        cluster2.ReplicaCount.ShouldBe(2);
+        cluster3.Offset.ShouldBe((ulong) 1);
+        cluster3.ReplicaCount.ShouldBe((ulong) 2);
+        cluster2.Offset.ShouldBe((ulong) 0);
+        cluster2.ReplicaCount.ShouldBe((ulong) 2);
         
         await store.Delete(cluster2.ReplicaId);
         await watchdog3.PerformIteration();
-        cluster3.Offset.ShouldBe(0);
-        cluster3.ReplicaCount.ShouldBe(1);
+        cluster3.Offset.ShouldBe((ulong) 0);
+        cluster3.ReplicaCount.ShouldBe((ulong) 1);
     }
     
     public abstract Task ActiveReplicasDoNotDeleteEachOther();
@@ -328,4 +328,35 @@ public async Task ReplicaWatchdogUpdatesHeartbeat(Task<IFunctionStore> storeTask
         storedReplicas.Single().Heartbeat.ShouldBeGreaterThan(1);
 
     }
+    
+    public abstract Task WorkIsDividedBetweenReplicas();
+    public Task WorkIsDividedBetweenReplicas(Task<IFunctionStore> storeTask)
+    {
+        var replicaId1 = ReplicaId.NewId();
+        var clusterInfo = new ClusterInfo(replicaId1)
+        {
+            ReplicaCount = 3
+        };
+
+        var storedIds = Enumerable
+            .Range(0, 10)
+            .Select(i => new StoredId(new StoredType(0), i.ToString().ToStoredInstance()))
+            .ToList();
+
+        //offset 0
+        var owned = storedIds.Select(clusterInfo.OwnedByThisReplica).ToList();
+        owned.Any().ShouldBeTrue();
+        
+        //offset 1
+        clusterInfo.Offset = 1;
+        owned = storedIds.Select(clusterInfo.OwnedByThisReplica).ToList();
+        owned.Any().ShouldBeTrue();
+        
+        //offset 2
+        clusterInfo.Offset = 2;
+        owned = storedIds.Select(clusterInfo.OwnedByThisReplica).ToList();
+        owned.Any().ShouldBeTrue();
+        
+        return Task.CompletedTask;
+    }
 }
diff --git a/Core/Cleipnir.ResilientFunctions/CoreRuntime/Watchdogs/ReplicaWatchdog.cs b/Core/Cleipnir.ResilientFunctions/CoreRuntime/Watchdogs/ReplicaWatchdog.cs
@@ -46,8 +46,8 @@ public async Task Initialize()
         foreach (var crashedReplicaId in crashedReplicas)
             await functionStore.RescheduleCrashedFunctions(crashedReplicaId);
         
-        clusterInfo.ReplicaCount = replicas.Count;
-        clusterInfo.Offset = offset.Value;
+        clusterInfo.ReplicaCount = (ulong) replicas.Count;
+        clusterInfo.Offset = (ulong) offset.Value;
         _initialized = true;
     }
 
@@ -77,8 +77,8 @@ public async Task PerformIteration()
 
         if (offset is not null)
         {
-            clusterInfo.Offset = offset.Value;
-            clusterInfo.ReplicaCount = storedReplicas.Count;
+            clusterInfo.Offset = (ulong) offset.Value;
+            clusterInfo.ReplicaCount = (ulong) storedReplicas.Count;
         }
         else
         {
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/ClusterInfo.cs b/Core/Cleipnir.ResilientFunctions/Domain/ClusterInfo.cs
@@ -1,13 +1,17 @@
-﻿using System.Threading;
+﻿using System;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using Cleipnir.ResilientFunctions.Storage;
 
 namespace Cleipnir.ResilientFunctions.Domain;
 
 public class ClusterInfo
 {
     public ReplicaId ReplicaId { get; }
 
-    private int _offset;
-    public int Offset
+    private ulong _offset;
+    public ulong Offset
     {
         get
         {
@@ -21,8 +25,8 @@ internal set
         }
     }
 
-    private int _replicaCount;
-    public int ReplicaCount
+    private ulong _replicaCount;
+    public ulong ReplicaCount
     {
         get
         {
@@ -39,4 +43,14 @@ internal set
     private readonly Lock _sync = new();
 
     public ClusterInfo(ReplicaId replicaId) => ReplicaId = replicaId;
+
+    public bool OwnedByThisReplica(StoredId storedId)
+    {
+        var serializedStoredId = storedId.Serialize();
+        using SHA256 sha256 = SHA256.Create();
+        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(serializedStoredId));
+        var number = BitConverter.ToUInt64(hashBytes);
+        var owner = number % ReplicaCount;
+        return Offset == owner;
+    }
 }
diff --git a/Stores/MariaDB/Cleipnir.ResilientFunctions.MariaDB.Tests/WatchDogsTests/ReplicaWatchdogTests.cs b/Stores/MariaDB/Cleipnir.ResilientFunctions.MariaDB.Tests/WatchDogsTests/ReplicaWatchdogTests.cs
@@ -45,4 +45,8 @@ public override Task StrikedOutReplicasFunctionIsPostponedAfterCrash()
     [TestMethod]
     public override Task ReplicaWatchdogUpdatesHeartbeat()
         => ReplicaWatchdogUpdatesHeartbeat(FunctionStoreFactory.Create());
+    
+    [TestMethod]
+    public override Task WorkIsDividedBetweenReplicas()
+        => WorkIsDividedBetweenReplicas(FunctionStoreFactory.Create());
 }
diff --git a/Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL.Tests/WatchDogsTests/ReplicaWatchdogTests.cs b/Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL.Tests/WatchDogsTests/ReplicaWatchdogTests.cs
@@ -45,4 +45,8 @@ public override Task StrikedOutReplicasFunctionIsPostponedAfterCrash()
     [TestMethod]
     public override Task ReplicaWatchdogUpdatesHeartbeat()
         => ReplicaWatchdogUpdatesHeartbeat(FunctionStoreFactory.Create());
+    
+    [TestMethod]
+    public override Task WorkIsDividedBetweenReplicas()
+        => WorkIsDividedBetweenReplicas(FunctionStoreFactory.Create());
 }
diff --git a/Stores/SqlServer/Cleipnir.ResilientFunctions.SqlServer.Tests/WatchDogsTests/ReplicaWatchdogTests.cs b/Stores/SqlServer/Cleipnir.ResilientFunctions.SqlServer.Tests/WatchDogsTests/ReplicaWatchdogTests.cs
@@ -45,4 +45,8 @@ public override Task StrikedOutReplicasFunctionIsPostponedAfterCrash()
     [TestMethod]
     public override Task ReplicaWatchdogUpdatesHeartbeat()
         => ReplicaWatchdogUpdatesHeartbeat(FunctionStoreFactory.Create());
+    
+    [TestMethod]
+    public override Task WorkIsDividedBetweenReplicas()
+        => WorkIsDividedBetweenReplicas(FunctionStoreFactory.Create());
 }

Original file line number	Diff line number	Diff line change
`@@ -45,4 +45,8 @@ public override Task StrikedOutReplicasFunctionIsPostponedAfterCrash()`
`45`	`45`	`[TestMethod]`
`46`	`46`	`public override Task ReplicaWatchdogUpdatesHeartbeat()`
`47`	`47`	`=> ReplicaWatchdogUpdatesHeartbeat(FunctionStoreFactory.Create());`
	`48`	`+`
	`49`	`+ [TestMethod]`
	`50`	`+ public override Task WorkIsDividedBetweenReplicas()`
	`51`	`+ => WorkIsDividedBetweenReplicas(FunctionStoreFactory.Create());`
`48`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,8 @@ public async Task Initialize()`
`46`	`46`	`foreach (var crashedReplicaId in crashedReplicas)`
`47`	`47`	`await functionStore.RescheduleCrashedFunctions(crashedReplicaId);`
`48`	`48`
`49`		`- clusterInfo.ReplicaCount = replicas.Count;`
`50`		`- clusterInfo.Offset = offset.Value;`
	`49`	`+ clusterInfo.ReplicaCount = (ulong) replicas.Count;`
	`50`	`+ clusterInfo.Offset = (ulong) offset.Value;`
`51`	`51`	`_initialized = true;`
`52`	`52`	`}`
`53`	`53`
`@@ -77,8 +77,8 @@ public async Task PerformIteration()`
`77`	`77`
`78`	`78`	`if (offset is not null)`
`79`	`79`	`{`
`80`		`- clusterInfo.Offset = offset.Value;`
`81`		`- clusterInfo.ReplicaCount = storedReplicas.Count;`
	`80`	`+ clusterInfo.Offset = (ulong) offset.Value;`
	`81`	`+ clusterInfo.ReplicaCount = (ulong) storedReplicas.Count;`
`82`	`82`	`}`
`83`	`83`	`else`
`84`	`84`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,17 @@`
`1`		`-using System.Threading;`
	`1`	`+using System;`
	`2`	`+using System.Security.Cryptography;`
	`3`	`+using System.Text;`
	`4`	`+using System.Threading;`
	`5`	`+using Cleipnir.ResilientFunctions.Storage;`
`2`	`6`
`3`	`7`	`namespace Cleipnir.ResilientFunctions.Domain;`
`4`	`8`
`5`	`9`	`public class ClusterInfo`
`6`	`10`	`{`
`7`	`11`	`public ReplicaId ReplicaId { get; }`
`8`	`12`
`9`		`- private int _offset;`
`10`		`- public int Offset`
	`13`	`+ private ulong _offset;`
	`14`	`+ public ulong Offset`
`11`	`15`	`{`
`12`	`16`	`get`
`13`	`17`	`{`
`@@ -21,8 +25,8 @@ internal set`
`21`	`25`	`}`
`22`	`26`	`}`
`23`	`27`
`24`		`- private int _replicaCount;`
`25`		`- public int ReplicaCount`
	`28`	`+ private ulong _replicaCount;`
	`29`	`+ public ulong ReplicaCount`
`26`	`30`	`{`
`27`	`31`	`get`
`28`	`32`	`{`
`@@ -39,4 +43,14 @@ internal set`
`39`	`43`	`private readonly Lock _sync = new();`
`40`	`44`
`41`	`45`	`public ClusterInfo(ReplicaId replicaId) => ReplicaId = replicaId;`
	`46`	`+`
	`47`	`+ public bool OwnedByThisReplica(StoredId storedId)`
	`48`	`+ {`
	`49`	`+ var serializedStoredId = storedId.Serialize();`
	`50`	`+ using SHA256 sha256 = SHA256.Create();`
	`51`	`+ var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(serializedStoredId));`
	`52`	`+ var number = BitConverter.ToUInt64(hashBytes);`
	`53`	`+ var owner = number % ReplicaCount;`
	`54`	`+ return Offset == owner;`
	`55`	`+ }`
`42`	`56`	`}`