private static async Task <ISiloHost> StartSilo()
{
// define the cluster configuration
var builder = new SiloHostBuilder()
.ConfigureClustering(
ServiceProvider.GetService <IOptions <OrleansConfig> >(),
Startup.HostingEnvironment.EnvironmentName
)
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
})
.AddMemoryGrainStorage(Constants.OrleansMemoryProvider)
.ConfigureApplicationParts(parts =>
{
parts.AddApplicationPart(typeof(IGrainMarker).Assembly).WithReferences();
})
.ConfigureServices(DependencyInjectionHelper.IocContainerRegistration)
.UsePerfCounterEnvironmentStatistics()
.UseDashboard(options => { })
.UseInMemoryReminderService()
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
static ISiloHost CreateSilo(string[] args)
{
(int siloPort, int gatewayPort, IPAddress advertisedIP) = GetEndpointsOption(args);
Console.WriteLine(($"siloPort：{siloPort}，gatewayPort：{gatewayPort}，advertisedIP：{advertisedIP}"));
//启动SiloHost
var builder = new SiloHostBuilder()
.UseDashboard(opt => opt.HostSelf = false)
.UseConsulClustering((OptionsBuilder <ConsulClusteringSiloOptions> opt) =>
{
opt.Configure <IConfiguration>((options, config) =>
{
var c = config.GetSection("IdentityOptions").Get <ConsulClusteringSiloOptions>();
options.Address = c.Address;
});
})
.ConfigureHostConfiguration((IConfigurationBuilder config) =>
{
config.SetBasePath(Directory.GetCurrentDirectory())
.AddCommandLine(args)
.AddJsonFile("hostsettings.json", optional: true, reloadOnChange: true);
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "Zop.Identity";
options.ServiceId = "Zop.Identity";
})
.ConfigureEndpoints(advertisedIP, siloPort: siloPort, gatewayPort: gatewayPort, listenOnAnyHostAddress: true)
.ConfigureAppConfiguration((HostBuilderContext context, IConfigurationBuilder config) =>
{
config.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{context.HostingEnvironment.EnvironmentName}.json", optional: true);
})
.ConfigureServices((HostBuilderContext context, IServiceCollection services) =>
{
services.AddAutoMapper();
services.AddIdentityApplication();
services.AddRepositoryStorage(rb =>
{
var ro = context.Configuration.GetSection("IdentityRepositories").Get <RepositoryOptions>();
rb.AddIdentityRepository(options =>
{
options.DbContextOptions = dbBuilder => dbBuilder.UseMySql(ro.ConnectionString);
});
});
})
.ConfigureLogging((HostBuilderContext context, ILoggingBuilder logging) =>
{
logging.AddConfiguration(context.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddFile(context.Configuration.GetSection("Logging:File"));
})
.Configure <ProcessExitHandlingOptions>(options => options.FastKillOnProcessExit = false)
.AddExceptionsFilter();
var host = builder.Build();
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
var builder = new SiloHostBuilder()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
})
.UseAdoNetClustering(options =>
{
options.Invariant = "System.Data.SqlClient";
options.ConnectionString =
"Data Source=researchdb;Initial Catalog=OrleDb;Persist Security Info=True;User ID=sa;Password=OrleDBP@asswor1d";
})
.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000)
.UseDashboard(options => { options.Port = 8090; })
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Warning).AddFile("log.warn.txt");
loggingBuilder.SetMinimumLevel(LogLevel.Information).AddFile("log.info.txt");
loggingBuilder.SetMinimumLevel(LogLevel.Debug).AddFile("log.debug.txt");
});
var host = builder.Build();
await host.StartAsync();
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
var builder = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Account).Assembly).WithReferences())
.ConfigureLocalHostPrimarySilo()
.ConfigureServices((context, servicecollection) =>
{
servicecollection.AddSingleton <ISerializer, ProtobufSerializer>(); //注册序列化组件
servicecollection.AddMongoES(); //注册MongoDB为事件库
servicecollection.AddRabbitMQ <MessageInfo>(); //注册RabbitMq为默认消息队列
})
.Configure <MongoConfig>(c =>
{
c.SysStartTime = new DateTime(2018, 2, 1);
c.Connection = "mongodb://127.0.0.1:28888";
})
.Configure <RabbitConfig>(c =>
{
c.UserName = "******";
c.Password = "******";
c.Hosts = new[] { "192.168.199.216:5672" };
c.MaxPoolSize = 100;
c.VirtualHost = "/";
})
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
protected Task RunSilo()
{
try
{
var builder = new SiloHostBuilder();
builder.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = TableRoom.GameConstant.ClusterId;
options.ServiceId = TableRoom.GameConstant.ServiceId;
})
.Configure <GrainCollectionOptions>(options =>
{
options.CollectionAge = TimeSpan.FromSeconds(61);
options.DeactivationTimeout = TimeSpan.FromSeconds(5);
options.CollectionQuantum = TimeSpan.FromSeconds(1);
})
.ConfigureLogging(log => log.SetMinimumLevel(LogLevel.Error).AddConsole());//LogLevel.Warning
builder.ConfigureApplicationParts(parts =>
{
parts.AddApplicationPart(typeof(GChatRoomEntry).Assembly).WithReferences();
});
m_Host = builder.Build();
m_Host.StartAsync().Wait();
}
catch (Exception e)
{
Log.Debug(e.ToString());
}
return(Task.CompletedTask);
}
private static async Task <ISiloHost> StartSilo()
{
var config = ClusterConfiguration.LocalhostPrimarySilo();
config.AddMemoryStorageProvider();
var builder = new SiloHostBuilder()
.UseConfiguration(config)
.AddApplicationPartsFromReferences(typeof(Account).Assembly)
.ConfigureServices((context, servicecollection) =>
{
servicecollection.AddSingleton <ISerializer, ProtobufSerializer>(); //注册序列化组件
servicecollection.AddMongoES(); //注册MongoDB为事件库
servicecollection.AddRabbitMQ <MessageInfo>(); //注册RabbitMq为默认消息队列
})
.Configure <MongoConfig>(c => c.Connection = "mongodb://127.0.0.1:28888")
.Configure <RabbitConfig>(c =>
{
c.UserName = "******";
c.Password = "******";
c.Hosts = new[] { "127.0.0.1:5672" };
c.MaxPoolSize = 100;
c.VirtualHost = "/";
})
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
static void Main(string[] args)
{
var builder = new SiloHostBuilder()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = Constants.ClusterId;
options.ServiceId = Constants.ServiceId;
})
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Channel).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
//need to configure a grain storage called "PubSubStore" for using streaming with ExplicitSubscribe pubsub type
.AddMemoryGrainStorage("PubSubStore")
//Depends on your application requirements, you can configure your silo with other stream providers, which can provide other features,
//such as persistence or recoverability. For more information, please see http://dotnet.github.io/orleans/Documentation/Orleans-Streams/Stream-Providers.html
.AddSimpleMessageStreamProvider(Constants.ChatRoomStreamProvider);
var silo = builder.Build();
silo.StartAsync().Wait();
Console.WriteLine("Press Enter to close.");
Console.ReadLine();
// shut the silo down after we are done.
silo.StopAsync().Wait();
}
public static async Task <IWebHostBuilder> CreateWebHostBuilder(string[] args)
{
var silo =
new SiloHostBuilder()
.UseDashboard()
.UseLocalhostClustering()
.AddMemoryGrainStorage("OrleansStorage") // TODO: replace with your storage
.ConfigureApplicationParts(parts =>
{
parts.AddApplicationPart(typeof(ISimple).Assembly).WithReferences();
parts.AddApplicationPart(typeof(SimpleGrain).Assembly).WithReferences();
})
.Build();
await silo.StartAsync();
var client = silo.Services.GetRequiredService <IClusterClient>();
return(WebHost.CreateDefaultBuilder(args)
.ConfigureServices(s =>
{
s.AddSingleton <IClusterClient>(client);
s.AddSingleton <IGrainFactory>(client);
})
.UseStartup <Startup>());
}
private static async Task <ISiloHost> StartSilo()
{
var assambly = typeof(IHelloGrain).Assembly;
var builder = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "TestApp";
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(assambly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.UseInMemoryReminderService()
.UseLocalhostClustering()
.AddLogStorageBasedLogConsistencyProvider("LogStorage")
.AddStateStorageBasedLogConsistencyProvider("StateStorage")
//.AddCustomStorageBasedLogConsistencyProvider("CustomStorage")
.AddMemoryGrainStorage("OrleansStorage", options => options.NumStorageGrains = 10);
var host = builder.Build();
await host.StartAsync();
return(host);
}
/// <summary>
/// 在本地启动一个Host
/// </summary>
/// <returns></returns>
static async Task <ISiloHost> StartHost(int silePort, int gatewayPort, int mainSiloPort)
{
var builder = new SiloHostBuilder()
//启动一个在本地的Host 若primarySiloEndpoint属性为空 则启动主简仓 否则进行连接
//IPAddress.Loopback为127.0.0.1
.UseDevelopmentClustering(new IPEndPoint(IPAddress.Loopback, mainSiloPort))
.ConfigureEndpoints(siloPort: silePort, gatewayPort: gatewayPort)
.Configure <ClusterOptions>(options =>
{
//ClusterId为集群名称 相同的名称才能被分配到一个集群中
options.ClusterId = "dev";
//当前服务的名称
options.ServiceId = "ShoppingRecordServer";
})
//注入打印消息的入口
.ConfigureLogging(logging => logging.AddConsole());
//进行构建
var host = builder.Build();
//启动服务
await host.StartAsync();
Console.WriteLine("服务启动成功");
return(host);
}
/// <summary>
/// 启动网关的简仓
/// </summary>
/// <returns></returns>
static async Task <ISiloHost> StartHost(int silePort, int gatewayPort)
{
var builder = new SiloHostBuilder()
.Configure <SerializationProviderOptions>(d => { d.SerializationProviders.Add(typeof(ProtobufSerializer).GetTypeInfo()); d.FallbackSerializationProvider = typeof(ProtobufSerializer).GetTypeInfo(); })
.UseDevelopmentClustering(new IPEndPoint(IPAddress.Loopback, silePort))
.ConfigureEndpoints(GetInternalIp(), siloPort: silePort, gatewayPort: gatewayPort)
.Configure <ClusterOptions>(options =>
{
//ClusterId为集群名称 相同的名称才能被分配到一个集群中
options.ClusterId = "dev";
//当前服务的名称
options.ServiceId = "GoodsServer";
})
//注入打印消息的入口
.ConfigureLogging(logging => logging.AddConsole());
//进行构建
var host = builder.Build();
//启动服务
await host.StartAsync();
Console.WriteLine("简仓服务启动成功");
return(host);
}
public void StorageOptionsValidator(string connectionString)
{
var siloPort = 11111;
int gatewayPort = 30000;
var siloAddress = IPAddress.Loopback;
var builder = new SiloHostBuilder();
Assert.Throws <OrleansConfigurationException>(() =>
{
var silo = builder
.Configure <ClusterOptions>(options => options.ClusterId = "TESTCLUSTER")
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(siloAddress, siloPort))
.ConfigureEndpoints(siloAddress, siloPort, gatewayPort)
.ConfigureApplicationParts(pm =>
{
pm.AddApplicationPart(typeof(JsonTestGrain).Assembly);
pm.AddApplicationPart(typeof(IJsonTestGrain).Assembly);
})
.AddRedisGrainStorage("Redis", optionsBuilder => optionsBuilder.Configure(options =>
{
options.DataConnectionString = connectionString;
}))
.Build();
});
}
private static async Task <ISiloHost> StartSilo()
{
var builder = new SiloHostBuilder()
// configurando acesso ao silo
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "dev";
})
.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000)
// clustering organizado via banco de dados
.UseAdoNetClustering(options =>
{
options.Invariant = "System.Data.SqlClient";
options.ConnectionString = "Server=localhost;Database=Example;User Id=sa;Password=root@1234";
})
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(NormalGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
//define the cluster config
var builder = new SiloHostBuilder()
.AddAdoNetGrainStorage("SqlStorage", options =>
{
options.Invariant = "System.Data.SqlClient";
options.ConnectionString = "Server=localhost;Database=OrleansStorageTest;User=sa;Password=1q2w3e4r*;";
options.UseJsonFormat = true;
})
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "OrleansTutorialOne";
})
.ConfigureApplicationParts(parts =>
parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
public void SiloHostBuilder_ClusterOptionsTest()
{
Assert.Throws <OrleansConfigurationException>(() => new SiloHostBuilder()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureServices(services => services.AddSingleton <IMembershipTable, NoOpMembershipTable>())
.Build());
Assert.Throws <OrleansConfigurationException>(() => new SiloHostBuilder()
.Configure <ClusterOptions>(options => options.ClusterId = "someClusterId")
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureServices(services => services.AddSingleton <IMembershipTable, NoOpMembershipTable>())
.Build());
Assert.Throws <OrleansConfigurationException>(() => new SiloHostBuilder()
.Configure <ClusterOptions>(options => options.ServiceId = "someServiceId")
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureServices(services => services.AddSingleton <IMembershipTable, NoOpMembershipTable>())
.Build());
var builder = new SiloHostBuilder()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.Configure <ClusterOptions>(options => { options.ClusterId = "someClusterId"; options.ServiceId = "someServiceId"; })
.ConfigureServices(services => services.AddSingleton <IMembershipTable, NoOpMembershipTable>());
using (var silo = builder.Build())
{
Assert.NotNull(silo);
}
}
/// <inheritdoc />
public async Task <string> OpenAsync(CancellationToken cancellationToken)
{
try
{
var builder = new SiloHostBuilder();
builder.ConfigureServices(
services =>
{
services.AddOptions <FabricSiloInfo>().Configure <ILocalSiloDetails>((info, details) =>
{
info.Name = details.Name;
info.Silo = details.SiloAddress.ToParsableString();
if (details.GatewayAddress != null)
{
info.Gateway = details.GatewayAddress.ToParsableString();
}
});
});
this.configure(builder);
this.Host = builder.Build();
await this.Host.StartAsync(cancellationToken);
}
catch
{
this.Abort();
throw;
}
var endpoint = this.Host.Services.GetRequiredService <IOptions <FabricSiloInfo> >().Value;
return(JsonConvert.SerializeObject(endpoint));
}
public void SiloHostBuilder_LoadSheddingValidatorPasses()
{
var builder = new SiloHostBuilder()
.ConfigureDefaults()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options => options.ClusterId = "someClusterId")
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureServices(services => services.AddSingleton <IMembershipTable, NoOpMembershipTable>())
.Configure <LoadSheddingOptions>(options =>
{
options.LoadSheddingEnabled = true;
options.LoadSheddingLimit = 95;
})
.ConfigureServices(svcCollection =>
{
svcCollection.AddSingleton <FakeHostEnvironmentStatistics>();
svcCollection.AddFromExisting <IHostEnvironmentStatistics, FakeHostEnvironmentStatistics>();
svcCollection.AddTransient <IConfigurationValidator, LoadSheddingValidator>();
});
using (var host = builder.Build())
{
Assert.NotNull(host);
}
}
private static async Task <ISiloHost> InitialiseSilo()
{
var builder = new SiloHostBuilder()
// Grain State
.AddAdoNetGrainStorage("PubSubStore", options =>
{
options.Invariant = Invariant;
options.ConnectionString = ConnectionString;
options.UseJsonFormat = true;
})
// Membership
.UseAdoNetClustering(options =>
{
options.Invariant = Invariant;
options.ConnectionString = ConnectionString;
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = ClusterId;
options.ServiceId = ServiceId;
})
.AddSimpleMessageStreamProvider("SMSProvider")
.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(PublisherGrain).Assembly).WithReferences())
.ConfigureLogging(log => log.SetMinimumLevel(LogLevel.Warning).AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
private async Task RunAsync(CancellationToken cancellationToken)
{
// TODO: Replace the following with your own logic.
var siloPort = 11111;
int gatewayPort = 30000;
var siloAddress = IPAddress.Loopback;
var silo =
new SiloHostBuilder()
.UseDashboard(options =>
{
options.HostSelf = true;
options.HideTrace = false;
})
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(siloAddress, siloPort))
.UseInMemoryReminderService()
.ConfigureEndpoints(siloAddress, siloPort, gatewayPort)
.Configure <ClusterOptions>(options => options.ClusterId = "helloworldcluster")
.ConfigureApplicationParts(appParts => appParts.AddApplicationPart(typeof(TestCalls).Assembly))
.Build();
await silo.StartAsync();
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(1000);
}
await silo.StopAsync();
}
private static async Task <ISiloHost> StartSilo()
{
var builder = new SiloHostBuilder()
.UseLocalhostClustering()
.UseDashboard()
.AddRay <Configuration>()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Account).Assembly).WithReferences())
.ConfigureServices((context, servicecollection) =>
{
//注册postgresql为事件存储库
servicecollection.AddPostgreSQLStorage(config =>
{
config.ConnectionDict.Add("core_event", "Server=127.0.0.1;Port=5432;Database=Ray;User Id=postgres;Password=extop;Pooling=true;MaxPoolSize=20;");
});
servicecollection.AddPostgreSQLTransactionStorage(options =>
{
options.ConnectionKey = "core_event";
options.TableName = "Transaction_TemporaryRecord";
});
servicecollection.PSQLConfigure();
//注册mongodb为事件存储库
//servicecollection.AddMongoDBStorage(config =>
//{
// config.ConnectionDict.Add("core", "mongodb://127.0.0.1:27017");
//});
//servicecollection.AddMongoTransactionStorage(options =>
//{
// options.ConnectionKey = "core";
// options.CollectionName = "Transaction_TemporaryRecord";
//});
//servicecollection.MongoConfigure();
servicecollection.AddRabbitMQ(config =>
{
config.UserName = "******";
config.Password = "******";
config.Hosts = new[] { "127.0.0.1:5672" };
config.MaxPoolSize = 100;
config.VirtualHost = "/";
}, async container =>
{
await container.CreateEventBus <Account>("Account", "account", 5).DefaultConsumer <long>();
});
})
.Configure <GrainCollectionOptions>(options =>
{
options.CollectionAge = TimeSpan.FromMinutes(5);
})
.ConfigureLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Information);
logging.AddConsole(options => options.IncludeScopes = true);
}).EnableDirectClient();
var host = builder.Build();
await host.StartAsync();
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
var config = LoadConfig();
var orleansConfig = GetOrleansConfig(config);
var builder = new SiloHostBuilder()
//Clustering information
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloApp";
})
//Clustering provider
.UseAdoNetClustering(options => {
options.Invariant = orleansConfig.Invariant;
options.ConnectionString = orleansConfig.ConnectionString;
})
//Endpoints
.Configure <EndpointOptions>(options =>
{
options.SiloPort = 11112;
options.GatewayPort = 30002;
options.AdvertisedIPAddress = IPAddress.Loopback;
})
.UseDashboard()
.ConfigureServices(services =>
{
services.AddSingleton <IOrleansRequestContext, OrleansRequestContext>();
services.AddSingleton(s => CreateGrainMethodsList());
services.AddSingleton(s => new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.None,
TypeNameHandling = TypeNameHandling.None,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
})
.AddStateStorageBasedLogConsistencyProvider("StateStorage")
.AddIncomingGrainCallFilter <LoggingFilter>()
.AddAdoNetGrainStorageAsDefault(options =>
{
options.Invariant = orleansConfig.Invariant;
options.ConnectionString = orleansConfig.ConnectionString;
options.UseJsonFormat = true;
})
//Implementations
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IHello).Assembly).WithReferences())
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole());
var host = builder.Build();
await host.StartAsync();
return(host);
}
/// <summary>
/// 启动Orleans仪表盘服务
/// </summary>
/// <param name="configure"></param>
/// <param name="applicationPartTypes"></param>
/// <returns></returns>
public static ISiloHost StartDashboardServer(DashboardConfiguration configure, Type[] applicationPartTypes)
{
var gatewayPort = configure.GatewayPort;
var siloPort = configure.SiloPort;
var builder = new SiloHostBuilder()
// Grain State
.AddAdoNetGrainStorage(configure.OrleansStorage, options =>
{
options.Invariant = Invariant;
options.ConnectionString = configure.ClusterDatabase.ConnectionString;
options.UseJsonFormat = true;
})
// Membership
.UseAdoNetClustering(options =>
{
options.Invariant = Invariant;
options.ConnectionString = configure.ClusterDatabase.ConnectionString;
})
.UseDashboard(options =>
{
options.Username = configure.Username;
options.Password = configure.Password;
options.HostSelf = true;
options.HideTrace = false;
options.Port = configure.Port;
options.CounterUpdateIntervalMs = configure.UpdateIntervalMs;
})
.Configure <ClusterOptions>(options =>
{
options.ClusterId = configure.ClusterId;
options.ServiceId = configure.ServiceId;
})
.Configure <SerializationProviderOptions>(options =>
{
options.SerializationProviders.Add(typeof(ProtobufSerializer).GetTypeInfo());
options.FallbackSerializationProvider = typeof(ProtobufSerializer).GetTypeInfo();
})
.ConfigureEndpoints(siloPort, gatewayPort)
.ConfigureApplicationParts(parts =>
{
if (applicationPartTypes != null)
{
foreach (var type in applicationPartTypes)
{
parts.AddApplicationPart(type.Assembly).WithReferences();
}
}
})
.UseInMemoryReminderService()
.ConfigureLogging(log => log.SetMinimumLevel(LogLevel.Warning).AddConsole());
var host = builder.Build();
host.StartAsync().Wait();
Console.WriteLine("Orleans仪表盘已经启动");
return(host);
}
public ISiloHostBuilder CreateSiloBuilder(string siloName, ClusterConfiguration clusterConfiguration)
{
return(SiloHostBuilder
.CreateDefault()
.UseConfiguration(clusterConfiguration)
.ConfigureSiloName(siloName)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IRuntimeCodeGenGrain).Assembly).WithCodeGeneration()));
}
public ExceptionTests()
{
this.silo = SiloHostBuilder.CreateDefault().ConfigureApplicationParts(parts => parts.AddFromAppDomain()).ConfigureLocalHostPrimarySilo().Build();
this.silo.StartAsync().GetAwaiter().GetResult();
this.client = ClientBuilder.CreateDefault().ConfigureApplicationParts(parts => parts.AddFromAppDomain()).UseConfiguration(ClientConfiguration.LocalhostSilo()).Build();
this.client.Connect().GetAwaiter().GetResult();
}
public void SiloHostBuilder_NullConfigurationTest()
{
var builder = SiloHostBuilder.CreateDefault()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory().AddFromAppDomain())
.ConfigureServices(RemoveConfigValidators);
Assert.Throws <ArgumentNullException>(() => builder.UseConfiguration(null));
}
public void SiloHostBuilder_DoubleSpecifyConfigurationTest()
{
var builder = SiloHostBuilder.CreateDefault()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory().AddFromAppDomain())
.ConfigureServices(RemoveConfigValidators).UseConfiguration(new ClusterConfiguration()).UseConfiguration(new ClusterConfiguration());
Assert.Throws <InvalidOperationException>(() => builder.Build());
}
private static async Task <ISiloHost> StartSilo()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
var invariant = "System.Data.SqlClient";
var connectionString = config.GetConnectionString("DefaultConnectionString");
var assambly = typeof(Program).Assembly;
var builder = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "SettlementClusterID";
options.ServiceId = "settlementServiceID";
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(assambly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.ConfigureAppConfiguration(context =>
{
context.AddConfiguration(config);
})
.UseInMemoryReminderService()
//依赖注入
.UseServiceProviderFactory(opt =>
{
opt.AddTransient <ISettlementRepository, SettlementRepository>();
return(opt.BuildServiceProvider());
})
//use AdoNet for clustering
.UseAdoNetClustering(options =>
{
options.Invariant = invariant;
options.ConnectionString = connectionString;
})
//use AdoNet for reminder service
.UseAdoNetReminderService(options =>
{
options.Invariant = invariant;
options.ConnectionString = connectionString;
})
//use AdoNet for Persistence
.AddAdoNetGrainStorage("SettlementStore", options =>
{
options.Invariant = invariant;
options.ConnectionString = connectionString;
});
var host = builder.Build();
await host.StartAsync();
return(host);
}
public static void Main(string[] args)
{
var siloPort = 11111;
int gatewayPort = 30000;
var siloAddress = IPAddress.Loopback;
var silo =
new SiloHostBuilder()
.UseDashboard(options =>
{
options.HostSelf = true;
options.HideTrace = false;
})
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(siloAddress, siloPort))
.UseInMemoryReminderService()
.ConfigureEndpoints(siloAddress, siloPort, gatewayPort)
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "helloworldcluster";
options.ServiceId = "1";
})
.ConfigureApplicationParts(appParts => appParts.AddApplicationPart(typeof(TestCalls).Assembly))
.ConfigureLogging(builder =>
{
builder.AddConsole();
})
.Build();
silo.StartAsync().Wait();
var client =
new ClientBuilder()
.UseStaticClustering(options => options.Gateways.Add((new IPEndPoint(siloAddress, gatewayPort)).ToGatewayUri()))
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "helloworldcluster";
options.ServiceId = "1";
})
.ConfigureApplicationParts(appParts => appParts.AddApplicationPart(typeof(TestCalls).Assembly))
.ConfigureLogging(builder =>
{
builder.AddConsole();
})
.Build();
client.Connect().Wait();
var cts = new CancellationTokenSource();
TestCalls.Make(client, cts);
Console.WriteLine("Press key to exit...");
Console.ReadLine();
cts.Cancel();
silo.StopAsync().Wait();
}
private static async Task <int> RunMainAsync(string[] args)
{
try
{
Console.WriteLine("Configuring local silo...");
Channel channel = new Channel("127.0.0.1:9998", ChannelCredentials.Insecure); // TODO: Make the ip configurable.
var builder = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "EthereumBlockChainHarvester";
})
.ConfigureApplicationParts(parts => parts
.AddApplicationPart(typeof(BlockChainExtractor).Assembly)
.WithReferences()) //TODO: Load the assembly in some other way so we are not dependent on the implementation project.
.ConfigureLogging(logging => logging.AddConsole())
.ConfigureServices(((context, services) => {
services.AddSingleton <Channel>(sc => channel);
// TODO: Find if these will work without a factory.
services.AddSingleton <Scynet.Subscriber.SubscriberClient>(sc => new Scynet.Subscriber.SubscriberClient(channel));
services.AddSingleton <Scynet.Publisher.PublisherClient>(sc => new Scynet.Publisher.PublisherClient(channel));
services.AddSingleton <Scynet.Hatchery.HatcheryClient>(sc => new Scynet.Hatchery.HatcheryClient(channel));
}))
.AddSimpleMessageStreamProvider("SMSProvider")
.AddMemoryGrainStorageAsDefault()
.AddMemoryGrainStorage("PubSubStore");
var host = builder.Build();
Console.WriteLine("Running...");
await host.StartAsync();
Console.WriteLine("Yay, everything worked!");
Console.WriteLine("\nPress Enter to terminate...\n");
Console.ReadLine();
await host.StopAsync();
return(0);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(1);
}
}
public void SiloHostBuilder_DoubleSpecifyConfigurationTest()
{
var builder = new SiloHostBuilder().ConfigureDefaults()
.ConfigureServices(RemoveConfigValidatorsAndSetAddress)
.UseConfiguration(new ClusterConfiguration())
.UseConfiguration(new ClusterConfiguration());
Assert.Throws <InvalidOperationException>(() => builder.Build());
}
