/// <summary>
/// Create a local connect only ClientBuilder
/// </summary>
/// <param name="gatewayPort"></param>
/// <param name="serviceId"></param>
/// <param name="clusterId"></param>
/// <param name="applicationPartTypes">Application parts (optional)</param>
/// <returns></returns>
public static IClientBuilder CreateLocalhostClientBuilder(
int gatewayPort = 30000,
string clusterId = "dev",
string serviceId = "dev",
IEnumerable <Type> applicationPartTypes = null)
{
var clientBuilder = new ClientBuilder()
.Configure <StatisticsOptions>(options =>
{
options.CollectionLevel = StatisticsLevel.Critical;
})
.UseLocalhostClustering(gatewayPort, serviceId, clusterId);
if (applicationPartTypes != null)
{
clientBuilder.ConfigureApplicationParts(manager =>
{
foreach (var applicationPartType in applicationPartTypes)
{
manager.AddApplicationPart(applicationPartType.Assembly).WithReferences();
}
});
}
return(clientBuilder);
}
public static IClusterClient Initialize(ClientConfiguration config, int initializeAttemptsBeforeFailing = 5)
{
var attempt = 0;
IClusterClient client = null;
while (attempt < initializeAttemptsBeforeFailing)
{
try
{
var builder = new ClientBuilder().ConfigureAppConfiguration();
builder.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory());
client = builder.Build();
client.Connect().Wait();
break;
}
catch (Exception ex) when(ex is AggregateException || ex is SiloUnavailableException)
{
attempt++;
Console.WriteLine($"Attempt {attempt} of {initializeAttemptsBeforeFailing} failed to initialize the Orleans client.");
if (attempt > initializeAttemptsBeforeFailing)
{
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(2));
}
attempt++;
}
return(client);
}
/// <summary>
/// Initialize Static Route ClientBuilder
/// </summary>
/// <param name="clusterInfo"></param>
/// <param name="staticGatewayOption"></param>
/// <param name="applicationPartTypes">Application parts (optional)</param>
/// <returns></returns>
public static IClientBuilder CreateStaticRouteClientBuilder(
ClusterInfoOption clusterInfo,
StaticGatewayListProviderOptions staticGatewayOption,
IEnumerable <Type> applicationPartTypes = null)
{
var clientBuilder = new ClientBuilder()
.ConfigureCluster(clusterInfo, TimeSpan.FromSeconds(20), TimeSpan.FromMinutes(60))
.Configure <StatisticsOptions>(options =>
{
options.CollectionLevel = StatisticsLevel.Critical;
})
.UseStaticClustering(option =>
{
option.Gateways = staticGatewayOption.Gateways;
});
if (applicationPartTypes != null)
{
clientBuilder.ConfigureApplicationParts(manager =>
{
foreach (var applicationPartType in applicationPartTypes)
{
manager.AddApplicationPart(applicationPartType.Assembly).WithReferences();
}
});
}
return(clientBuilder);
}
private static async Task <IClusterClient> TryConnect(HostBuilderContext context)
{
IClusterClient client = null;
try
{
var builder = new ClientBuilder();
// TODO get from context.config
builder.UseLocalhostClustering();
// TODO needs config delegates to customize parts
builder.ConfigureApplicationParts(parts =>
{
parts.AddApplicationPart(typeof(IArrayGrain <>).Assembly).WithReferences();
});
client = builder.Build();
// causes host builder to run hosted services???
Console.WriteLine("Awaiting connect request.");
await client.Connect();
}
catch
{
Console.WriteLine("Exception caught.");
client?.Dispose();
throw;
}
return(client);
}
public GraphManager(string connectionString, LoggerType loggers, LogLevel logLevel, string instrumentationKey = null)
{
//use storage provider
var builder = new ClientBuilder();
builder.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IPiSystem).Assembly));
AddStorageProvider(builder, connectionString);
AddAppInsighlts(builder, loggers, instrumentationKey);
AddLoggers(builder, loggers, logLevel, instrumentationKey);
this.client = builder.Build();
this.client.Connect(CreateRetryFilter()).GetAwaiter().GetResult();
}
protected override IEnumerable <ServiceInstanceListener> CreateServiceInstanceListeners()
{
return(new ServiceInstanceListener[]
{
new ServiceInstanceListener(serviceContext =>
new KestrelCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
{
ServiceEventSource.Current.ServiceMessage(serviceContext, $"Starting Kestrel on {url}");
var serviceName = new Uri("fabric:/RWProtoTwo/RiftRunServerService");
var builder = new ClientBuilder();
builder.Configure <ClusterOptions>(options =>
{
options.ServiceId = serviceName.ToString();
options.ClusterId = "RitRunProto";
});
builder.UseAzureStorageClustering(options => options.ConnectionString = ConnectionString);
builder.ConfigureApplicationParts(parts =>
{
parts.AddFromApplicationBaseDirectory();
});
var client = builder.Build();
ConnectToServer(client);
var accountManager = client.GetGrain <IAccountOrchestrator>("AccountOrchestrator"); //activate Orchestrator
accountManager.CreateAccountOrchestrator();
return new WebHostBuilder()
.UseKestrel()
.ConfigureServices(services =>
{
services.AddSingleton <StatelessServiceContext>(serviceContext);
services.AddSingleton <IClusterClient>(client);
})
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>()
.UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.None)
.UseUrls(url)
.Build();
}))
});
}
private static async Task <IClusterClient> StartClientWithRetries()
{
attempt = 0;
var clientBuilder = new ClientBuilder();
if (_providerInfo.DefaultProvider == "MongoDB")
{
clientBuilder.UseMongoDBClustering(options =>
{
var mongoSetting = _providerInfo.MongoDB.Cluster;
options.ConnectionString = mongoSetting.DbConn;
options.DatabaseName = mongoSetting.DbName;
// see:https://github.com/OrleansContrib/Orleans.Providers.MongoDB/issues/54
options.CollectionPrefix = mongoSetting.CollectionPrefix;
})
.Configure <ClientMessagingOptions>(options => {
options.ResponseTimeout = TimeSpan.FromSeconds(20);
options.ResponseTimeoutWithDebugger = TimeSpan.FromMinutes(60);
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
});
}
clientBuilder.ConfigureApplicationParts(manager =>
{
manager.AddApplicationPart(typeof(IVisitTracker).Assembly).WithReferences();
})
.ConfigureLogging(builder =>
{
builder.AddSerilog(dispose: true);
});
var client = clientBuilder.Build();
await client.Connect(RetryFilter);
Console.WriteLine("Client successfully connect to silo host");
return(client);
}
private async Task <IClusterClient> ConfigurationClusterClient(string serviceId)
{
var clientBuilder = new ClientBuilder();
if (this._environment.EnvironmentName == Environments.Development)
{
clientBuilder.UseLocalhostClustering(serviceId: this._options.ClusterId, clusterId: serviceId.ToLower());
}
else
{
clientBuilder.UseZooKeeperClustering(zooKeeperOptions =>
{
zooKeeperOptions.ConnectionString = this._options.ZooKeeperConnectionString;
});
}
var clusterClient = clientBuilder
//.Configure<ClusterOptions>(options =>
//{
// options.ClusterId = this._options.ClusterId;
// options.ServiceId = serviceId.ToLower();
//})
.ConfigureApplicationParts(part =>
{
part.AddApplicationPart(Assembly.GetExecutingAssembly());
})
.ConfigureServices(service =>
{
service.AddLogger(this._loggingFactory)
.AddMicrosoftLogging()
.AddSingleton(this._mediator);
})
.ConfigureLogging(configure => configure.SetMinimumLevel(this._environment.EnvironmentName == Environments.Development ? LogLevel.Debug : LogLevel.Information))
.Build();
this._logging.Info($"begin connect Orleans client");
await clusterClient.Connect(ex =>
{
return(Task.FromResult(true));
});
this._logging.Info($"OrleansClient:{clusterClient.ToJsonString()}");
return(clusterClient);
}
public IUdfsClusterClient Build(
UdfsClusterClientOptions clusterClientOptions
)
{
var clientBuilder = new ClientBuilder();
// Local or distribute cluster
if (clusterClientOptions.Membership.Enabled)
{
clientBuilder.UseAdoNetClustering(
options =>
{
options.Invariant = clusterClientOptions.Membership.Provider;
options.ConnectionString = clusterClientOptions.Membership.ConnectionString;
}
);
}
else
{
clientBuilder.UseLocalhostClustering();
}
//.ConfigureLogging(logging => logging.AddConsole())
//.UsePerfCounterEnvironmentStatistics()
//.Configure<ClientMessagingOptions>(options => options.ResponseTimeout = TimeSpan.FromSeconds(30))
clientBuilder.Configure <ClusterOptions>(
options =>
{
options.ClusterId = clusterClientOptions.ClusterService.ClusterId;
options.ServiceId = clusterClientOptions.ClusterService.ServiceId;
}
);
// Interfaces
foreach (var item in clusterClientOptions.GrainAssemblies)
{
clientBuilder.ConfigureApplicationParts(parts => parts.AddApplicationPart(item).WithReferences());
}
// Build client
return(new UdfsClusterClient(clusterClientOptions, clientBuilder.Build()));
}
public SerializationTestEnvironment(ClientConfiguration config = null, Action <IClientBuilder> configureClientBuilder = null)
{
if (config == null)
{
config = this.DefaultConfig();
}
var builder = new ClientBuilder()
.ConfigureDefaults()
.ConfigureApplicationParts(
parts => parts
.AddFromApplicationBaseDirectory()
.AddFromAppDomain());
builder.UseConfiguration(config);
builder.ConfigureApplicationParts(parts => parts.AddFromAppDomain().AddFromApplicationBaseDirectory());
configureClientBuilder?.Invoke(builder);
this.Client = builder.Build();
this.RuntimeClient = this.Client.ServiceProvider.GetRequiredService <OutsideRuntimeClient>();
}
IClusterClient Build()
{
using (Trace.Execution("Orleans client initialization"))
{
var builder = new ClientBuilder()
.UseConfiguration(configuration)
.ConfigureServices(services =>
{
services.Add(ServiceDescriptor.Singleton <IActorSystem>(this));
services.Add(ServiceDescriptor.Singleton <IClientActorSystem>(this));
services.Add(ServiceDescriptor.Singleton(this));
di?.Invoke(services);
});
builder.ConfigureApplicationParts(apm => apm
.AddFromAppDomain()
.WithCodeGeneration());
return(builder.Build());
}
}
public static IClusterClient Get(OrleansClientConnectionOptions options)
{
var serviceName = new Uri(options.FabricUrl);
var builder = new ClientBuilder();
builder.Configure <ClusterOptions>(opt =>
{
opt.ServiceId = serviceName.ToString();
opt.ClusterId = options.ClusterId;
});
builder.UseAzureStorageClustering(opt =>
opt.ConnectionString = options.TableStorageConnectionString);
builder.ConfigureApplicationParts(parts =>
parts.AddApplicationPart(typeof(IMyFirstGrain).Assembly));
builder.ConfigureLogging(logging => logging.AddDebug());
var client = builder.Build();
return(client);
}
public static IClusterClient Get(string fabricUrl, string azureStorageConnectionString)
{
var serviceName = new Uri(fabricUrl);
var builder = new ClientBuilder();
builder.Configure <ClusterOptions>(options =>
{
options.ServiceId = serviceName.ToString();
options.ClusterId = "development";
});
builder.UseAzureStorageClustering(options =>
options.ConnectionString = azureStorageConnectionString);
builder.ConfigureApplicationParts(parts =>
parts.AddApplicationPart(typeof(IMyFirstGrain).Assembly));
builder.ConfigureLogging(logging => logging.AddDebug());
var client = builder.Build();
return(client);
}
/// <summary>
/// Initialize a normal Orleans ClientBuilder
/// </summary>
/// <param name="logger">Logger to log ClientBuilder operation information</param>
/// <param name="clusterInfo"></param>
/// <param name="providerOption"></param>
/// <param name="applicationPartTypes">Application parts (optional)</param>
/// <returns></returns>
public static IClientBuilder CreateClientBuilder(ILogger logger,
ClusterInfoOption clusterInfo,
OrleansProviderOption providerOption,
IEnumerable <Type> applicationPartTypes = null)
{
var clientBuilder = new ClientBuilder()
.ConfigureCluster(clusterInfo, TimeSpan.FromSeconds(20), TimeSpan.FromMinutes(60))
.Configure <StatisticsOptions>(options =>
{
options.CollectionLevel = StatisticsLevel.Critical;
});
switch (providerOption.DefaultProvider.ToLower())
{
case "sqldb":
{
logger.LogTrace("Using SQL DB provider");
var sqlDbSetting = providerOption.SQLDB.Cluster;
try
{
var helper = new ExtMethodInvoker("Orleans.Clustering.AdoNet");
var adoNetClusteringClientOptionsType = helper.ExtensionLibAssembly.GetType("Orleans.Configuration.AdoNetClusteringClientOptions", true);
var adoNetClusteringClientOptionsValue = new Dictionary <string, object>
{
["ConnectionString"] = sqlDbSetting.DbConn,
["Invariant"] = sqlDbSetting.Invariant ?? @"System.Data.SqlClient"
};
var configSqlDbClusteringAction =
CreateDelegateHelper.CreateAssignValueAction(adoNetClusteringClientOptionsType, "options", adoNetClusteringClientOptionsValue);
clientBuilder = helper.Invoke <IClientBuilder>(
new ExtMethodInfo {
MethodName = "UseAdoNetClustering", ExtendedType = typeof(IClientBuilder)
},
clientBuilder, configSqlDbClusteringAction);
}
catch (Exception ex)
{
throw new SqlDbLibLoadFailedException(ex);
}
}
break;
case "mysql":
{
logger.LogTrace("Using MySQL DB provider");
var mysqlDbSetting = providerOption.SQLDB.Cluster;
try
{
var helper = new ExtMethodInvoker("Orleans.Clustering.AdoNet");
var adoNetClusteringClientOptionsType = helper.ExtensionLibAssembly.GetType("Orleans.Configuration.AdoNetClusteringClientOptions", true);
var adoNetClusteringClientOptionsValue = new Dictionary <string, object>
{
["ConnectionString"] = mysqlDbSetting.DbConn,
["Invariant"] = mysqlDbSetting.Invariant ?? @"MySql.Data.MySqlClient"
};
var configSqlDbClusteringAction =
CreateDelegateHelper.CreateAssignValueAction(adoNetClusteringClientOptionsType, "options", adoNetClusteringClientOptionsValue);
clientBuilder = helper.Invoke <IClientBuilder>(
new ExtMethodInfo {
MethodName = "UseAdoNetClustering", ExtendedType = typeof(IClientBuilder)
},
clientBuilder, configSqlDbClusteringAction);
}
catch (Exception ex)
{
throw new MySqlLibLoadFailedException(ex);
}
}
break;
case "mongodb":
{
logger.LogTrace("Using MongoDB provider...");
var mongoSetting = providerOption.MongoDB.Cluster;
try
{
var helper = new ExtMethodInvoker("Orleans.Providers.MongoDB");
clientBuilder = helper.Invoke <IClientBuilder>(
new ExtMethodInfo {
MethodName = "UseMongoDBClient", ExtendedType = typeof(IClientBuilder)
},
clientBuilder, mongoSetting.DbConn);
var mongoDbMembershipTableOptionsType =
helper.ExtensionLibAssembly.GetType("Orleans.Providers.MongoDB.Configuration.MongoDBGatewayListProviderOptions", true);
var mongoDbMembershipTableOptionsValue = new Dictionary <string, object>
{
["DatabaseName"] = mongoSetting.DbName
};
if (!string.IsNullOrEmpty(mongoSetting.CollectionPrefix))
{
mongoDbMembershipTableOptionsValue["CollectionPrefix"] = mongoSetting.CollectionPrefix;
}
var configMongoDbClusteringAction =
CreateDelegateHelper.CreateAssignValueAction(mongoDbMembershipTableOptionsType, "options", mongoDbMembershipTableOptionsValue);
clientBuilder = helper.Invoke <IClientBuilder>(
new ExtMethodInfo {
MethodName = "UseMongoDBClustering", ExtendedType = typeof(IClientBuilder)
},
clientBuilder, configMongoDbClusteringAction);
}
catch (Exception ex)
{
throw new MongoDbLibLoadFailedException(ex);
}
}
break;
}
if (applicationPartTypes != null)
{
clientBuilder.ConfigureApplicationParts(manager =>
{
foreach (var applicationPartType in applicationPartTypes)
{
manager.AddApplicationPart(applicationPartType.Assembly).WithReferences();
}
});
}
return(clientBuilder);
}
private static async Task Run(string[] args)
{
var serviceName = new Uri("fabric:/StatelessCalculatorApp/StatelessCalculatorService");
var builder = new ClientBuilder();
builder.Configure <ClusterOptions>(options =>
{
options.ServiceId = Guid.Empty;
options.ClusterId = "dev";
});
// Use Service Fabric for managing cluster membership.
builder.UseServiceFabricClustering(serviceName);
// Add the application assemblies.
builder.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(ICalculatorGrain).Assembly));
// Optional: configure logging.
builder.ConfigureLogging(logging => logging.AddDebug());
builder.ConfigureServices(
services =>
{
// Some deployments require a custom FabricClient, eg so that cluster endpoints and certificates can be configured.
// A pre-configured FabricClient can be injected.
var fabricClient = new FabricClient();
services.AddSingleton(fabricClient);
});
// Create the client and connect to the cluster.
var client = builder.Build();
await client.Connect();
double result;
if (args.Length < 1)
{
Console.WriteLine(
$"Usage: {Assembly.GetExecutingAssembly()} <operation> [operand]\n\tOperations: get, set, add, subtract, multiple, divide");
return;
}
var value = args.Length > 1 ? double.Parse(args[1]) : 0;
var calculator = client.GetGrain <ICalculatorGrain>(Guid.Empty);
var observer = new CalculatorObserver();
var observerReference = await client.CreateObjectReference <ICalculatorObserver>(observer);
var cancellationTokenSource = new CancellationTokenSource();
var subscriptionTask = StaySubscribed(calculator, observerReference, cancellationTokenSource.Token);
switch (args[0].ToLower())
{
case "stress":
result = await StressTest(client);
break;
case "add":
case "+":
result = await calculator.Add(value);
break;
case "subtract":
case "-":
result = await calculator.Subtract(value);
break;
case "multiply":
case "*":
result = await calculator.Multiply(value);
break;
case "divide":
case "/":
result = await calculator.Divide(value);
break;
case "set":
result = await calculator.Set(value);
break;
case "get":
default:
result = await calculator.Get();
break;
}
Console.WriteLine(result);
Console.WriteLine("Listening for updates to calculations. Press any key to exit.");
Console.ReadKey();
cancellationTokenSource.Cancel();
await subscriptionTask;
}
protected override void ProcessRecord()
{
try
{
this.WriteVerbose($"[{DateTime.UtcNow}] Initializing Orleans Grain Client");
var builder = new ClientBuilder();
switch (this.ParameterSetName)
{
case FilePathSet:
this.WriteVerbose($"[{DateTime.UtcNow}] Using config file at '{this.ConfigFilePath}'...");
if (string.IsNullOrWhiteSpace(this.ConfigFilePath))
{
throw new ArgumentNullException(nameof(this.ConfigFilePath));
}
builder.LoadConfiguration(this.ConfigFilePath);
break;
case FileSet:
this.WriteVerbose($"[{DateTime.UtcNow}] Using provided config file...");
if (this.ConfigFile == null)
{
throw new ArgumentNullException(nameof(this.ConfigFile));
}
builder.LoadConfiguration(this.ConfigFile);
break;
case ConfigSet:
this.WriteVerbose($"[{DateTime.UtcNow}] Using provided 'ClientConfiguration' object...");
if (this.Config == null)
{
throw new ArgumentNullException(nameof(this.Config));
}
builder.UseConfiguration(this.Config);
break;
case EndpointSet:
this.WriteVerbose($"[{DateTime.UtcNow}] Using default Orleans Grain Client initializer");
if (this.GatewayAddress == null)
{
throw new ArgumentNullException(nameof(this.GatewayAddress));
}
var config = this.GetOverriddenConfig();
builder.UseConfiguration(config);
break;
default:
this.WriteVerbose($"[{DateTime.UtcNow}] Using default Orleans Grain Client initializer");
builder.LoadConfiguration();
break;
}
this.client = builder
.ConfigureApplicationParts(parts => parts.AddFromAppDomain())
.Build();
this.client.Connect().GetAwaiter().GetResult();
this.SetClient(this.client);
this.WriteObject(this.client);
}
catch (Exception ex)
{
this.WriteError(new ErrorRecord(ex, ex.GetType().Name, ErrorCategory.InvalidOperation, this));
}
}
private static async Task Run(string[] args)
{
var serviceName = new Uri("fabric:/StatelessCalculatorApp/StatelessCalculatorService");
var builder = new ClientBuilder();
builder.Configure <ClusterOptions>(options =>
{
options.ServiceId = serviceName.ToString();
options.ClusterId = "development";
});
// TODO: Pick a clustering provider and configure it here.
builder.UseAzureStorageClustering(options => options.ConnectionString = "UseDevelopmentStorage=true");
// Add the application assemblies.
builder.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(ICalculatorGrain).Assembly));
// Optional: configure logging.
builder.ConfigureLogging(logging => logging.AddDebug());
// Create the client and connect to the cluster.
var client = builder.Build();
await client.Connect();
double result;
if (args.Length < 1)
{
Console.WriteLine(
$"Usage: {Assembly.GetExecutingAssembly()} <operation> [operand]\n\tOperations: get, set, add, subtract, multiple, divide");
return;
}
var value = args.Length > 1 ? double.Parse(args[1]) : 0;
var calculator = client.GetGrain <ICalculatorGrain>(Guid.Empty);
var observer = new CalculatorObserver();
var observerReference = await client.CreateObjectReference <ICalculatorObserver>(observer);
var cancellationTokenSource = new CancellationTokenSource();
var subscriptionTask = StaySubscribed(calculator, observerReference, cancellationTokenSource.Token);
switch (args[0].ToLower())
{
case "stress":
result = await StressTest(client);
break;
case "add":
case "+":
result = await calculator.Add(value);
break;
case "subtract":
case "-":
result = await calculator.Subtract(value);
break;
case "multiply":
case "*":
result = await calculator.Multiply(value);
break;
case "divide":
case "/":
result = await calculator.Divide(value);
break;
case "set":
result = await calculator.Set(value);
break;
case "get":
default:
result = await calculator.Get();
break;
}
Console.WriteLine(result);
Console.WriteLine("Listening for updates to calculations. Press any key to exit.");
Console.ReadKey();
cancellationTokenSource.Cancel();
await subscriptionTask;
}
static void Main(string[] args)
{
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
listeners = new Dictionary <int, UdpServerListener>();
sources = new Dictionary <int, CancellationTokenSource>();
OrleansConfig orleansConfig = GetOrleansConfig();
config = GetPiraeusConfig();
if (!orleansConfig.Dockerized)
{
var client = new ClientBuilder();
client.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IPiSystem).Assembly));
client.UseLocalhostClustering();
clusterClient = client.Build();
hostname = "localhost";
}
else
{
clusterClient = GetClient(orleansConfig);
hostname = Dns.GetHostName();
}
Task connectTask = ConnectAsync();
Task.WhenAll(connectTask);
int[] ports = config.GetPorts();
foreach (var port in ports)
{
sources.Add(port, new CancellationTokenSource());
}
//string hostname = config.Hostname == null ? "localhost" : config.Hostname;
int index = 0;
while (index < ports.Length)
{
listeners.Add(ports[index], new UdpServerListener(config, new IPEndPoint(GetIPAddress(hostname), ports[index]), sources[ports[index]].Token));
index++;
}
KeyValuePair <int, UdpServerListener>[] udpKvps = listeners.ToArray();
foreach (var item in udpKvps)
{
item.Value.OnError += Listener_OnError;
Task task = item.Value.StartAsync();
Task.WhenAll(task);
}
done = new ManualResetEventSlim(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
done.Set();
eventArgs.Cancel = true;
};
Console.WriteLine("UDP Gateway is ready...");
done.Wait();
}
private async Task <IClusterClient> StartClientWithRetries()
{
var attempt = 0;
const int initializeAttemptsBeforeFailing = 5;
const double retryWaitSeconds = 4.0;
var clientBuilder = new ClientBuilder();
if (_providerInfo.DefaultProvider == "MongoDB")
{
clientBuilder.UseMongoDBClustering(options =>
{
var mongoSetting = _providerInfo.MongoDB.Cluster;
options.ConnectionString = mongoSetting.DbConn;
options.DatabaseName = mongoSetting.DbName;
// see:https://github.com/OrleansContrib/Orleans.Providers.MongoDB/issues/54
options.CollectionPrefix = mongoSetting.CollectionPrefix;
})
.Configure <ClientMessagingOptions>(options =>
{
options.ResponseTimeout = TimeSpan.FromSeconds(20);
options.ResponseTimeoutWithDebugger = TimeSpan.FromMinutes(60);
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
});
}
clientBuilder.ConfigureApplicationParts(manager =>
{
manager.AddApplicationPart(typeof(IPlayerAggregate).Assembly).WithReferences();
manager.AddApplicationPart(typeof(IPlayer).Assembly).WithReferences();
manager.AddApplicationPart(typeof(IGameHost).Assembly).WithReferences();
manager.AddApplicationPart(typeof(ILeaderBoard).Assembly).WithReferences();
})
.ConfigureLogging(builder =>
{
builder.AddSerilog(dispose: true);
});
var client = clientBuilder.Build();
await client.Connect(RetryFilter);
_logger.LogInformation("Player Orleans Client successfully connect to silo host");
return(client);
#region Orleans Connect Retry Filter
async Task <bool> RetryFilter(Exception exception)
{
if (exception.GetType() != typeof(SiloUnavailableException))
{
_logger.LogError($"Cluster client failed to connect to cluster with unexpected error. Exception: {exception}");
return(false);
}
attempt++;
_logger.LogInformation($"Cluster client attempt {attempt} of {initializeAttemptsBeforeFailing} failed to connect to cluster. Exception: {exception}");
if (attempt > initializeAttemptsBeforeFailing)
{
return(false);
}
await Task.Delay(TimeSpan.FromSeconds(retryWaitSeconds));
return(true);
}
#endregion
}