static void Main(string[] args)
{
HostingEnvironment = GetHostingEnvironment();
Configuration = GetConfiguration(HostingEnvironment, args);
var siloHostBuilder = new SiloHostBuilder()
.SetClusteringEnvironment()
.Configure <ClusterOptions>(options => {
options.ClusterId = Configuration["Orleans:ClusterId"];
options.ServiceId = Configuration["Orleans:ServiceId"];
})
.Configure <EndpointOptions>(options => {
options.AdvertisedIPAddress = IPAddress.Loopback;
})
.ConfigureApplicationParts(parts => {
parts.AddApplicationPart(typeof(Grains.Posts.BlogPostGrain).Assembly).WithReferences();
})
.ConfigureLogging(logging => {
logging
.AddConfiguration(Configuration)
.AddConsole();
})
.ConfigureServices(ConfigureServices);
if (Configuration.GetValue <bool>("OrleansDashboard:Enabled", false))
{
siloHostBuilder = siloHostBuilder.UseDashboard(options => {
options.Host = Configuration["OrleansDashboard:Host"];
options.Port = Configuration.GetValue <int>("OrleansDashboard:Port");
options.Username = Configuration["OrleansDashboard:Username"];
options.Password = Configuration["OrleansDashboard:Password"];
options.CounterUpdateIntervalMs = Configuration.GetValue <int>("OrleansDashboard:UpdateInterval", 1000);
});
}
var siloHost = siloHostBuilder.Build();
siloHost.StartAsync()
.ContinueWith(task => {
Console.WriteLine("CoreBlog SiloHost is running...");
return(task);
});
resetEvent.WaitOne();
}
/// <summary>
/// 启动Silo
/// </summary>
/// <param name="assemblys"></param>
/// <returns></returns>
private static async Task <ISiloHost> StartSilo(params Assembly[] assemblys)
{
var orleansConfig = OrleansConfig.ReadConfig();
// define the cluster configuration
var builder = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{ //群集标识
options.ClusterId = "dev";
options.ServiceId = "OrleansBasics";
})
.Configure <EndpointOptions>(options =>
{ //网关设置
//options.AdvertisedIPAddress = IPAddress.Parse("127.0.0.1");//监听外网地址
options.AdvertisedIPAddress = IPAddress.Parse(orleansConfig.GatewayAddress);
options.SiloPort = orleansConfig.SiloPort;
options.GatewayPort = orleansConfig.GatewayPort;
})
.ConfigureApplicationParts(
parts =>
{
foreach (var assembly in assemblys)
{ //注入程序集
parts.AddApplicationPart(assembly).WithReferences();
}
}
)
.ConfigureLogging(logging => logging.AddConsole());
if (orleansConfig.UseDashboard)
{//使用监控
builder.UseDashboard();
}
var host = builder.Build();
await host.StartAsync();
return(host);
}
private static async Task <ISiloHost> StartSilo(SiloHostConfig config)
{
var builder = new SiloHostBuilder()
.UseAdoNetClustering(op =>
{
op.ConnectionString = config.ClusteringDbConnectionString;
op.Invariant = config.ClusteringDbInvariant;
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = config.ClusterId;
options.ServiceId = config.ServiceId;
})
.Configure <EndpointOptions>(options =>
{
options.AdvertisedIPAddress = IPAddress.Parse(config.AdvertisedIPAddress);
options.SiloPort = config.SiloPort;
options.GatewayPort = config.GatewayPort;
})
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddDebug());
if (config.Dashboard != null && config.Dashboard.UseDashboard)
{
builder = builder.UseDashboard(options =>
{
options.Username = config.Dashboard.Username;
options.Password = config.Dashboard.Password;
options.Host = config.Dashboard.Host;
options.Port = config.Dashboard.Port;
options.HostSelf = config.Dashboard.HostSelf;
options.CounterUpdateIntervalMs = config.Dashboard.CounterUpdateIntervalMs;
});
}
var host = builder.Build();
await host.StartAsync();
return(host);
}
private ISiloHost CreateSiloHost()
{
var builder = new SiloHostBuilder();
if (_dashboardOptions.Value.Enable)
{
builder.UseDashboard(options =>
{
options.Port = _dashboardOptions.Value.Port;
});
}
builder.Configure <ClusterOptions>(options =>
{
options.ClusterId = _siloOptions.Value.ClusterId;
options.ServiceId = _siloOptions.Value.ServiceId;
});
if (string.IsNullOrEmpty(_siloOptions.Value.AdvertisedIp) || "*".Equals(_siloOptions.Value.AdvertisedIp))
{
builder.ConfigureEndpoints(_siloOptions.Value.SiloPort, _siloOptions.Value.GatewayPort,
listenOnAnyHostAddress: _siloOptions.Value.ListenOnAnyHostAddress);
}
else
{
var ip = IPAddress.Parse(_siloOptions.Value.AdvertisedIp);
builder.ConfigureEndpoints(ip, _siloOptions.Value.SiloPort, _siloOptions.Value.GatewayPort,
listenOnAnyHostAddress: _siloOptions.Value.ListenOnAnyHostAddress);
}
if (_providerOptions.Value.DefaultProvider == "MongoDB")
{
var mongoDbOption = _providerOptions.Value.MongoDB;
builder.UseMongoDBClustering(options =>
{
var clusterOption = mongoDbOption.Cluster;
options.ConnectionString = clusterOption.DbConn;
options.DatabaseName = clusterOption.DbName;
// see:https://github.com/OrleansContrib/Orleans.Providers.MongoDB/issues/54
options.CollectionPrefix = clusterOption.CollectionPrefix;
})
.UseMongoDBReminders(options =>
{
var reminderOption = mongoDbOption.Reminder;
options.ConnectionString = reminderOption.DbConn;
options.DatabaseName = reminderOption.DbName;
if (!string.IsNullOrEmpty(reminderOption.CollectionPrefix))
{
options.CollectionPrefix = reminderOption.CollectionPrefix;
}
})
.AddMongoDBGrainStorageAsDefault(options =>
{
var storageOption = mongoDbOption.Storage;
options.ConnectionString = storageOption.DbConn;
options.DatabaseName = storageOption.DbName;
if (!string.IsNullOrEmpty(storageOption.CollectionPrefix))
{
options.CollectionPrefix = storageOption.CollectionPrefix;
}
});
}
builder.ConfigureServices(services =>
{
services
.AddLogging(loggingBuilder => loggingBuilder.AddSerilog())
.AddTransient <GameHost>()
.AddTransient <LeaderBoard>()
.AddTransient <Player>();
})
.ConfigureApplicationParts(parts => { parts.AddFromApplicationBaseDirectory().WithReferences(); })
.ConfigureLogging(logging => { logging.AddSerilog(dispose: true); });
return(builder.Build());
}
private ISiloHostBuilder InitBuilder()
{
var hostBuilder = new SiloHostBuilder();
hostBuilder.Configure <SerializationProviderOptions>(options =>
{
options.SerializationProviders.Add(typeof(OrleansCustomSerialization));
// A workaround for an Orleans issue
// to ensure the stack trace properly de/serialized
// Gigya.Microdot.UnitTests.Serialization.ExceptionSerializationTests
options.SerializationProviders.Add(typeof(NonSerializedExceptionsSerializer));
options.FallbackSerializationProvider = typeof(OrleansCustomSerialization);
})
.UsePerfCounterEnvironmentStatistics()
// We paid attention that AddFromApplicationBaseDirectory making issues of non-discovering grain types.
.ConfigureApplicationParts(parts => parts.AddFromAppDomain())
.Configure <SiloOptions>(options => options.SiloName = _appInfo.Name);
if (_orleansConfig.Dashboard.Enable)
{
hostBuilder.UseDashboard(o =>
{
o.Port = _endPointDefinition.SiloDashboardPort;
o.CounterUpdateIntervalMs = (int)TimeSpan.Parse(_orleansConfig.Dashboard.WriteInterval).TotalMilliseconds;
o.HideTrace = _orleansConfig.Dashboard.HideTrace;
});
}
SetGrainCollectionOptions(hostBuilder);
hostBuilder.Configure <PerformanceTuningOptions>(options =>
{
options.DefaultConnectionLimit = ServicePointManager.DefaultConnectionLimit;
});
hostBuilder.AddMemoryGrainStorage(ProviderConstants.DEFAULT_STORAGE_PROVIDER_NAME, options => options.NumStorageGrains = 10);
hostBuilder.Configure <TelemetryOptions>(o => o.AddConsumer <MetricsStatisticsConsumer>());
hostBuilder.Configure <SchedulingOptions>(options =>
{
options.PerformDeadlockDetection = true;
options.AllowCallChainReentrancy = true;
options.MaxActiveThreads = Process.GetCurrentProcess().ProcessorAffinityList().Count();
});
hostBuilder.Configure <ClusterMembershipOptions>(options =>
{
});
if (_orleansConfig.EnableTls)
{
var localCertificate = _certificateLocator.GetCertificate("Service");
hostBuilder.UseTls(localCertificate, tlsOptions =>
{
tlsOptions.LocalCertificate = localCertificate;
tlsOptions.ClientCertificateMode = RemoteCertificateMode.AllowCertificate;
tlsOptions.RemoteCertificateMode = RemoteCertificateMode.AllowCertificate;
tlsOptions.SslProtocols = SslProtocols.Tls12;
tlsOptions.OnAuthenticateAsClient = OnAuthenticateAsClient;
});
}
SetReminder(hostBuilder);
SetSiloSource(hostBuilder);
hostBuilder.Configure <StatisticsOptions>(o =>
{
o.LogWriteInterval = TimeSpan.FromDays(1);
o.PerfCountersWriteInterval = TimeSpan.Parse(_orleansConfig.MetricsTableWriteInterval);
});
return(hostBuilder);
}
/// <summary>
/// Starts the silo host.
/// </summary>
/// <returns>An <see cref="ISiloHost" />.</returns>
private ISiloHost StartSilo()
{
var databaseConfig = this.configuration.GetSection("Database");
var connectionSettings = new MqttDatabaseConnectionSettings();
databaseConfig.Bind(connectionSettings);
DashboardOptions dashboardOptions = null;
if (this.configuration.GetSection("Orleans").GetSection("DashboardOptions").Exists())
{
dashboardOptions = new DashboardOptions();
this.configuration.GetSection("Orleans").Bind("DashboardOptions", dashboardOptions);
}
// ReSharper disable ImplicitlyCapturedClosure
var builder = new SiloHostBuilder().ConfigureServices(
s =>
{
s.Configure <MqttDatabaseConnectionSettings>(databaseConfig);
s.AddSingleton <IEventLogRepository>(r => new EventLogRepository(connectionSettings));
s.AddSingleton <IBlacklistRepository>(u => new BlacklistRepository(connectionSettings));
s.AddSingleton <IDatabaseVersionRepository>(u => new DatabaseVersionRepository(connectionSettings));
s.AddSingleton <IPublishMessageRepository>(a => new PublishMessageRepository(connectionSettings));
s.AddSingleton <IUserRepository>(u => new UserRepository(connectionSettings));
s.AddSingleton <IWhitelistRepository>(u => new WhitelistRepository(connectionSettings));
s.AddSingleton <IMqttValidator>(new MqttValidator());
}).UseAdoNetClustering(
options =>
{
options.Invariant = "Npgsql";
options.ConnectionString = connectionSettings.ToConnectionString();
}).UseAdoNetReminderService(
options =>
{
options.Invariant = "Npgsql";
options.ConnectionString = connectionSettings.ToConnectionString();
}).Configure <ClusterOptions>(options => { this.configuration.GetSection("Orleans").Bind("ClusterOptions", options); }).Configure <EndpointOptions>(
options =>
{
var opt = new SiloEndpointOptions();
this.configuration.GetSection("Orleans").Bind("EndpointOptions", opt);
opt.Bind(options);
}).ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(MqttRepositoryGrain).Assembly).WithReferences()).ConfigureLogging(
logging =>
{
logging.ClearProviders();
logging.AddSerilog(dispose: true, logger: this.logger);
});
if (dashboardOptions != null)
{
builder.UseDashboard(
o =>
{
o.HostSelf = true;
o.CounterUpdateIntervalMs = dashboardOptions.CounterUpdateIntervalMs;
o.Port = dashboardOptions.Port;
});
}
builder.AddSimpleMessageStreamProvider("SMSProvider").AddMemoryGrainStorage("PubSubStore");
var host = builder.Build();
return(host);
}
