private static async Task <ISiloHost> StartSilo() { // define the cluster configuration var config = new ClusterConfiguration(); config.Defaults.Port = new Random(1).Next(10001, 10100); config.Globals.ClusterId = "testcluster"; config.AddMemoryStorageProvider(); config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.Disabled; var builder = new SiloHostBuilder() .UseConfiguration(config) .UseKubeMembership(opt => { //opt.APIEndpoint = "http://localhost:8001"; //opt.CertificateData = "test"; //opt.APIToken = "test"; opt.CanCreateResources = true; opt.DropResourcesOnInit = true; }) .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences()) .ConfigureLogging(logging => logging.AddConsole()); var host = builder.Build(); await host.StartAsync(); return(host); }
private static void AdjustConfig(ClusterConfiguration config) { // register stream provider config.AddMemoryStorageProvider("PubSubStore"); config.Globals.RegisterStreamProvider <TestEventHubStreamProvider>(StreamProviderName, BuildProviderSettings()); config.Globals.ClientDropTimeout = TimeSpan.FromSeconds(5); }
private static ClusterConfiguration LoadClusterConfiguration() { var cluster = new ClusterConfiguration(); cluster.LoadFromFile("OrleansConfiguration.dev.xml"); cluster.AddMemoryStorageProvider(); return(cluster); }
/// <summary> /// Initialise cluster configuration using configuration supplied or using default configuration /// </summary> /// <param name="clusterConfiguration">Used if not null</param> /// <returns></returns> public int Initialise(ClusterConfiguration clusterConfiguration = null) { if (clusterConfiguration == null) { _clusterConfiguration = ClusterConfiguration.LocalhostPrimarySilo(); _clusterConfiguration.AddMemoryStorageProvider(); _clusterConfiguration.AddMemoryStorageProvider("PubSubStore"); _clusterConfiguration.AddSimpleMessageStreamProvider(MemoryChatConfiguration.MemoryChatStreamProvider); //_clusterConfiguration.AddAzureTableStorageProvider("AzureStore", "UseDevelopmentStorage=true"); } else { _clusterConfiguration = clusterConfiguration; } return(0); }
private static int StartSilo(string[] args) { // define the cluster configuration var config = new ClusterConfiguration(); config.LoadFromFile("OrleansConfiguration.dev.xml"); config.AddMemoryStorageProvider(); config.UseStartupType <Startup>(); hostWrapper = new OrleansHostWrapper(config, args); return(hostWrapper.Run()); }
private static int StartSilo(string[] args) { // define the cluster configuration var config = new ClusterConfiguration(); config.Globals.LivenessType = GlobalConfiguration.LivenessProviderType.AzureTable; config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.AzureTable; config.Globals.DataConnectionString = "MY_DATA_CONNECTION_STRING"; config.AddMemoryStorageProvider(); config.AddAzureTableStorageProvider("AzureStore"); config.Defaults.DefaultTraceLevel = Severity.Error; config.Defaults.Port = 100; config.Defaults.ProxyGatewayEndpoint = new IPEndPoint(config.Defaults.Endpoint.Address, 101); hostWrapper = new OrleansHostWrapper(config, args); return(hostWrapper.Run()); }
private static void Main() { OrleansStartup orleansStartup = new OrleansStartup("clusterName"); ClusterConfiguration siloConfig = ClusterConfiguration .LocalhostPrimarySilo(PortUtils.FindAvailablePortIncrementally(22222), PortUtils.FindAvailablePortIncrementally(40000)) .AddPublishSubscribeStreamProvider(); siloConfig.AddMemoryStorageProvider("PubSubStore"); ISiloHost siloHost = new SiloHostBuilder() .AddApplicationPart(typeof(TestGrain).Assembly) .UseConfiguration(siloConfig) .UseServiceProviderFactory(collection => orleansStartup.ConfigureServices(collection)) .Build(); ClientConfiguration clientConfiguration = ClientConfiguration .LocalhostSilo() .AddPublishSubscribeStreamProvider() .ConnectTo(siloConfig); IClientBuilder clientBuilder = new ClientBuilder() .AddApplicationPart(typeof(TestGrain).Assembly) .UseConfiguration(clientConfiguration) .UseServiceProviderFactory(services => orleansStartup.ConfigureServices(services)); using (orleansStartup.PublishSubscribe .Observe <object>("*") .Subscribe(_ => { Console.Out.WriteLine(_); })) { using (siloHost.Run()) using (IClusterClientEx clusterClient = clientBuilder.Run()) { clusterClient.GetGrain <ITestGrain>(Guid.NewGuid()).Run().Wait(); //orleansStartup.PublishSubscribe.Publish("from Console", "Hello From Console"); Console.WriteLine("Press Enter to close."); Console.ReadLine(); } } }
private static void AdjustConfig(ClusterConfiguration config) { // register stream provider config.AddMemoryStorageProvider("PubSubStore"); config.Globals.ClientDropTimeout = TimeSpan.FromSeconds(5); }
/// <summary> /// Start a new silo in the target cluster /// </summary> /// <param name="host">The target cluster</param> /// <param name="type">The type of the silo to deploy</param> /// <param name="options">The options to use for the silo</param> /// <param name="instanceCount">The instance count of the silo</param> /// <param name="shared">The shared AppDomain to use</param> /// <returns>A handle to the deployed silo</returns> public static SiloHandle StartOrleansSilo(TestingSiloHost host, Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null) { if (host == null) { throw new ArgumentNullException("host"); } // Load initial config settings, then apply some overrides below. ClusterConfiguration config = new ClusterConfiguration(); try { if (options.SiloConfigFile == null) { config.StandardLoad(); } else { config.LoadFromFile(options.SiloConfigFile.FullName); } } catch (FileNotFoundException) { if (options.SiloConfigFile != null && !string.Equals(options.SiloConfigFile.Name, TestingSiloOptions.DEFAULT_SILO_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase)) { // if the user is not using the defaults, then throw because the file was legitimally not found throw; } config = ClusterConfiguration.LocalhostPrimarySilo(); config.AddMemoryStorageProvider("Default"); config.AddMemoryStorageProvider("MemoryStore"); } int basePort = options.BasePort < 0 ? BasePort : options.BasePort; if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0) { config.PrimaryNode = config.Globals.SeedNodes[0]; } else { config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort); } config.Globals.SeedNodes.Clear(); config.Globals.SeedNodes.Add(config.PrimaryNode); if (!String.IsNullOrEmpty(host.DeploymentId)) { config.Globals.DeploymentId = host.DeploymentId; } config.Defaults.PropagateActivityId = options.PropagateActivityId; if (options.LargeMessageWarningThreshold > 0) { config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold; } config.Globals.LivenessType = options.LivenessType; config.Globals.ReminderServiceType = options.ReminderServiceType; if (!String.IsNullOrEmpty(options.DataConnectionString)) { config.Globals.DataConnectionString = options.DataConnectionString; } host.Globals = config.Globals; string siloName; switch (type) { case Silo.SiloType.Primary: siloName = "Primary"; break; default: siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture); break; } NodeConfiguration nodeConfig = config.GetOrCreateNodeConfigurationForSilo(siloName); nodeConfig.HostNameOrIPAddress = "loopback"; nodeConfig.Port = basePort + instanceCount; nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel; nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId; nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit; int?gatewayport = null; if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null) { gatewayport = (options.ProxyBasePort < 0 ? ProxyBasePort : options.ProxyBasePort) + instanceCount; nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, gatewayport.Value); } config.Globals.ExpectedClusterSize = 2; config.Overrides[siloName] = nodeConfig; AdjustForTest(config, options); WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName)); return(AppDomainSiloHandle.Create(siloName, type, config, nodeConfig, host.additionalAssemblies)); }
private bool ParseArguments(string[] args) { string deploymentId = null; string siloName = Dns.GetHostName(); // Default to machine name int argPos = 1; for (int i = 0; i < args.Length; i++) { string a = args[i]; if (a.StartsWith("-") || a.StartsWith("/")) { switch (a.ToLowerInvariant()) { case "/?": case "/help": case "-?": case "-help": // Query usage help return(false); default: Console.WriteLine("Bad command line arguments supplied: " + a); return(false); } } else if (a.Contains("=")) { string[] split = a.Split('='); if (String.IsNullOrEmpty(split[1])) { Console.WriteLine("Bad command line arguments supplied: " + a); return(false); } switch (split[0].ToLowerInvariant()) { case "deploymentid": deploymentId = split[1]; break; default: Console.WriteLine("Bad command line arguments supplied: " + a); return(false); } } // unqualified arguments below else if (argPos == 1) { siloName = a; argPos++; } else { // Too many command line arguments Console.WriteLine("Too many command line arguments supplied: " + a); return(false); } } //集群启动 ClusterConfiguration config = new ClusterConfiguration(); string configpath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{Path.GetFileNameWithoutExtension("OrleansConfiguration.xml")}.xml"); if (File.Exists(configpath)) { config.LoadFromFile(configpath); } else { config = ClusterConfiguration.LocalhostPrimarySilo(); } config.AddMemoryStorageProvider(); siloHost = new SiloHost(siloName, config); if (deploymentId != null) { siloHost.DeploymentId = deploymentId; } return(true); }
static int Main(string[] args) { string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Development"; var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddInMemoryCollection(new Dictionary <string, string> // add default settings, that will be overridden by commandline { { "Id", "OrleansHost" }, { "Version", "1.0.0" }, { "DeploymentId", "testdeploymentid" }, }) .AddCommandLine(args) .AddJsonFile($"appconfig.json", optional: true) .AddJsonFile($"appconfig.{environment}.json", optional: true) .AddEnvironmentVariables("ASPNETCORE_"); // The CloudService will pass settings (such as) the connectionstring through environment variables if ("Development".Equals(environment) && builder.GetFileProvider().GetFileInfo("OrleansHost.csproj").Exists) { // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 builder.AddUserSecrets <Program>(); } var config = builder.Build(); loggerFactory.AddConsole(config.GetSection("Logging")); loggerFactory.AddDebug(); var logger = loggerFactory.CreateLogger <Program>(); ClusterConfiguration clusterConfig = ClusterConfiguration.LocalhostPrimarySilo(); clusterConfig.Globals.DeploymentId = config["Id"]; clusterConfig.Globals.DataConnectionString = config.GetConnectionString("DataConnectionString"); clusterConfig.AddMemoryStorageProvider("Default"); clusterConfig.AddMemoryStorageProvider("PubSubStore"); clusterConfig.AddSimpleMessageStreamProvider("Default"); clusterConfig.Defaults.DefaultTraceLevel = Orleans.Runtime.Severity.Warning; clusterConfig.Defaults.TraceFileName = ""; clusterConfig.UseStartupType <Startup>(); var siloHost = new SiloHost(config["Id"], clusterConfig); try { siloHost.InitializeOrleansSilo(); bool ok = siloHost.StartOrleansSilo(catchExceptions: false); if (!ok) { logger.LogError(string.Format($"Failed to start Orleans silo '{siloHost.Name}' as a {siloHost.Type} node.")); return(1); } } catch (Exception exc) { siloHost.ReportStartupError(exc); return(2); } Console.WriteLine("OrleansHost is running. Press [Ctrl]-C to stop..."); siloHost.WaitForOrleansSiloShutdown(); // logger.LogInformation(string.Format($"Orleans silo '{siloHost.Name}' shutdown. Press [Enter]")); // Console.ReadLine(); return(0); }
static async Task Main(string[] args) { string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Development"; var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddInMemoryCollection(new Dictionary <string, string> // add default settings, that will be overridden by commandline { { "Id", "OrleansHost" }, { "Version", "1.0.0" }, { "DeploymentId", "testdeploymentid" }, }) .AddCommandLine(args) .AddJsonFile($"appconfig.json", optional: true) .AddJsonFile($"appconfig.{environment}.json", optional: true) .AddEnvironmentVariables("ASPNETCORE_"); // The CloudService will pass settings (such as) the connectionstring through environment variables if ("Development".Equals(environment) && builder.GetFileProvider().GetFileInfo("OrleansHost.csproj").Exists) { // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 builder.AddUserSecrets <Program>(); } var config = builder.Build(); loggerFactory.AddConsole(config.GetSection("Logging")); loggerFactory.AddDebug(); var logger = loggerFactory.CreateLogger <Program>(); logger.LogWarning(string.Format($"Starting Orleans silo...")); ClusterConfiguration clusterConfig = ClusterConfiguration.LocalhostPrimarySilo(); clusterConfig.Globals.DeploymentId = config["Id"]; clusterConfig.Globals.DataConnectionString = config.GetConnectionString("DataConnectionString"); clusterConfig.AddMemoryStorageProvider("Default"); clusterConfig.AddMemoryStorageProvider("PubSubStore"); clusterConfig.AddSimpleMessageStreamProvider("Default"); string siloName = config["Id"]; var host = new SiloHostBuilder() .UseConfiguration(clusterConfig) .ConfigureSiloName(siloName) .ConfigureServices(services => { services.AddOptions(); services.TryAdd(ServiceDescriptor.Singleton <ILoggerFactory, LoggerFactory>()); services.TryAdd(ServiceDescriptor.Singleton(typeof(ILogger <>), typeof(Logger <>))); services.Configure <ConnectionStrings>(config.GetSection("ConnectionStrings")); string reduxConnectionString = config.GetConnectionString("ReduxConnectionString"); services.AddSingleton(new ReduxTableStorage <CertState>(reduxConnectionString)); services.AddSingleton(new ReduxTableStorage <UserState>(reduxConnectionString)); services.AddSingleton(new ReduxTableStorage <CounterState>(reduxConnectionString)); }) .AddApplicationPart(typeof(CounterGrain).Assembly) .AddApplicationPartsFromReferences(typeof(CounterGrain).Assembly) .Build(); try { await host.StartAsync(); logger.LogInformation(string.Format($"Successfully started Orleans silo {siloName}")); Console.WriteLine($"Silo {siloName} is running. Press [enter] to stop..."); Console.ReadLine(); await host.StopAsync(); logger.LogWarning(string.Format($"Orleans silo shutdown.")); } catch (Exception e) { logger.LogCritical(e, "Silo stopping fatally with exception: " + e.Message); } }