public ValuesController() { if (host == null) { host = SiloWrapper.Instance.host; } if (client == null) { client = ClientWrapper.Instance.client; } }
private void CreateClusteredSiloHost() { var silo = new SiloHostBuilder() .Configure <ClusterOptions>(options => { options.ClusterId = orleansConfig.ClusterId; options.ServiceId = orleansConfig.ServiceId; }); string storageType = GetStorageType(orleansConfig.DataConnectionString); if (storageType.ToLowerInvariant() == "redis") { silo.UseRedisMembership(options => options.ConnectionString = orleansConfig.DataConnectionString); silo.AddRedisGrainStorage("store", options => options.ConnectionString = orleansConfig.DataConnectionString); } else if (storageType.ToLowerInvariant() == "azurestorage") { silo.UseAzureStorageClustering(options => options.ConnectionString = orleansConfig.DataConnectionString); silo.AddAzureBlobGrainStorage("store", options => options.ConnectionString = orleansConfig.DataConnectionString); } else { //throw } silo.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000); LogLevel orleansLogLevel = GetLogLevel(); var loggers = orleansConfig.GetLoggerTypes(); silo.ConfigureLogging(builder => { if (loggers.HasFlag(LoggerType.Console)) { builder.AddConsole(); } if (loggers.HasFlag(LoggerType.Debug)) { builder.AddDebug(); } builder.SetMinimumLevel(orleansLogLevel); }); if (loggers.HasFlag(LoggerType.AppInsights) && !string.IsNullOrEmpty(orleansConfig.AppInsightsKey)) { silo.AddApplicationInsightsTelemetryConsumer(orleansConfig.AppInsightsKey); } host = silo.Build(); //var clusterClient = (IClusterClient)host.Services.GetService(typeof(IClusterClient)); }
private static async Task RunMainAsync(string[] args) { try { _startupStopwatch = Stopwatch.StartNew(); _hostingEnv = new HostingEnvironment(); var shortEnvName = AppInfo.MapEnvironmentName(_hostingEnv.Environment); var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddCommandLine(args) .AddJsonFile("config.json") .AddJsonFile($"config.{shortEnvName}.json") .AddJsonFile("app-info.json") .AddEnvironmentVariables(); if (_hostingEnv.IsDockerDev) { configBuilder.AddJsonFile("config.dev-docker.json", optional: true); } var config = configBuilder.Build(); var appInfo = new AppInfo(config); Console.Title = $"Silo - {appInfo.Name}"; var logger = LoggingConfig.Configure(config, appInfo) .CreateLogger(); Log.Logger = logger; _log = logger.ForContext <Program>(); _log.Information("Initializing Silo {appName} ({version}) [{env}]...", appInfo.Name, appInfo.Version, _hostingEnv.Environment); _siloHost = BuildSilo(config, appInfo, logger); AssemblyLoadContext.Default.Unloading += context => { _log.Information("Assembly unloading..."); Task.Run(StopSilo); SiloStopped.WaitOne(); _log.Information("Assembly unloaded complete."); Log.CloseAndFlush(); }; await StartSilo(); } catch (Exception ex) { _log.Error(ex, "An error has occurred while initializing or starting silo."); Log.CloseAndFlush(); } }
/// <summary>Creates and initializes a silo in the current app domain.</summary> /// <param name="name">Name of this silo.</param> /// <param name="siloBuilderFactoryType">Type of silo host builder factory.</param> /// <param name="config">Silo config data to be used for this silo.</param> public AppDomainSiloHost(string name, Type siloBuilderFactoryType, ClusterConfiguration config) { var builderFactory = (ISiloBuilderFactory)Activator.CreateInstance(siloBuilderFactoryType); ISiloHostBuilder builder = builderFactory .CreateSiloBuilder(name, config) .ConfigureServices(services => services.AddSingleton <TestHooksSystemTarget>()) .AddApplicationPartsFromAppDomain() .AddApplicationPartsFromBasePath(); this.host = builder.Build(); InitializeTestHooksSystemTarget(); this.AppDomainTestHook = new AppDomainTestHooks(this.host); }
static async Task RunAsync(ISiloHost silo, IClusterClient client, string mapFileName) { await silo.StartAsync(); await client.Connect(); Console.WriteLine("Map file name is '{0}'.", mapFileName); Console.WriteLine("Setting up Adventure, please wait ..."); Adventure adventure = new Adventure(client); adventure.Configure(mapFileName).Wait(); Console.WriteLine("Adventure setup completed."); }
public TestHooksSystemTarget( ISiloHost host, ILocalSiloDetails siloDetails, ILoggerFactory loggerFactory, TestHooksHostEnvironmentStatistics hostEnvironmentStatistics, IOptions <LoadSheddingOptions> loadSheddingOptions) : base(Constants.TestHooksSystemTargetId, siloDetails.SiloAddress, loggerFactory) { this.host = host; this.hostEnvironmentStatistics = hostEnvironmentStatistics; this.loadSheddingOptions = loadSheddingOptions.Value; this.consistentRingProvider = this.host.Services.GetRequiredService <IConsistentRingProvider>(); }
public void InstantiateSilo() { siloHost = new SiloHostBuilder() .UseLocalhostClustering() .UseDashboard() .AddMemoryGrainStorageAsDefault() .UseInMemoryReminderService() .AddSimpleMessageStreamProvider("default", options => options.FireAndForgetDelivery = true) .AddMemoryGrainStorage("PubSubStore") .ConfigureApplicationParts(partManager => partManager.AddApplicationPart(typeof(AccountGrain).Assembly).WithReferences()) .ConfigureLogging(logging => logging.AddSerilog()) .Build(); }
/// <summary> /// Starts the service. /// </summary> public void Start() { try { this.siloHost = this.StartSilo(); this.siloHost.StartAsync(this.cancellationToken); } catch (Exception ex) { this.logger.Error("Start of the silo host failed: {ex}.", ex); throw; } }
public static async Task <IServiceCollection> AddOrleansClusterClient(this IServiceCollection services, IConfiguration configuration) { ISiloHost siloHost = BuildSiloHost(configuration); await siloHost.StartAsync(); var client = siloHost.Services.GetRequiredService <IClusterClient>(); return (services .AddSingleton <ISiloHost>(siloHost) // in order to be disposed correctly .AddSingleton <IClusterClient>(client) .AddSingleton <IGrainFactory>(client)); }
private static void StartSilo() { var config = new SiloHost(Dns.GetHostName(), new FileInfo("OrleansConfiguration.xml")); if (Environment.GetEnvironmentVariable("LAUCHING_ENV") == "LOCALHOST") { config.Config = ClusterConfiguration.LocalhostPrimarySilo(); config.Config.AddMemoryStorageProvider("RedisStore"); } else { config.Config.Globals.MembershipTableAssembly = typeof(Orleans.ConsulUtils.LegacyConsulGatewayListProviderConfigurator).Assembly.FullName; var consulIps = Dns.GetHostAddressesAsync("consul").Result; config.Config.Globals.DataConnectionString = $"http://{consulIps.First()}:8500"; config.Config.Globals.LivenessType = GlobalConfiguration.LivenessProviderType.Custom; var ips = Dns.GetHostAddressesAsync(Dns.GetHostName()).Result; config.Config.Defaults.HostNameOrIPAddress = ips.FirstOrDefault()?.ToString(); config.Config.Globals.RegisterStorageProvider <Orleans.StorageProviders.RedisStorage.RedisStorage>( "RedisStore", new Dictionary <string, string>() { { "RedisConnectionString", "storage" }, { "UseJsonFormat", "false" } }); } config.Config.Globals.ClusterId = "DDBMSP-Cluster"; config.Config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.Disabled; config.Config.Globals.SerializationProviders.Add(typeof(ProtobufSerializer).GetTypeInfo()); config.Config.RegisterDashboard(); var builder = SiloHostBuilder.CreateDefault().UseConfiguration(config.Config); builder.GetApplicationPartManager() .AddApplicationPart(typeof(Common.CSharpRepl.Context).Assembly) .AddApplicationPart(typeof(ArticleState).Assembly) .AddFromApplicationBaseDirectory() .AddApplicationPart(typeof(Interfaces.Grains.Aggregators.IAggregator <>).Assembly); SiloHost = builder.ConfigureSiloName(Dns.GetHostName()) .UseDashboard(options => { options.HostSelf = true; options.Port = 8080; options.Host = "*"; }) .Build(); SiloHost.StartAsync(); }
private async Task StartServer() { if (Host == null) { var builder = new SiloHostBuilder() .UseAdoNetClustering(config => config.Configure(options => { options.ConnectionString = Settings.Default.Database; options.Invariant = "System.Data.SqlClient"; })) .Configure <ClusterOptions>(config => { config.ClusterId = "development"; config.ServiceId = "calculator"; }) .Configure <SerializationProviderOptions>(config => { config.SerializationProviders.Clear(); config.SerializationProviders.Add(typeof(BondSerializer)); config.FallbackSerializationProvider = typeof(BinaryFormatterSerializer); }) .Configure <EndpointOptions>(config => { config.AdvertisedIPAddress = IPAddress.Loopback; config.GatewayPort = (int)nPort.Value; config.SiloPort = (int)nPort.Value + 10000; }) .AddAdoNetGrainStorage("SQLServer", config => config.Configure(options => { options.ConnectionString = Settings.Default.Database; options.Invariant = "System.Data.SqlClient"; options.UseJsonFormat = true; })) .AddRedisGrainStorage("Redis", config => config.Configure(options => { options.ConnectionString = "127.0.0.1:6379"; options.UseJson = true; options.DatabaseNumber = 1; })) .ConfigureApplicationParts(parts => { parts.AddApplicationPart(typeof(IStatistics).Assembly).WithReferences(); parts.AddApplicationPart(typeof(Statistics).Assembly).WithReferences(); }); //.ConfigureLogging(logging => logging.AddConsole()); Host = builder.Build(); await Host.StartAsync(); } }
internal static async Task Main(string[] args) { var currentDirectory = Directory.GetCurrentDirectory(); var configDirectory = Path.Combine(currentDirectory, "..", "config"); IConfigurationBuilder builder = new ConfigurationBuilder() .SetBasePath(configDirectory) .AddJsonFile("db-settings.json"); Configuration = builder.Build(); string orleDbConnection = Configuration.GetConnectionString("OrleDb"); string persistenceConnection = Configuration.GetConnectionString("BloggingContext"); string invariant = "Npgsql"; await Task.WhenAll(WaitUntilReady(orleDbConnection), WaitUntilReady(persistenceConnection)); var siloHostBuilder = new SiloHostBuilder() .Configure <ClusterOptions>(options => { options.ClusterId = "PoC.Blog.BloggingCluster"; options.ServiceId = "PoC.Blog.SiloHost"; }) .UseAdoNetClustering(options => { options.ConnectionString = orleDbConnection; options.Invariant = invariant; }) .AddAdoNetGrainStorageAsDefault(delegate(AdoNetGrainStorageOptions options) { options.Invariant = invariant; options.ConnectionString = persistenceConnection; options.UseJsonFormat = true; }) .ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000) .ConfigureLogging(loggingBuilder => { loggingBuilder.SetMinimumLevel(LogLevel.Information).AddFile("log.info.txt"); loggingBuilder.SetMinimumLevel(LogLevel.Debug).AddFile("log.debug.txt"); }) .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(UserRegistry).Assembly).WithReferences()); ISiloHost host = siloHostBuilder.Build(); await host.StartAsync(); Console.WriteLine("Silo started"); await Task.Delay(TimeSpan.FromTicks(int.MaxValue)); }
private static async Task <ISiloHost> StartSilo(AppConfig configuration) { ISiloHostBuilder builder = new SiloHostBuilder() .ConfigureAppConfiguration(config => { }) .Configure <ClusterOptions>(options => { options.ClusterId = "InvestorApp"; options.ServiceId = "Backend"; }) .UseAdoNetClustering(options => { options.Invariant = "Npgsql"; options.ConnectionString = configuration.ConnectionStrings[Constants.System]; }) .Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback) .ConfigureLogging(logging => logging.AddNLog(new NLogProviderOptions { CaptureMessageTemplates = true, CaptureMessageProperties = true })) .ConfigureServices(services => { services.AddSingleton <AppConfig>(configuration); }) .AddGenericGrainStorage <AssetStorageProvider>(nameof(AssetStorageProvider), opt => { opt.Configure(options => { options.ConnectionString = configuration.ConnectionStrings[Constants.Billing]; }); }) .Configure <GrainVersioningOptions>(options => { options.DefaultCompatibilityStrategy = nameof(BackwardCompatible); options.DefaultVersionSelectorStrategy = nameof(MinimumVersion); }) .ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory().WithReferences()) .UseDashboard(options => { //options.Username = "******"; //options.Password = "******"; options.Host = "*"; options.Port = 3128; options.HostSelf = true; options.CounterUpdateIntervalMs = 5000; }); ISiloHost host = builder.Build(); await host.StartAsync(); return(host); }
static void Main(string[] args) { Console.WriteLine("##### Starting Silo..."); var siloPort = 11111; var gatewayPort = 30000; // get the config data needed for Orleans silo. We tend tend to favour Azure table storage, and include a sample appsettings.Sample.json file. // for more info on configuration in ASP.NET Core see https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?tabs=basicconfiguration var appSettingsBuilder = new ConfigurationBuilder() .SetBasePath(System.IO.Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables(); IConfigurationRoot appSettings = appSettingsBuilder.Build(); // start the silo // see https://dotnet.github.io/orleans/Documentation/Deployment-and-Operations/Configuration-Guide/Typical-Configurations.html silo = new SiloHostBuilder() .Configure <ProcessExitHandlingOptions>(options => { options.FastKillOnProcessExit = true; }) .Configure <ClusterOptions>(options => { options.ClusterId = appSettings["Orleans:ClusterId"]; options.ServiceId = appSettings["Orleans:ServiceId"]; }) // Setting SiloName is more reliable when running in Kubernetes, the hostname will be the podname // When run in a StatefulSet, we'll get stable pod and hostnames .Configure <SiloOptions>(options => { options.SiloName = System.Environment.MachineName; }) .UseAzureStorageClustering(options => options.ConnectionString = appSettings["Orleans:ConnectionString"]) .UseAzureTableReminderService(options => options.ConnectionString = appSettings["Orleans:ConnectionString"]) .AddAzureTableGrainStorage("grain-store", options => { options.ConnectionString = appSettings["Orleans:ConnectionString"]; }) // last param is important it enables listening on all interfaces .ConfigureEndpoints(siloPort, gatewayPort, AddressFamily.InterNetwork, true) .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(EventGrain).Assembly).WithReferences()) .ConfigureLogging(builder => builder.SetMinimumLevel((LogLevel)appSettings.GetValue <int>("Orleans:LogLevel")).AddConsole()) .Build(); Task.Run(StartSilo); AssemblyLoadContext.Default.Unloading += context => { Task.Run(StopSilo); siloStopped.WaitOne(); }; siloStopped.WaitOne(); }
private static void SetupApplicationShutdown(ISiloHost siloHost, ILogger logger) { Console.CancelKeyPress += (s, a) => { a.Cancel = true; lock (SyncLock) { if (!_siloStopping) { _siloStopping = true; Task.Run(() => StopSilo(siloHost, logger)).Ignore(); } } }; }
public Fixture() { var(siloPort, gatewayPort) = TestClusterNetworkHelper.GetRandomAvailableServerPorts(); this.Silo = new SiloHostBuilder() .UseLocalhostClustering(siloPort, gatewayPort) .Configure <ClusterOptions>(options => { options.ClusterId = Guid.NewGuid().ToString(); options.ServiceId = Guid.NewGuid().ToString(); }) .AddMemoryGrainStorage("PubSubStore") .AddMemoryStreams <DefaultMemoryMessageBodySerializer>("MemStream") .Build(); this.Silo.StartAsync().GetAwaiter().GetResult(); }
static void InitSilo(string[] args) { siloHost = new SiloHost(System.Net.Dns.GetHostName()); // The Cluster config is quirky and weird to configure in code, so we're going to use a config file siloHost.ConfigFileName = "OrleansConfiguration.xml"; siloHost.InitializeOrleansSilo(); var startedok = siloHost.StartOrleansSilo(); if (!startedok) { throw new SystemException(String.Format("Failed to start Orleans silo '{0}' as a {1} node", siloHost.Name, siloHost.Type)); } }
protected override Task OnInit() { silo = new SiloHostBuilder() .UseLocalhostClustering() .Configure <ClusterOptions>(options => { options.ClusterId = "dev"; options.ServiceId = "AdventureApp"; }) .Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback) //.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(RoomGrain).Assembly).WithReferences()) .ConfigureLogging(logging => logging.AddConsole()) .Build(); return(Task.CompletedTask); }
public async Task StartAsync(CancellationToken cancellationToken) { var siloHostBuilder = new SiloHostBuilder(); _configure(_provider, siloHostBuilder); var parentScope = _provider.GetRequiredService <ILifetimeScope>(); siloHostBuilder.UseServiceProviderFactory(cs => { _scope = parentScope.BeginLifetimeScope(cb => { cb.Populate(cs); }); return(new AutofacServiceProvider(_scope)); }); _siloHost = siloHostBuilder.Build(); await _siloHost.StartAsync(cancellationToken); }
public async Task InitializeAsync() { var(siloPort, gatewayPort) = portAllocator.AllocateConsecutivePortPairs(1); this.Silo = new SiloHostBuilder() .UseLocalhostClustering(siloPort, gatewayPort) .Configure <ClusterOptions>(options => { options.ClusterId = Guid.NewGuid().ToString(); options.ServiceId = Guid.NewGuid().ToString(); }) .AddMemoryGrainStorage("PubSubStore") .AddMemoryStreams <DefaultMemoryMessageBodySerializer>("MemStream") .Build(); await this.Silo.StartAsync(); }
private async void OnApplicationStartedAsync() { _logger.LogInformation("initialize Orleans silo host..."); _siloHost = CreateSiloHost(); try { await _siloHost.StartAsync(); } catch (Exception ex) { _logger.LogError(ex, "Start up Silo Host failed"); throw; } }
static void Main(string [] args) { silo = new SiloHostBuilder() //.Configure<ClusterOptions>(options => //{ // options.ClusterId = "orleans-docker"; // options.ServiceId = "AspNetSampleApp"; //}) //.ConfigureEndpoints(siloPort: 11111, gatewayPort: 30000) .UseLocalhostClustering() .ConfigureApplicationParts(parts => { parts.AddApplicationPart(typeof(ReadContentGrain).Assembly).WithReferences().WithCodeGeneration(); parts.AddApplicationPart(typeof(FeedViewModel).Assembly).WithReferences(); parts.AddApplicationPart(typeof(ReadContentRepository).Assembly).WithReferences(); parts.AddApplicationPart(typeof(Page).Assembly).WithReferences(); }) .ConfigureLogging(builder => builder.SetMinimumLevel(LogLevel.Warning).AddConsole()) .ConfigureServices(services => { var conf = Configuration; services.AddSingleton <IConfiguration>(conf); services.AddSingleton <IDataConfiguration>(provider => new DataConfiguration(conf)); services.AddSingleton <IContentDbContext>(provider => { var p = provider.GetService <IDataConfiguration>(); return(new ContentDbContext(p)); }); services.AddSingleton <IReadContentRepository, ReadContentRepository>(); services.AddSingleton <ICreateContentRepository, CreateContentRepository>(); services.AddSingleton <IUpdateContentRepository, UpdateContentRepository>(); services.AddSingleton <IDeleteContentRepository, DeleteContentRepository>(); }) .Build(); Task.Run(StartSilo); AssemblyLoadContext.Default.Unloading += context => { Task.Run(StopSilo); siloStopped.WaitOne(); }; siloStopped.WaitOne(); }
public static async Task <int> LogAndRun(ISiloHost siloHost) { Log.Logger = BuildLogger(siloHost.Services.GetRequiredService <IConfiguration>()); try { Log.Information("Starting application"); await siloHost.StartAsync(); Log.Information("Started application, press CTRL+C to exit"); var siloStopped = new ManualResetEvent(false); void OnCancelKeyPress(object sender, ConsoleCancelEventArgs e) { Console.CancelKeyPress -= OnCancelKeyPress; // Remove handler to stop listening to CTRL+C events. e.Cancel = true; // Prevent the application from crashing ungracefully. Task.Run(async() => // Shutdown gracefully on a background thread. { try { Log.Information("Stopping application"); await siloHost.StopAsync(); Log.Information("Stopped application"); siloStopped.Set(); } catch (Exception exception) { Log.Fatal(exception, "Application stopped ungracefully"); } }); } Console.CancelKeyPress += OnCancelKeyPress; siloStopped.WaitOne(); return(0); } catch (Exception exception) { Log.Fatal(exception, "Application terminated unexpectedly"); return(1); } finally { Log.CloseAndFlush(); } }
private static async Task RunMainAsync(string[] args) { try { _startupStopwatch = Stopwatch.StartNew(); _hostingEnv = new HostingEnvironment(); var shortEnvName = AppInfo.MapEnvironmentName(_hostingEnv.Environment); var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddCommandLine(args) .AddJsonFile("appsettings.json") .AddJsonFile("config.json") .AddEnvironmentVariables(); if (_hostingEnv.IsDockerDev) { configBuilder.AddJsonFile("config.dev-docker.json", optional: true); } var config = configBuilder.Build(); var appInfo = new AppInfo(config); Console.Title = $"Silo - {appInfo.Name}"; _siloHost = BuildSilo(appInfo, config); _log.Info($"Initializing Silo { appInfo.Name} ({appInfo.Version}) [{ _hostingEnv.Environment}]..."); AssemblyLoadContext.Default.Unloading += context => { _log.Info("Assembly unloading..."); Task.Run(StopSilo); SiloStopped.WaitOne(); _log.Info("Assembly unloaded complete."); // Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux) NLog.LogManager.Shutdown(); }; await StartSilo(); } catch (Exception ex) { _log.Error(ex, "An error has occurred while initializing or starting silo."); NLog.LogManager.Shutdown(); } }
private static async Task <int> Main(string[] args) { string environmentName = Environment.GetEnvironmentVariable("SERVER_ENVIRONMENT"); Logger logger = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger(); IConfigurationRoot configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", true, true) .AddJsonFile($"appsettings.{environmentName}.json", true) .AddEnvironmentVariables() .Build(); AppConfig config = new AppConfig(); configuration.Bind("AppConfig", config); try { if (config.MigrateDatabases) { EvolveMigrator migrator = new EvolveMigrator(); migrator.Migrate(config.ConnectionStrings[Constants.System], Constants.SystemScripts, false); } logger.Info("Rialto Silo has been started"); ISiloHost host = await StartSilo(config); Console.WriteLine("Enter 'exit' to stop..."); while (!(Console.ReadLine() ?? string.Empty).Equals("exit")) { } await host.StopAsync(); logger.Info("Rialto Silo has been stopped"); return(0); } catch (Exception ex) { logger.Error(ex, "Rialto Silo is failed"); } finally { LogManager.Shutdown(); } return(-1); }
public TestSiloHost( string connectionString, string serviceId, string clusterId) { var siloPort = GetFreePort(); var gwPort = GetFreePort(); this.siloHost = new SiloHostBuilder() .Configure <ClusterOptions>(options => { options.ClusterId = clusterId; options.ServiceId = serviceId; }) .UseAzureStorageClustering(options => options.ConnectionString = connectionString) .UseAzureTableReminderService(options => options.ConnectionString = connectionString) .ConfigureEndpoints(IPAddress.Loopback, siloPort, gwPort) .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(PingGrain).Assembly).WithReferences()) .Build(); }
public static IDisposable Run(this ISiloHost siloHost) { if (siloHost == null) { throw new ArgumentNullException(nameof(siloHost)); } siloHost.StartAsync().Wait(); return(new AnonymousDisposable(() => { if (!siloHost.Stopped.IsCompleted) { siloHost.StopAsync().Wait(); } })); }
private static async Task <ISiloHost> StartSilo() { ISiloHostBuilder siloBuilder = new SiloHostBuilder().UseLocalhostClustering().Configure <ClusterOptions>( options => { options.ClusterId = ClusterId; options.ServiceId = ServiceId; }).Configure <EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback) .ConfigureApplicationParts(x => x.ConfigureDefaults()) .UseOrleankka() .AddAzureBlobGrainStorage("BlobStorage", options => options.ConnectionString = "UseDevelopmentStorage=true"); ISiloHost host = siloBuilder.Build(); await host.StartAsync(); return(host); }
public async Task StartAsync(CancellationToken cancellationToken) { var builder = new SiloHostBuilder() .UseLocalhostClustering() .Configure <ClusterOptions>(options => { options.ClusterId = "*"; options.ServiceId = "*"; }) .Configure <EndpointOptions>(options => { options.AdvertisedIPAddress = IPAddress.Loopback; options.GatewayPort = 30000; }) .ConfigureLogging(logging => logging.AddConsole()) .ConfigureApplicationParts(parts => { parts.AddApplicationPart(typeof(BaseGrain).Assembly).WithReferences(); parts.AddApplicationPart(typeof(FieldsMaintance.FieldsMaintanceGrain).Assembly).WithReferences(); parts.AddApplicationPart(typeof(Dosage_CalculatorGrain).Assembly).WithReferences(); parts.AddApplicationPart(typeof(SprayerMaintanceGrain).Assembly).WithReferences(); parts.AddApplicationPart(typeof(SprayingAgentMaintanceGrain).Assembly).WithReferences(); }) .UseDashboard(options => { options.Username = "******"; options.Password = "******"; options.Host = "*"; options.Port = 8080; options.HostSelf = true; options.CounterUpdateIntervalMs = 1000; }).ConfigureServices(services => { services.AddTransient <SprayCalculatorContext>(); services.AddTransient <FieldsRepository>(); services.AddTransient <SprayersRepository>(); services.AddTransient <SprayingAgentsRepository>(); services.AddTransient <IDosage_CalculatorBL, Dosage_Calculator>(); }); _siloHost = builder.Build(); await _siloHost.StartAsync(cancellationToken); }
public ExceptionTests() { this.silo = new SiloHostBuilder() .ConfigureApplicationParts( parts => parts.AddApplicationPart(typeof(ExceptionGrain).Assembly).WithReferences()) .ConfigureLocalHostPrimarySilo() .Build(); this.silo.StartAsync().GetAwaiter().GetResult(); this.client = new ClientBuilder() .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IExceptionGrain).Assembly).WithReferences()) .UseConfiguration(ClientConfiguration.LocalhostSilo()) .Build(); this.client.Connect().GetAwaiter().GetResult(); }