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();
}
