static async Task Main(string[] args)
{
var host = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory())
.UseLocalhostClustering()
.Build();
await host.StartAsync();
Console.CancelKeyPress += async(sender, eventArgs) => await ShutdownAsync(host);
AssemblyLoadContext.Default.Unloading += async context => await ShutdownAsync(host);
Console.WriteLine("Press any key.");
Console.ReadLine();
}
/// <summary>
/// 启动本地配置
/// </summary>
/// <returns></returns>
private static async Task <ISiloHost> StartSilo()
{
var host = new SiloHostBuilder()
.UseLocalhostClustering() //配置Silo只使用开发集群，并监听本地主机。
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "MyHost"; //获取或设置此服务的唯一标识符，该标识符应在部署和重新部署后仍然有效
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback) //配置Silo的端口
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Student).Assembly).WithReferences())
.Build();
await host.StartAsync();//启动当前Silo.
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
var host = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options => {
options.ClusterId = "dev";
options.ServiceId = "Orleans_Basic";
})
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
await host.StartAsync();
return(host);
}
static async Task Main(string[] args)
{
var host = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory())
.UseLocalhostClustering()
.Configure <SchedulingOptions>(options => options.AllowCallChainReentrancy = false)
.ConfigureLogging(builder => builder.AddConsole())
.Build();
await host.StartAsync();
Console.WriteLine("Press any key...");
Console.ReadLine();
await host.StopAsync();
}
private static void StartSiloHost()
{
var siloHost = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(EchoGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
siloHost.StartAsync().ConfigureAwait(false).GetAwaiter().GetResult();
siloHost.Stopped.ConfigureAwait(false).GetAwaiter().GetResult();
}
public static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
//单台服务器上模拟多个Silo集群
Random rd = new Random();
var siloPort = rd.Next(40001, 50000);
var gatewayPort = rd.Next(30003, 40000);
var silo = new SiloHostBuilder()
//.Configure<EndpointOptions>(options =>
//{
// options.AdvertisedIPAddress = IPAddress.Loopback;
//})
.ConfigureEndpoints(siloPort: siloPort, gatewayPort: gatewayPort, listenOnAnyHostAddress: true, advertisedIP: IPAddress.Loopback)
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "excelapp";
})
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(ExcelGrain).Assembly).WithReferences())
.UseAdoNetClustering(option =>
{
option.ConnectionString = config["ConnectionStrings:OrleansCluster"];
option.Invariant = "MySql.Data.MySqlClient";
})
.AddAdoNetGrainStorageAsDefault(option =>
{
option.Invariant = "MySql.Data.MySqlClient";
option.ConnectionString = config["ConnectionStrings:OrleansGrain"];
})
.ConfigureLogging(logging => logging.AddConsole())
.Build();
Console.WriteLine("Starting");
await silo.StartAsync();
Console.WriteLine("Started");
Console.ReadKey();
Console.WriteLine("Shutting down");
await silo.StopAsync();
}
public static void Main(string[] args)
{
var configuration =
ClusterConfiguration.LocalhostPrimarySilo(33333)
.RegisterDashboard();
var silo =
new SiloHostBuilder()
.UseConfiguration(configuration)
.UseDashboard(options =>
{
options.HostSelf = true;
options.HideTrace = false;
})
.ConfigureApplicationParts(appParts => appParts.AddApplicationPart(typeof(TestCalls).Assembly))
.ConfigureLogging(builder =>
{
builder.AddConsole();
})
.Build();
silo.StartAsync().Wait();
var client =
new ClientBuilder()
.UseConfiguration(ClientConfiguration.LocalhostSilo())
.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();
}
static void Main()
{
ISiloHost build = new SiloHostBuilder()
//使用本地化构造，注意集群启动必须有不同的 SiloPort, GatewayPort
.UseLocalhostClustering(siloPort: 11112, gatewayPort: 30001)
//配置数据库持久化
.UseMongoDBClient(connectionString)
//"WMSTileCache" 内部编号
.AddMongoDBGrainStorage("WMSTileCache", options =>
{
//在MongoDB中构建的数据库名字
options.DatabaseName = "WMS";
options.CreateShardKeyForCosmos = false;
options.ConfigureJsonSerializerSettings = settings =>
{
settings.NullValueHandling = NullValueHandling.Include;
settings.ObjectCreationHandling = ObjectCreationHandling.Replace;
settings.DefaultValueHandling = DefaultValueHandling.Populate;
};
})
.AddMongoDBGrainStorage("WMSLogCache", options =>
{
options.DatabaseName = "WMS";
options.CreateShardKeyForCosmos = false;
options.ConfigureJsonSerializerSettings = settings =>
{
settings.NullValueHandling = NullValueHandling.Include;
settings.ObjectCreationHandling = ObjectCreationHandling.Replace;
settings.DefaultValueHandling = DefaultValueHandling.Populate;
};
})
//配置集群
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "Cluster";
})
.ConfigureLogging(logging => logging.AddConsole())
.Build();
//
build.StartAsync().Wait();
Console.ReadKey();
}
private static async Task <ISiloHost> StartSilo()
{
// define the cluster configuration
var siloPort = 11111;
var gatewayPort = 30000;
var siloAddress = IPAddress.Loopback;
var host = new SiloHostBuilder()
.Configure(options => options.ClusterId = "google-hashcode-2018")
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(siloAddress, siloPort))
.ConfigureEndpoints(siloAddress, siloPort, gatewayPort)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(TreeGrain <>).Assembly).WithReferences())
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(MakeRideAction).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
await host.StartAsync();
return(host);
}
public static async Task <TestCluster> Create()
{
var primarySilo = new SiloHostBuilder()
.UseLocalhostClustering(siloPort: 11111, gatewayPort: 30000)
.Configure <ClusterMembershipOptions>(options =>
{
options.ExpectedClusterSize = 2;
options.UseLivenessGossip = true;
options.ProbeTimeout = TimeSpan.FromSeconds(5);
options.NumMissedProbesLimit = 3;
})
.ConfigureStreamsAndLogging()
.Build();
var secondarySilo = new SiloHostBuilder()
.UseLocalhostClustering(siloPort: 11112, gatewayPort: 30001,
primarySiloEndpoint: new IPEndPoint(IPAddress.Loopback, EndpointOptions.DEFAULT_SILO_PORT))
.Configure <ClusterMembershipOptions>(options =>
{
options.ExpectedClusterSize = 2;
options.UseLivenessGossip = true;
options.ProbeTimeout = TimeSpan.FromSeconds(5);
options.NumMissedProbesLimit = 3;
})
.ConfigureStreamsAndLogging()
.Build();
var client = new ClientBuilder()
.UseLocalhostClustering(gatewayPorts: new[] { 30000, 30001 })
.ConfigureStreamsAndLogging()
.Build();
await primarySilo.StartAsync();
await secondarySilo.StartAsync();
// wait for the cluster to stabilize; otherwise only one silo could send & process all messages
await Task.Delay(TimeSpan.FromMinutes(1));
await client.Connect();
return(new TestCluster(primarySilo, secondarySilo, client));
}
static void Main(string[] args)
{
var host = new SiloHostBuilder()
.UseLocalhostClustering()
.AddMinioGrainStorage("minio", options =>
{
options.AccessKey = "";
options.SecretKey = "";
options.Endpoint = "localhost:9000";
options.Container = "grain-storage";
})
.ConfigureApplicationParts(partManager => partManager.AddApplicationPart(typeof(MySuperGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
host.StartAsync().Wait();
Console.WriteLine("Silo started");
Console.ReadKey();
}
private static async Task <ISiloHost> StartSilo()
{
var host = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
})
//.ConfigureEndpoints()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
await host.StartAsync();
return(host);
}
private static async Task <ISiloHost> StartSilo()
{
Console.WriteLine("Starting silo");
// define the cluster configuration
var host = new SiloHostBuilder()
.UseLocalhostClustering()
.AddMemoryGrainStorageAsDefault()
.UseDashboard()
.ConfigureLogging(logging => {
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Warning);
})
.Build();
await host.StartAsync();
return(host);
}
public static async Task <IClusterClient> Start(CancellationToken cancellationToken)
{
var thisAssembly = typeof(OrleansHost).Assembly;
var host = new SiloHostBuilder()
.ConfigureHostConfiguration(builder => builder.AddJsonFile("appsettings.json"))
.AddMemoryGrainStorageAsDefault()
.AddMemoryGrainStorage("PubSubStore")
.AddSimpleMessageStreamProvider(Constants.STREAM_PROVIDER, DefaultSMSSettings)
.AddStartupTask <LoadSubscriptionsTask>()
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.UseInMemoryReminderService()
.ConfigureLogging((context, logging) =>
{
logging.AddConfiguration(context.Configuration.GetSection("Logging"));
logging.AddConsole();
})
.ConfigureApplicationParts(appPartManager =>
{
appPartManager.AddApplicationPart(thisAssembly).WithCodeGeneration();
})
.ConfigureServices(services =>
{
services.AddSingleton(new HttpClient());
})
.Build();
await host.StartAsync(cancellationToken);
var client = new ClientBuilder()
.ConfigureHostConfiguration(builder => builder.AddJsonFile("appsettings.json"))
.UseLocalhostClustering()
.ConfigureApplicationParts(appPartManager =>
{
appPartManager.AddApplicationPart(thisAssembly).WithCodeGeneration();
})
.Build();
await client.Connect();
return(client);
}
static async Task Main(string[] args)
{
var host = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory())
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "local";
options.ServiceId = "HelloWorld";
})
.ConfigureLogging(builder => builder.AddConsole())
.Build();
await host.StartAsync();
Console.WriteLine("Press any key...");
Console.ReadLine();
await host.StopAsync();
}
static async Task Main(string[] args)
{
var host = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory())
.UseLocalhostClustering()
.ConfigureLogging(builder => builder.AddConsole())
.ConfigureServices(services =>
{
services.AddTransient(provider => HelloComponent.Create(provider.GetRequiredService <IGrainActivationContext>()));
})
.Build();
await host.StartAsync();
Console.WriteLine("Press any key...");
Console.ReadLine();
await host.StopAsync();
}
public OrleansFixture()
{
var silo = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.UseSignalR()
.Build();
silo.StartAsync().Wait();
this.Silo = silo;
var client = new ClientBuilder()
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.UseSignalR()
.Build();
client.Connect().Wait();
this.ClientProvider = new DefaultClusterClientProvider(client);
}
static async Task Main(string[] args)
{
Console.WriteLine("Running demo. Booting cluster might take some time ...\n");
var host = new SiloHostBuilder()
.Configure <ClusterOptions>(options => options.ClusterId = DemoClusterId)
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(LocalhostSiloAddress, LocalhostSiloPort))
.ConfigureEndpoints(LocalhostSiloAddress, LocalhostSiloPort, LocalhostGatewayPort)
.ConfigureApplicationParts(x => x
.AddApplicationPart(Assembly.GetExecutingAssembly())
.AddApplicationPart(typeof(Join).Assembly)
.WithCodeGeneration())
.UseOrleankka()
.Build();
await host.StartAsync();
Console.WriteLine("Finished booting cluster...");
Console.ReadLine();
}
private static async Task <ISiloHost> StartSilo()
{
// define the cluster configuration
ISiloHost host = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "Theory";
})
.AddMemoryGrainStorageAsDefault()
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(UserStoreGrain).Assembly).WithReferences())
.ConfigureServices(x => x.AddDbContext <DataContext>(options => options.UseSqlite("Data Source=../TheoryEngineers.AspServer/Test.db")))
.ConfigureLogging(x => x.AddConsole())
.Build();
await host.StartAsync();
return(host);
}
public async Task LocalhostClusterTest()
{
using var portAllocator = new TestClusterPortAllocator();
var(baseSiloPort, baseGatewayPort) = portAllocator.AllocateConsecutivePortPairs(2);
var silo1 = new SiloHostBuilder()
.AddMemoryGrainStorage("MemoryStore")
.UseLocalhostClustering(baseSiloPort, baseGatewayPort)
.Build();
var silo2 = new SiloHostBuilder()
.AddMemoryGrainStorage("MemoryStore")
.UseLocalhostClustering(baseSiloPort + 1, baseGatewayPort + 1, new IPEndPoint(IPAddress.Loopback, baseSiloPort))
.Build();
var client = new ClientBuilder()
.UseLocalhostClustering(new[] { baseGatewayPort, baseGatewayPort + 1 })
.Build();
try
{
await Task.WhenAll(silo1.StartAsync(), silo2.StartAsync());
await client.Connect();
var grain = client.GetGrain <IEchoGrain>(Guid.NewGuid());
var result = await grain.Echo("test");
Assert.Equal("test", result);
}
finally
{
var cancelled = new CancellationTokenSource();
cancelled.Cancel();
Utils.SafeExecute(() => silo1.StopAsync(cancelled.Token));
Utils.SafeExecute(() => silo2.StopAsync(cancelled.Token));
Utils.SafeExecute(() => silo1.Dispose());
Utils.SafeExecute(() => silo2.Dispose());
Utils.SafeExecute(() => client.Close());
Utils.SafeExecute(() => client.Dispose());
}
}
public OrleansFixture()
{
var silo = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.AddMemoryGrainStorage(Constants.PUBSUB_PROVIDER)
.UseSignalR()
.Build();
silo.StartAsync().Wait();
Silo = silo;
var client = new ClientBuilder()
.UseLocalhostClustering()
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.UseSignalR()
.Build();
client.Connect().Wait();
ClientProvider = new DefaultClusterClientProvider(client);
}
public static void Main(string[] args)
{
var siloHost = new SiloHostBuilder()
.UseLocalhostClustering(8000, 3500)
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "UniqueIdentifierToFindSilo";
options.ServiceId = "HelloWorldApp";
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Hello).Assembly).WithReferences())
.ConfigureLogging(logging => logging.AddConsole())
.Build();
siloHost.StartAsync().Wait();
Console.WriteLine("Press a button to stop silo");
Console.ReadLine();
siloHost.StopAsync().Wait();
}
public async Task LocalhostClusterTest()
{
var silo1 = new SiloHostBuilder()
.AddMemoryGrainStorage("MemoryStore")
.UseLocalhostClustering(12111, 30001)
.Build();
var silo2 = new SiloHostBuilder()
.AddMemoryGrainStorage("MemoryStore")
.UseLocalhostClustering(12112, 30002, new IPEndPoint(IPAddress.Loopback, 12111))
.Build();
var client = new ClientBuilder()
.UseLocalhostClustering(new[] { 30001, 30002 })
.Build();
try
{
await Task.WhenAll(silo1.StartAsync(), silo2.StartAsync());
await client.Connect();
var grain = client.GetGrain <IEchoGrain>(Guid.NewGuid());
var result = await grain.Echo("test");
Assert.Equal("test", result);
}
finally
{
var cancelled = new CancellationTokenSource();
cancelled.Cancel();
Utils.SafeExecute(() => silo1.StopAsync(cancelled.Token));
Utils.SafeExecute(() => silo2.StopAsync(cancelled.Token));
Utils.SafeExecute(() => silo1.Dispose());
Utils.SafeExecute(() => silo2.Dispose());
Utils.SafeExecute(() => client.Close());
Utils.SafeExecute(() => client.Dispose());
}
}
/// <summary>
/// 启动本地配置
/// </summary>
/// <returns></returns>
private static async Task <ISiloHost> StartSilo()
{
var host = new SiloHostBuilder()
.UseLocalhostClustering() //配置Silo只使用开发集群，并监听本地主机。
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "MyHost"; //获取或设置此服务的唯一标识符，该标识符应在部署和重新部署后仍然有效
})
.Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback) //配置Silo的端口
//.Configure<EndpointOptions>(options =>
//{
// // Port to use for Silo-to-Silo
// options.SiloPort = 11111;
// // Port to use for the gateway
// options.GatewayPort = 30000;
// // IP Address to advertise in the cluster
// options.AdvertisedIPAddress = IPAddress.Loopback;
// // The socket used for silo-to-silo will bind to this endpoint
// options.GatewayListeningEndpoint = new IPEndPoint(IPAddress.Any, 40000);
// // The socket used by the gateway will bind to this endpoint
// options.SiloListeningEndpoint = new IPEndPoint(IPAddress.Any, 50000);
//})//配置Silo的端口
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(Student).Assembly).WithReferences())
//.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory())
.UseDashboard(options => {
options.Username = "******";
options.Password = "******";
options.Host = "*";
options.Port = 8080;
options.HostSelf = true;
options.CounterUpdateIntervalMs = 1000;
}) //注册Dashboard，具体信息见：https://github.com/OrleansContrib/OrleansDashboard
.UsePerfCounterEnvironmentStatistics() //添加主机CPU和内存监控
.Build();
await host.StartAsync(); //启动当前Silo.
return(host);
}
static async Task Main(string[] args)
{
var codeGenLogger = LoggerFactory.Create(builder => builder.AddConsole());
var host = new SiloHostBuilder()
.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory().WithCodeGeneration(codeGenLogger))
.UseLocalhostClustering()
.Build();
Console.CancelKeyPress += async(sender, eventArgs) => await ShutdownAsync(host);
AssemblyLoadContext.Default.Unloading += async context => await ShutdownAsync(host);
await host.StartAsync();
foreach (var grain in host.Services.GetServices <IGrain>())
{
Console.WriteLine($"Grain: {grain.GetGrainIdentity()}");
}
Console.WriteLine("Press any key.");
Console.ReadLine();
}
static void Main(string[] args)
{
var silo = 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())
.AddMemoryGrainStorage("PubSubStorage")
.AddSimpleMessageStreamProvider(Constants.ChatRoomStreamNameProvider)
.Build();
silo.StartAsync().Wait();
Console.WriteLine("Press enter to close.");
Console.ReadLine();
// shut the silo down after we are done.
silo.StopAsync().Wait();
}
private static async Task <ISiloHost> StartSilo()
{
var silo = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "stock-stream-cluster";
options.ServiceId = "StockTickerApp";
})
.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000)
.ConfigureApplicationParts(parts =>
parts.AddApplicationPart(typeof(StocksStreamingGrain).Assembly).WithReferences())
.ConfigureLogging(logging =>
logging
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddConsole())
.Build();
await silo.StartAsync();
return(silo);
}
static async Task Main(string[] args)
{
const string connectionString = "server=<hostname or IP>;uid=<type username here>;pwd=<type pwd here>;database=orleanstest;SslMode=none";
var silo = new SiloHostBuilder()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "Orleans2GettingStarted2";
})
.UseAdoNetClustering(options =>
{
options.ConnectionString = connectionString;
options.Invariant = "MySql.Data.MySqlClient";
})
.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000)
.ConfigureLogging(builder => builder.SetMinimumLevel(LogLevel.Warning).AddConsole())
.Build();
await silo.StartAsync();
Console.ReadLine();
}
public static async Task Main(string[] args)
{
var host = new SiloHostBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "OrleansBasics";
})
.ConfigureApplicationParts(
parts => parts.AddApplicationPart(typeof(Arithmetic).Assembly)
.WithReferences()
)
.ConfigureLogging(log => log.AddConsole())
.Build();
await host.StartAsync();
Console.WriteLine("Press Enter to terminate...\n\n");
Console.ReadLine();
await host.StopAsync();
}
public static async Task Main()
{
WriteLine("Running example. Booting cluster might take some time ...\n");
var host = new SiloHostBuilder()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = DemoClusterId;
options.ServiceId = DemoServiceId;
})
.UseDevelopmentClustering(options => options.PrimarySiloEndpoint = new IPEndPoint(LocalhostSiloAddress, LocalhostSiloPort))
.ConfigureEndpoints(LocalhostSiloAddress, LocalhostSiloPort, LocalhostGatewayPort)
.ConfigureApplicationParts(x => x
.AddApplicationPart(Assembly.GetExecutingAssembly())
.WithCodeGeneration())
.UseOrleankka()
.Build();
await host.StartAsync();
var client = new ClientBuilder()
.Configure <ClusterOptions>(options => options.ClusterId = DemoClusterId)
.UseStaticClustering(options => options.Gateways.Add(new IPEndPoint(LocalhostSiloAddress, LocalhostGatewayPort).ToGatewayUri()))
.ConfigureApplicationParts(x => x
.AddApplicationPart(Assembly.GetExecutingAssembly())
.WithCodeGeneration())
.UseOrleankka()
.Build();
await client.Connect();
var greeter = client.ActorSystem().ActorOf <IGreeter>("id");
await greeter.Tell(new Greet { Who = "world" });
Write("\n\nPress any key to terminate ...");
ReadKey(true);
}
