refactor: simplify cluster manifest local silo handling

Remove synchronous local silo insertion from the cluster manifest provider and let the standard manifest fetch path populate all active silos.

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

Author: ReubenBond

src/Orleans.Runtime/Manifest/ClusterManifestProvider.cs

@@ -16,7 +16,6 @@ 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;
@@ -33,14 +32,12 @@ 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;
@@ -70,7 +67,7 @@ private ClusterManifest EnsureCurrentManifestVersion(ClusterMembershipSnapshot c
                 return current;
             }
 
-            var synchronizedSilos = ApplySynchronousMembershipChanges(current.Silos, clusterMembership, out var modified);
+            var synchronizedSilos = RemoveNonActiveSilos(current.Silos, clusterMembership, out var modified);
             if (current.Version.Major == membershipVersion && !modified)
             {
                 return current;
@@ -84,7 +81,7 @@ private ClusterManifest EnsureCurrentManifestVersion(ClusterMembershipSnapshot c
                     return current;
                 }
 
-                synchronizedSilos = ApplySynchronousMembershipChanges(current.Silos, clusterMembership, out modified);
+                synchronizedSilos = RemoveNonActiveSilos(current.Silos, clusterMembership, out modified);
                 if (current.Version.Major == membershipVersion && !modified)
                 {
                     return current;
@@ -190,20 +187,14 @@ private async Task<bool> UpdateManifest(ClusterMembershipSnapshot clusterMembers
                     continue;
                 }
 
-                if (siloAddress.Equals(_localSiloAddress))
-                {
-                    // Local membership changes are applied synchronously by EnsureCurrentManifestVersion.
-                    continue;
-                }
-
                 tasks.Add(GetManifest(siloAddress));
             }
 
             async Task<(SiloAddress Key, GrainManifest? Value, Exception? Exception)> GetManifest(SiloAddress siloAddress)
             {
                 try
                 {
-                    // Get the manifest from the remote silo.
+                    // Get the manifest from the silo.
                     var remoteManifestProvider = _grainFactory!.GetSystemTarget<ISiloManifestSystemTarget>(Constants.ManifestProviderType, siloAddress);
                     var manifest = await remoteManifestProvider.GetSiloManifest().AsTask().WaitAsync(_shutdownCts.Token);
                     return (siloAddress, manifest, null);
@@ -253,7 +244,7 @@ private ClusterManifest CreateClusterManifest(
             MajorMinorVersion version,
             ImmutableDictionary<SiloAddress, GrainManifest> silos)
         {
-            return new ClusterManifest(version, silos, [.. silos.Values, LocalGrainManifest]);
+            return new ClusterManifest(version, silos, [LocalGrainManifest]);
         }
 
         private bool TryPublishManifest(ClusterManifest manifest)
@@ -267,21 +258,6 @@ private bool TryPublishManifest(ClusterManifest manifest)
             return publishSuccess;
         }
 
-        private ImmutableDictionary<SiloAddress, GrainManifest> ApplySynchronousMembershipChanges(
-            ImmutableDictionary<SiloAddress, GrainManifest> silos,
-            ClusterMembershipSnapshot clusterMembership,
-            out bool modified)
-        {
-            silos = RemoveNonActiveSilos(silos, clusterMembership, out modified);
-            if (clusterMembership.GetSiloStatus(_localSiloAddress) != SiloStatus.Active || silos.ContainsKey(_localSiloAddress))
-            {
-                return silos;
-            }
-
-            modified = true;
-            return silos.Add(_localSiloAddress, LocalGrainManifest);
-        }
-
         private static ImmutableDictionary<SiloAddress, GrainManifest> RemoveNonActiveSilos(
             ImmutableDictionary<SiloAddress, GrainManifest> silos,
             ClusterMembershipSnapshot clusterMembership,

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

@@ -103,8 +103,11 @@ public async Task Current_WhenRemoteSiloBecomesActive_PublishesPrunedManifestBef
         var grainFactory = CreateGrainFactory(remoteSilo, remoteManifest);
         var provider = CreateClusterManifestProvider(localSilo, membership, grainFactory);
 
-        Assert.Equal(new MajorMinorVersion(1, 0), provider.Current.Version);
-        Assert.DoesNotContain(remoteSilo, provider.Current.Silos.Keys);
+        var current = provider.Current;
+        Assert.Equal(new MajorMinorVersion(1, 0), current.Version);
+        Assert.DoesNotContain(localSilo, current.Silos.Keys);
+        Assert.DoesNotContain(remoteSilo, current.Silos.Keys);
+        Assert.Contains(provider.LocalGrainManifest, current.AllGrainManifests);
 
         membership.Update(CreateMembershipSnapshot(
             2,
@@ -113,6 +116,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.DoesNotContain(remoteSilo, pruned.Silos.Keys);
 
         var lifecycle = await StartAsync(provider);
@@ -170,16 +174,17 @@ private static ClusterManifestProvider CreateClusterManifestProvider(
         TestClusterMembershipService membership,
         IInternalGrainFactory grainFactory)
     {
-        var localSiloDetails = Substitute.For<ILocalSiloDetails>();
-        localSiloDetails.SiloAddress.Returns(localSilo);
+        var siloManifestProvider = CreateSiloManifestProvider();
+        grainFactory
+            .GetSystemTarget<ISiloManifestSystemTarget>(Constants.ManifestProviderType, localSilo)
+            .Returns(new TestSiloManifestSystemTarget(siloManifestProvider.SiloManifest));
 
         var services = new ServiceCollection()
             .AddSingleton(grainFactory)
             .BuildServiceProvider();
 
         return new ClusterManifestProvider(
-            localSiloDetails,
-            CreateSiloManifestProvider(),
+            siloManifestProvider,
             membership,
             Substitute.For<IFatalErrorHandler>(),
             NullLogger<ClusterManifestProvider>.Instance,