Get back the localhost clustering after bugfix from orleans team.

src/Squidex.Domain.Apps.Entities/AppProvider.cs

@@ -88,7 +88,7 @@ namespace Squidex.Domain.Apps.Entities
         {
             return localCache.GetOrCreateAsync($"GetSchemaAsync({appId}, {name})", async () =>
             {
-                using (Profiler.TraceMethod<AppProvider>())
+                using (Profiler.TraceMethod<AppProvider>("GetSchemaAsyncByName"))
                 {
                     var schemaId = await GetSchemaIdAsync(appId, name);
 
@@ -106,7 +106,7 @@ namespace Squidex.Domain.Apps.Entities
         {
             return localCache.GetOrCreateAsync($"GetSchemaAsync({appId}, {id}, {allowDeleted})", async () =>
             {
-                using (Profiler.TraceMethod<AppProvider>())
+                using (Profiler.TraceMethod<AppProvider>("GetSchemaAsyncById"))
                 {
                     var schema = await grainFactory.GetGrain<ISchemaGrain>(id).GetStateAsync();
 

src/Squidex/Config/Constants.cs

@@ -17,6 +17,8 @@ namespace Squidex.Config
 
         public static readonly string ApiScope = "squidex-api";
 
+        public static readonly string OrleansClusterId = "squidex";
+
         public static readonly string OrleansPrefix = "/orleans";
 
         public static readonly string PortalPrefix = "/portal";

src/Squidex/Config/Orleans/ClientWrapper.cs

@@ -24,14 +24,11 @@ namespace Squidex.Config.Orleans
         {
             Client = new ClientBuilder()
                 .UseDashboard()
-                .UseStaticClustering(options =>
+                .UseLocalhostClustering(40000)
-                {
-                    options.Gateways.Add(new IPEndPoint(ConfigUtilities.SiloAddress, 40000).ToGatewayUri());
-                })
                 .Configure<ClusterOptions>(options =>
                 {
-                    options.ClusterId = "squidex";
+                    options.ClusterId = Constants.OrleansClusterId;
-                    options.ServiceId = "squidex";
+                    options.ServiceId = Constants.OrleansClusterId;
                 })
                 .ConfigureServices((context, services) =>
                 {

src/Squidex/Config/Orleans/ConfigUtilities.cs

@@ -1,130 +0,0 @@
-// ==========================================================================
-//  Squidex Headless CMS
-// ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschraenkt)
-//  All rights reserved. Licensed under the MIT license.
-// ==========================================================================
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Net.NetworkInformation;
-using System.Net.Sockets;
-using System.Threading.Tasks;
-using Orleans.Runtime;
-
-namespace Squidex.Config.Orleans
-{
-    public static class ConfigUtilities
-    {
-        public static IPAddress SiloAddress { get; } = GetBestIPAddressAsync().Result;
-
-        private static Task<IPAddress> GetBestIPAddressAsync()
-        {
-            return ResolveIPAddressAsync(Dns.GetHostName(), null, AddressFamily.InterNetwork);
-        }
-
-        internal static async Task<IPAddress> ResolveIPAddressAsync(string addressOrHost, byte[] subnet, AddressFamily family)
-        {
-            var loopback = family == AddressFamily.InterNetwork ? IPAddress.Loopback : IPAddress.IPv6Loopback;
-
-            IList<IPAddress> nodeIps;
-
-            if (string.IsNullOrEmpty(addressOrHost))
-            {
-                nodeIps =
-                    NetworkInterface.GetAllNetworkInterfaces()
-                        .SelectMany(i => i.GetIPProperties().UnicastAddresses)
-                        .Select(a => a.Address)
-                        .Where(a => a.AddressFamily == family && !IPAddress.IsLoopback(a))
-                        .ToList();
-            }
-            else
-            {
-                if (addressOrHost.Equals("loopback", StringComparison.OrdinalIgnoreCase))
-                {
-                    return loopback;
-                }
-
-                if (IPAddress.TryParse(addressOrHost, out IPAddress address))
-                {
-                    return address;
-                }
-
-                nodeIps = await Dns.GetHostAddressesAsync(addressOrHost);
-            }
-
-            var candidates = new List<IPAddress>();
-
-            foreach (var nodeIp in nodeIps.Where(x => x.AddressFamily == family))
-            {
-                if (subnet == null)
-                {
-                    candidates.Add(nodeIp);
-                }
-                else
-                {
-                    var ip = nodeIp;
-
-                    if (subnet.Select((b, i) => ip.GetAddressBytes()[i] == b).All(x => x))
-                    {
-                        candidates.Add(nodeIp);
-                    }
-                }
-            }
-
-            if (candidates.Count > 0)
-            {
-                return PickIPAddress(candidates);
-            }
-
-            var subnetStr = Utils.EnumerableToString(subnet, null, ".", false);
-
-            throw new ArgumentException($"Hostname '{addressOrHost}' with subnet {subnetStr} and family {family} is not a valid IP address or DNS name");
-        }
-
-        internal static IPAddress PickIPAddress(IReadOnlyList<IPAddress> candidates)
-        {
-            IPAddress result = null;
-
-            foreach (IPAddress address in candidates)
-            {
-                if (result == null)
-                {
-                    result = address;
-                }
-                else
-                {
-                    if (CompareIPAddresses(address, result))
-                    {
-                        result = address;
-                    }
-                }
-            }
-
-            return result;
-        }
-
-        private static bool CompareIPAddresses(IPAddress lhs, IPAddress rhs)
-        {
-            var lbytes = lhs.GetAddressBytes();
-            var rbytes = rhs.GetAddressBytes();
-
-            if (lbytes.Length != rbytes.Length)
-            {
-                return lbytes.Length < rbytes.Length;
-            }
-
-            for (int i = 0; i < lbytes.Length; i++)
-            {
-                if (lbytes[i] != rbytes[i])
-                {
-                    return lbytes[i] < rbytes[i];
-                }
-            }
-
-            return false;
-        }
-    }
-}

src/Squidex/Config/Orleans/SiloWrapper.cs

@@ -6,6 +6,7 @@
 // ==========================================================================
 
 using System;
+using System.Net;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -66,8 +67,8 @@ namespace Squidex.Config.Orleans
                     })
                     .Configure<ClusterOptions>(options =>
                     {
-                        options.ClusterId = "squidex";
+                        options.ClusterId = Constants.OrleansClusterId;
-                        options.ServiceId = "squidex";
+                        options.ServiceId = Constants.OrleansClusterId;
                     })
                     .ConfigureLogging((hostingContext, builder) =>
                     {
@@ -102,7 +103,7 @@ namespace Squidex.Config.Orleans
                 {
                     ["MongoDB"] = () =>
                     {
-                        hostBuilder.ConfigureEndpoints(ConfigUtilities.SiloAddress, 11111, 40000, true);
+                        hostBuilder.ConfigureEndpoints(Dns.GetHostName(), 11111, 40000, listenOnAnyHostAddress: true);
 
                         var mongoConfiguration = config.GetRequiredValue("store:mongoDb:configuration");
                         var mongoDatabaseName = config.GetRequiredValue("store:mongoDb:database");
@@ -116,7 +117,7 @@ namespace Squidex.Config.Orleans
                     },
                     ["Development"] = () =>
                     {
-                        hostBuilder.UseLocalhostClustering(gatewayPort: 40000, clusterId: "squidex");
+                        hostBuilder.UseLocalhostClustering(gatewayPort: 40000, serviceId: Constants.OrleansClusterId, clusterId: Constants.OrleansClusterId);
                         hostBuilder.Configure<ClusterMembershipOptions>(options => options.ExpectedClusterSize = 1);
                     }
                 });