public LongRunningStatusHub(ILogger <LongRunningStatusHub> logger,
IOptionsMonitor <ClusterInfoOption> clusterInfoOptionsMonitor, IOptionsMonitor <OrleansProviderOption> providerOptionsMonitor)
{
_logger = logger;
_clusterInfo = clusterInfoOptionsMonitor.CurrentValue;
_providerOption = providerOptionsMonitor.CurrentValue;
}
public LongTaskDemoController(ILogger <LongTaskDemoController> logger,
IOptionsMonitor <ClusterInfoOption> clusterInfoOptionsMonitor, IOptionsMonitor <OrleansProviderOption> providerOptionsMonitor)
{
_logger = logger;
_clusterInfo = clusterInfoOptionsMonitor.CurrentValue;
_providerOption = providerOptionsMonitor.CurrentValue;
}
/// <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);
}
public async Task DemoRun()
{
var clusterInfoOption = new ClusterInfoOption {
ClusterId = "dev", ServiceId = "HelloWorldApp"
};
var staticGatewayOption = new StaticGatewayListProviderOptions
{
Gateways = new List <Uri> {
new Uri("gwy.tcp://127.0.0.1:30000/0")
}
};
using var client =
OrleansClientBuilder.CreateStaticRouteClient(_logger,
clusterInfoOption, staticGatewayOption,
configureLogging: builder => { builder.AddSerilog(); });
await client.ConnectWithRetryAsync();
_logger.LogInformation("Client successfully connect to silo host");
var grain = client.GetGrain <IHello>(0);
_logger.LogInformation("Get hello world grain, start calling RPC methods...");
var returnValue = await grain.SayHello("Hello Orleans");
_logger.LogInformation($"RPC method return value is \r\n\r\n{{{returnValue}}}\r\n");
await client.Close();
_logger.LogInformation("Client successfully close connection to silo host");
}
public PlayerClientHub(
IOptionsMonitor <ClusterInfoOption> clusterInfoOptions,
IOptionsMonitor <OrleansProviderOption> providerOptions,
ILogger <PlayerClientHub> logger)
{
_clusterInfo = clusterInfoOptions.CurrentValue;
_providerInfo = providerOptions.CurrentValue;
_logger = logger;
}
private static ClientBuilder ConfigureCluster(this ClientBuilder clientBuilder,
ClusterInfoOption clusterInfo, TimeSpan responseTimeout, TimeSpan responseTimeoutWithDebugger)
{
clientBuilder.Configure <ClientMessagingOptions>(options =>
{
options.ResponseTimeout = responseTimeout;
options.ResponseTimeoutWithDebugger = responseTimeoutWithDebugger;
}).Configure <ClusterOptions>(options =>
{
options.ClusterId = clusterInfo.ClusterId;
options.ServiceId = clusterInfo.ServiceId;
});
return(clientBuilder);
}
public async Task DemoRun()
{
var clusterInfoOption = new ClusterInfoOption {
ClusterId = "dev", ServiceId = "HelloWorldApp"
};
var sqlDbProviderOption =
new OrleansProviderOption
{
DefaultProvider = @"SQLDB",
SQLDB = new AdoNetProviderSettings
{
Cluster = new AdoNetProviderClusterSettings
{
DbConn =
@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=Orleans_Cluster;
Integrated Security=True;Pooling=False;Max Pool Size=200;
MultipleActiveResultSets=True"
}
}
};
using var client =
OrleansClientBuilder.CreateClient(_logger,
clusterInfoOption, sqlDbProviderOption,
configureLogging: builder => { builder.AddSerilog(); });
await client.ConnectWithRetryAsync();
_logger.LogInformation("Client successfully connect to silo host");
var grain = client.GetGrain <IHello>(0);
_logger.LogInformation("Get hello world grain, start calling RPC methods...");
var returnValue = await grain.SayHello("Hello Orleans");
_logger.LogInformation($"RPC method return value is \r\n\r\n{{{returnValue}}}\r\n");
await client.Close();
_logger.LogInformation("Client successfully close connection to silo host");
}
private static (ClusterInfoOption, OrleansProviderOption) GetConfigSettings(string[] args)
{
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables(prefix: "ORLEANS_CLIENT_APP_")
.AddCommandLine(args);
var config = builder.Build().GetSection("Orleans");
var clusterInfo = new ClusterInfoOption();
config.GetSection("Cluster").Bind(clusterInfo);
var providerInfo = new OrleansProviderOption();
config.GetSection("Provider").Bind(providerInfo);
return(clusterInfo, providerInfo);
}
public async Task DemoRun()
{
var clusterInfoOption = new ClusterInfoOption {
ClusterId = "dev", ServiceId = "HelloWorldApp"
};
var sqlDbProviderOption =
new OrleansProviderOption
{
DefaultProvider = @"MYSQL",
SQLDB = new AdoNetProviderSettings
{
Cluster = new AdoNetProviderClusterSettings
{
DbConn =
@"Server=localhost;uid=root;pwd=Pass1234;Database=orleans_demo"
}
}
};
using var client =
OrleansClientBuilder
.CreateClient(_logger, clusterInfoOption, sqlDbProviderOption,
new[] { typeof(IHello) }, configureLogging: builder => {
builder.AddSerilog();
});
await client.ConnectWithRetryAsync();
_logger.LogInformation("Client successfully connect to silo host");
var grain = client.GetGrain <IHello>(0);
_logger.LogInformation("Get hello world grain, start calling RPC methods...");
var returnValue = await grain.SayHello("Hello Orleans");
_logger.LogInformation($"RPC method return value is \r\n\r\n{{{returnValue}}}\r\n");
await client.Close();
_logger.LogInformation("Client successfully close connection to silo host");
}
/// <summary>
/// Create Orleans Client using various configuration options
/// </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>
/// <param name="configureLogging"></param>
/// <returns></returns>
public static IClusterClient CreateClient(ILogger logger,
ClusterInfoOption clusterInfo,
OrleansProviderOption providerOption,
IEnumerable <Type> applicationPartTypes = null,
Action <ILoggingBuilder> configureLogging = null)
{
try
{
var builder = CreateClientBuilder(logger, clusterInfo, providerOption, applicationPartTypes);
if (configureLogging != null)
{
builder.ConfigureLogging(configureLogging);
}
return(builder.Build());
}
catch (Exception ex)
{
logger.LogError(ex, "Create Silo Client failed");
throw;
}
}
public async Task DemoRun()
{
var clusterInfoOption = new ClusterInfoOption {
ClusterId = "dev", ServiceId = "HelloWorldApp"
};
var mongoDbProviderOption = new OrleansProviderOption
{
DefaultProvider = "mongodb",
MongoDB = new MongoDbProviderSettings
{
Cluster = new MongoDbProviderClusterSettings
{
DbConn = "mongodb://localhost:27017",
DbName = "demo-silo-Clustering"
}
}
};
using var client = OrleansClientBuilder
.CreateClient(_logger, clusterInfoOption, mongoDbProviderOption, new[] { typeof(IHello) },
builder => { builder.AddSerilog(); });
await client.ConnectWithRetryAsync();
_logger.LogInformation("Client successfully connect to silo host");
var grain = client.GetGrain <IHello>(0);
_logger.LogInformation("Get hello world grain, start calling RPC methods...");
var returnValue = await grain.SayHello("Hello Orleans");
_logger.LogInformation($"RPC method return value is \r\n\r\n{{{returnValue}}}\r\n");
await client.Close();
_logger.LogInformation("Client successfully close connection to silo host");
}
/// <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);
}
