fix: include active local silo in manifest

Synchronously add the local silo manifest when advancing to a membership version where the local silo is active.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ReubenBond

src/Orleans.Runtime/Manifest/ClusterManifestProvider.cs

@@ -16,6 +16,7 @@ namespace Orleans.Runtime.Metadata
 {
     internal partial class ClusterManifestProvider : IClusterManifestProvider, IAsyncDisposable, IDisposable, ILifecycleParticipant<ISiloLifecycle>
     {
+        private readonly SiloAddress _localSiloAddress;
         private readonly ILogger<ClusterManifestProvider> _logger;
         private readonly IServiceProvider _services;
         private readonly IClusterMembershipService _clusterMembershipService;
@@ -32,12 +33,14 @@ internal partial class ClusterManifestProvider : IClusterManifestProvider, IAsyn
         private Task? _runTask;
 
         public ClusterManifestProvider(
+            ILocalSiloDetails localSiloDetails,
             SiloManifestProvider siloManifestProvider,
             IClusterMembershipService clusterMembershipService,
             IFatalErrorHandler fatalErrorHandler,
             ILogger<ClusterManifestProvider> logger,
             IServiceProvider services)
         {
+            _localSiloAddress = localSiloDetails.SiloAddress;
             _logger = logger;
             _services = services;
             _clusterMembershipService = clusterMembershipService;
@@ -52,13 +55,13 @@ public ClusterManifestProvider(
                 onPublished: update => Interlocked.Exchange(ref _current, update));
         }
 
-        public ClusterManifest Current => EnsureCurrentManifestVersion(_clusterMembershipService.CurrentSnapshot);
+        public ClusterManifest Current => EnsureValidManifestForCurrentMembership(_clusterMembershipService.CurrentSnapshot);
 
         public IAsyncEnumerable<ClusterManifest> Updates => _updates;
 
         public GrainManifest LocalGrainManifest { get; }
 
-        private ClusterManifest EnsureCurrentManifestVersion(ClusterMembershipSnapshot clusterMembership)
+        private ClusterManifest EnsureValidManifestForCurrentMembership(ClusterMembershipSnapshot clusterMembership)
         {
             var current = _current;
             var membershipVersion = clusterMembership.Version.Value;
@@ -76,6 +79,12 @@ private ClusterManifest EnsureCurrentManifestVersion(ClusterMembershipSnapshot c
                 }
 
                 var synchronizedSilos = RemoveNonActiveSilos(current.Silos, clusterMembership);
+                if (clusterMembership.GetSiloStatus(_localSiloAddress) == SiloStatus.Active
+                    && !synchronizedSilos.ContainsKey(_localSiloAddress))
+                {
+                    synchronizedSilos = synchronizedSilos.Add(_localSiloAddress, LocalGrainManifest);
+                }
+
                 var version = new MajorMinorVersion(membershipVersion, 0);
                 var updated = CreateClusterManifest(version, synchronizedSilos);
                 TryPublishManifest(updated);
@@ -147,7 +156,7 @@ private async Task ProcessMembershipUpdates()
 
         private async Task<bool> UpdateManifest(ClusterMembershipSnapshot clusterMembership)
         {
-            var existingManifest = EnsureCurrentManifestVersion(clusterMembership);
+            var existingManifest = EnsureValidManifestForCurrentMembership(clusterMembership);
             if (existingManifest.Version.Major > clusterMembership.Version.Value)
             {
                 return true;

test/Orleans.Core.Tests/Manifest/ClusterManifestProviderTests.cs

@@ -53,6 +53,29 @@ public void Current_WhenLocalSiloIsNotActive_ResolvesTypeFromLocalManifest()
         Assert.Equal(TestGrainType, typeResolver.GetGrainType(TestInterfaceType));
     }
 
+    [Fact]
+    public void Current_WhenLocalSiloBecomesActive_IncludesLocalManifestSynchronously()
+    {
+        var localSilo = CreateSiloAddress(11111, 1);
+        using var membership = new TestClusterMembershipService(CreateMembershipSnapshot(
+            1,
+            (localSilo, SiloStatus.Created)));
+        var grainFactory = CreateGrainFactory(CreateSiloAddress(11112, 1), CreateGrainManifest());
+        var provider = CreateClusterManifestProvider(localSilo, membership, grainFactory);
+
+        Assert.DoesNotContain(localSilo, provider.Current.Silos.Keys);
+
+        membership.Update(CreateMembershipSnapshot(
+            2,
+            (localSilo, SiloStatus.Active)));
+
+        var current = provider.Current;
+
+        Assert.Equal(new MajorMinorVersion(2, 0), current.Version);
+        Assert.Contains(localSilo, current.Silos.Keys);
+        Assert.Contains(provider.LocalGrainManifest, current.AllGrainManifests);
+    }
+
     [Fact]
     public async Task Current_WhenMembershipVersionAdvances_PrunesNonActiveSilosAtFirstMinorVersion()
     {
@@ -91,7 +114,7 @@ public async Task Current_WhenMembershipVersionAdvances_PrunesNonActiveSilosAtFi
     }
 
     [Fact]
-    public async Task Current_WhenRemoteSiloBecomesActive_PublishesPrunedManifestBeforeRemoteFetch()
+    public async Task Current_WhenRemoteSiloBecomesActive_IncludesLocalManifestBeforeRemoteFetch()
     {
         var localSilo = CreateSiloAddress(11111, 1);
         var remoteSilo = CreateSiloAddress(11112, 1);
@@ -105,7 +128,7 @@ public async Task Current_WhenRemoteSiloBecomesActive_PublishesPrunedManifestBef
 
         var current = provider.Current;
         Assert.Equal(new MajorMinorVersion(1, 0), current.Version);
-        Assert.DoesNotContain(localSilo, current.Silos.Keys);
+        Assert.Contains(localSilo, current.Silos.Keys);
         Assert.DoesNotContain(remoteSilo, current.Silos.Keys);
         Assert.Contains(provider.LocalGrainManifest, current.AllGrainManifests);
 
@@ -116,7 +139,7 @@ public async Task Current_WhenRemoteSiloBecomesActive_PublishesPrunedManifestBef
 
         var pruned = provider.Current;
         Assert.Equal(new MajorMinorVersion(2, 0), pruned.Version);
-        Assert.DoesNotContain(localSilo, pruned.Silos.Keys);
+        Assert.Contains(localSilo, pruned.Silos.Keys);
         Assert.DoesNotContain(remoteSilo, pruned.Silos.Keys);
 
         var lifecycle = await StartAsync(provider);
@@ -183,7 +206,11 @@ private static ClusterManifestProvider CreateClusterManifestProvider(
             .AddSingleton(grainFactory)
             .BuildServiceProvider();
 
+        var localSiloDetails = Substitute.For<ILocalSiloDetails>();
+        localSiloDetails.SiloAddress.Returns(localSilo);
+
         return new ClusterManifestProvider(
+            localSiloDetails,
             siloManifestProvider,
             membership,
             Substitute.For<IFatalErrorHandler>(),