static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(theme: AnsiConsoleTheme.Code)
.CreateLogger();
var config = ClusterConfiguration.LocalhostPrimarySilo();
config.AddMemoryStorageProvider();
config.Defaults.DefaultTraceLevel = Severity.Warning;
config.Defaults.TraceFileName = null;
config.Defaults.TraceFilePattern = null;
config.Defaults.TraceToConsole = false;
config.Defaults.StatisticsCollectionLevel = StatisticsLevel.Critical;
using (var host = new SiloHost("Demo", config))
{
host.InitializeOrleansSilo();
host.StartOrleansSilo();
Console.WriteLine("Press any key to stop silo...");
Console.ReadKey(true);
host.StopOrleansSilo();
}
}
static void Main(string[] args)
{
// First, configure and start a local silo
var siloConfig = ClusterConfiguration.LocalhostPrimarySilo();
var silo = new SiloHost("TestSilo", siloConfig);
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Silo started.");
// Then configure and connect a client.
var clientConfig = ClientConfiguration.LocalhostSilo();
var client = new ClientBuilder().UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
//---------------------------------------------------------------------------------------
// Obtain a grain, invoke message and get result
//---------------------------------------------------------------------------------------
var hw = client.GetGrain <IGrainGS>(0);
Console.WriteLine(hw.HellowWorld().Result);
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
// Shut down
client.Close();
silo.ShutdownOrleansSilo();
}
static void Main(string[] args)
{
// First, configure and start a local silo
var siloConfig = ClusterConfiguration.LocalhostPrimarySilo();
var silo = new SiloHost("TestSilo", siloConfig);
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Silo started.");
// Then configure and connect a client.
var clientConfig = ClientConfiguration.LocalhostSilo();
var client = new ClientBuilder().UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
//HERE
//
var friend = client.GetGrain <ISayHello>(0);
Console.WriteLine("\n\n{0}\n\n", friend.SayHelloMessage().Result);
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
// Shut down
client.Close();
silo.ShutdownOrleansSilo();
}
// code to initialize and clean up an Orleans Silo
private static void InitSilo(string[] args)
{
// this is a hack to replace the local azure storage emulator for a real storage account
// which is stored in an environment variable in travis ci
const string SILO_SETTINGS_FILE = "DevTestServerConfiguration.xml";
string connectionString = null;
if (null != (connectionString = Environment.GetEnvironmentVariable("DataConnectionString")))
{
var settings = File.ReadAllText(SILO_SETTINGS_FILE).Replace("UseDevelopmentStorage=true", connectionString);
File.WriteAllText(SILO_SETTINGS_FILE, settings);
}
siloHost = new SiloHost("Primary")
{
ConfigFileName = SILO_SETTINGS_FILE,
DeploymentId = "1"
};
siloHost.InitializeOrleansSilo();
var ok = siloHost.StartOrleansSilo();
if (!ok)
{
throw new SystemException(string.Format("Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type));
}
}
public bool Run()
{
bool ok = false;
try
{
siloHost.InitializeOrleansSilo();
ok = siloHost.StartOrleansSilo();
if (ok)
{
Console.WriteLine(string.Format("Successfully started Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type));
}
else
{
throw new SystemException(string.Format("Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type));
}
}
catch (Exception exc)
{
siloHost.ReportStartupError(exc);
var msg = string.Format("{0}:\n{1}\n{2}", exc.GetType().FullName, exc.Message, exc.StackTrace);
Console.WriteLine(msg);
}
return(ok);
}
static void Main(string[] args)
{
Directory.CreateDirectory("Applications");
var silo = new SiloHost(Dns.GetHostName());
silo.InitializeOrleansSilo();
silo.Config.Globals.RegisterStorageProvider <AdoNetStorageProvider>("sql-store", new Dictionary <string, string> {
["AdoInvariant"] = "System.Data.SqlClient",
["DataConnectionString"] = "Data Source=.\\SQLExpress; Database=OrleansStore; Trusted_Connection=True;",
["UseJsonFormat"] = "true"
});
silo.Config.Globals.RegisterArangoStorageProvider("store",
password: "******",
databaseName: "OrleansStore",
collectionName: "Main");
if (!silo.StartOrleansSilo())
{
throw new Exception("Failed to start silo.");
}
Console.WriteLine("Silo started");
Console.ReadLine();
}
/// <summary>
/// Initialise and starts SiloHost reporting any issues
/// </summary>
/// <returns></returns>
public int Start()
{
if (_siloHost != null)
{
throw new Exception("Silo server is already running");
}
if (_clusterConfiguration == null)
{
throw new Exception("ClusterConfiguration has not been setup yet");
}
_siloHost = new SiloHost($"MemoryChatSilo-{Guid.NewGuid()}", _clusterConfiguration);
try
{
_siloHost.InitializeOrleansSilo();
if (_siloHost.StartOrleansSilo())
{
Console.WriteLine($"Successfully started silo server {_siloHost.Name}");
return(0);
}
else
{
throw new OrleansException($"Failed to start silo server {_siloHost.Name}");
}
}
catch (Exception ex)
{
_siloHost.ReportStartupError(ex);
Console.Error.WriteLine(ex);
return(1);
}
}
public bool Run()
{
var ok = false;
try
{
siloHost.InitializeOrleansSilo();
ok = siloHost.StartOrleansSilo();
if (ok)
{
System.Console.WriteLine("OrleansHostWrapper", "Run", "Successfully started Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type);
}
else
{
var message = string.Format("Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type);
throw new SystemException(message);
}
}
catch (Exception ex)
{
siloHost.ReportStartupError(ex);
System.Console.WriteLine("OrleansHostWrapper", "Run", "{0}:\n{1}\n{2}", ex.GetType().FullName, ex.Message, ex.StackTrace);
}
return(ok);
}
static void Main()
{
var azureTableCS = "DefaultEndpointsProtocol=https;AccountName=cs44de867d736aax49dfxbd9;AccountKey=I9QAt4VtgU6UTeJNAtxVCjFijmmMiJNjC032iMUJe2CvVkPxaLWnJYb0AfJuR5AtMpUO6LQ3z43EXOcy4Db+hg==";
var clusterConfig = ClusterConfiguration.LocalhostPrimarySilo();
clusterConfig.AddMemoryStorageProvider("Default");
clusterConfig.AddMemoryStorageProvider("PubSubStore");
clusterConfig.AddSimpleMessageStreamProvider("SMSProvider");
// clusterConfig.Globals.LivenessType = GlobalConfiguration.LivenessProviderType.AzureTable;
// clusterConfig.Globals.DataConnectionString = azureTableCS;
// clusterConfig.Globals.DataConnectionStringForReminders = azureTableCS;
// clusterConfig.Globals.DeploymentId = "OrleansTest";
// clusterConfig.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.AzureTable;
var silo = new SiloHost("Test Silo", clusterConfig);
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Press Enter to close.");
Console.ReadLine();
silo.ShutdownOrleansSilo();
}
static void Main(string[] args)
{
var m_SiloConfigFile = new FileInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{Path.GetFileNameWithoutExtension("OrleansConfiguration")}.xml"));
using (var m_Host = new SiloHost("GrLionSilo", m_SiloConfigFile))
{
m_Host.Config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain;
m_Host.LoadOrleansConfig();
m_Host.InitializeOrleansSilo();
m_Host.StartOrleansSilo();
ConsoleKeyInfo m_ConsoleKeyInfo = new ConsoleKeyInfo();
while (m_ConsoleKeyInfo.Key != ConsoleKey.Escape)
{
Console.WriteLine("OrleansSilo已启动,按下'Esc'键结束服务.");
m_ConsoleKeyInfo = Console.ReadKey();
Console.WriteLine($"{ m_ConsoleKeyInfo.Key}");
}
Console.WriteLine("正在结束OrleansSilo服务 . . .");
m_Host.StopOrleansSilo();
}
}
private static void Main()
{
while (true)
{
Console.WriteLine("请输入配置文件名称：");
var configName = Console.ReadLine();
var configFile = new FileInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
$"{Path.GetFileNameWithoutExtension(configName)}.xml"));
if (!configFile.Exists)
{
Console.WriteLine($"配置文件：{configFile.FullName}，不存在！");
continue;
}
Console.WriteLine("请输入节点名称：");
var nodeName = Console.ReadLine() ?? string.Empty;
using (var host = new SiloHost(nodeName, configFile))
{
host.LoadOrleansConfig();
host.InitializeOrleansSilo();
host.StartOrleansSilo();
Console.WriteLine("已启动，按下任意键退出。");
Console.ReadLine();
host.StopOrleansSilo();
}
break;
}
}
public bool Run()
{
bool ok = false;
try
{
_siloHost.InitializeOrleansSilo();
ok = _siloHost.StartOrleansSilo();
if (ok)
{
Console.WriteLine($"Successfully started Orleans silo '{_siloHost.Name}' as a {_siloHost.Type} node.");
}
else
{
throw new SystemException(
$"Failed to start Orleans silo '{_siloHost.Name}' as a {_siloHost.Type} node.");
}
}
catch (Exception exc)
{
_siloHost.ReportStartupError(exc);
var msg = $"{exc.GetType().FullName}:\n{exc.Message}\n{exc.StackTrace}";
Console.WriteLine(msg);
}
return(ok);
}
public static IDisposable Run(string[] args)
{
var configuration = ConreignSiloConfiguration.Load(
ApplicationPath.CurrentDirectory,
args
);
var silo = ConreignSilo.Create(configuration);
var logger = silo.Logger;
var orleansConfiguration = silo.CreateOrleansConfiguration();
var siloHost = new SiloHost(Environment.MachineName, orleansConfiguration);
try
{
siloHost.DeploymentId = configuration.ClusterId;
siloHost.InitializeOrleansSilo();
siloHost.StartOrleansSilo(false);
logger.Information("Silo is started.");
return(siloHost);
}
catch (Exception ex)
{
logger.Error(ex, "Failed to start silo.");
siloHost.Dispose();
throw;
}
}
public void Start(Func <IGrainFactory, Task> afterOrleansStartup = null,
Func <IGrainFactory, Task> beforeOrleansShutdown = null)
{
AfterOrleansStartup = afterOrleansStartup;
BeforeOrleansShutdown = beforeOrleansShutdown;
Log.Info(_ => _("Starting Orleans silo..."));
Silo = new SiloHost(CurrentApplicationInfo.HostName, ConfigBuilder.ClusterConfiguration)
{
Type = ConfigBuilder.SiloType
};
Silo.InitializeOrleansSilo();
bool siloStartedSuccessfully = Silo.StartOrleansSilo(false);
if (siloStartedSuccessfully)
{
Log.Info(_ => _("Successfully started Orleans silo", unencryptedTags: new { siloName = Silo.Name, siloType = Silo.Type }));
}
else if (BootstrapException != null)
{
throw new ProgrammaticException("Failed to start Orleans silo due to an exception thrown in the bootstrap method.", unencrypted: new Tags {
{ "siloName", Silo.Name }, { "siloType", Silo.Type.ToString() }
}, innerException: BootstrapException);
}
else
{
throw new ProgrammaticException("Failed to start Orleans silo", unencrypted: new Tags {
{ "siloName", Silo.Name }, { "siloType", Silo.Type.ToString() }
});
}
}
public bool Run()
{
bool ok = false;
try
{
siloHost.InitializeOrleansSilo();
siloHost.Config.Globals.RegisterBootstrapProvider <Dashboard>("Dashboard");
ok = siloHost.StartOrleansSilo();
if (!ok)
{
throw new SystemException(string.Format("Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type));
}
}
catch (Exception exc)
{
siloHost.ReportStartupError(exc);
var msg = string.Format("{0}:\n{1}\n{2}", exc.GetType().FullName, exc.Message, exc.StackTrace);
Console.WriteLine(msg);
}
return(ok);
}
private static void Run()
{
var config = GetClusterConfiguration();
config.Globals.SeedNodes.Add(new IPEndPoint(IPAddress.Loopback, 11111));
config.Defaults.HostNameOrIPAddress = "localhost";
config.Defaults.Port = 11111;
config.Defaults.ProxyGatewayEndpoint = new IPEndPoint(IPAddress.Loopback, 12345);
var process = Process.GetCurrentProcess();
var name = Environment.MachineName + "_" + process.Id + Guid.NewGuid().ToString("N").Substring(3);
var silo = new SiloHost(name, config);
// Configure the silo for the current environment.
silo.SetSiloType(Silo.SiloType.Primary);
Trace.TraceInformation("Silo configuration: \n" + silo.Config.ToString(name));
silo.InitializeOrleansSilo();
Trace.TraceInformation("Successfully initialized Orleans silo '{0}' as a {1} node.", silo.Name, silo.Type);
Trace.TraceInformation("Starting Orleans silo '{0}' as a {1} node.", silo.Name, silo.Type);
if (silo.StartOrleansSilo())
{
silo.WaitForOrleansSiloShutdown();
}
}
static void Main(string[] args)
{
using (var db = new DBContext())
{
Database.SetInitializer <DBContext>(null);
var objectContext = ((IObjectContextAdapter)db).ObjectContext;
var mappingCollection = (StorageMappingItemCollection)objectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace);
mappingCollection.GenerateViews(new List <EdmSchemaError>());
db.Database.Log = Console.WriteLine;
db.Database.Initialize(false);
}
using (var host = new SiloHost("Default"))
{
//host.ConfigFileName = "OrleansConfiguration.xml";
host.LoadOrleansConfig();
host.InitializeOrleansSilo();
host.StartOrleansSilo();
#region 正式环境
#endregion
Console.WriteLine("启动成功");
Console.Read();
}
}
static void Main(string[] args)
{
// First, configure and start a local silo
var siloConfig = ClusterConfiguration.LocalhostPrimarySilo();
var silo = new SiloHost("TestSilo", siloConfig);
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Silo started.");
// Then configure and connect a client.
var clientConfig = ClientConfiguration.LocalhostSilo();
var client = new ClientBuilder().UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
//
// This is the place for your test code.
//
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
// Shut down
client.Close();
silo.ShutdownOrleansSilo();
}
public int Run()
{
if (siloHost == null)
{
return(1);
}
try
{
siloHost.InitializeOrleansSilo();
if (siloHost.StartOrleansSilo())
{
Console.WriteLine($"Successfully started Orleans silo '{siloHost.Name}' as a {siloHost.Type} node.");
return(0);
}
else
{
throw new OrleansException($"Failed to start Orleans silo '{siloHost.Name}' as a {siloHost.Type} node.");
}
}
catch (Exception exc)
{
siloHost.ReportStartupError(exc);
Console.Error.WriteLine(exc);
return(1);
}
}
static void Main(string[] args)
{
Console.WriteLine("Please input number:");
var number = Console.ReadLine();
Console.Title = "Silo" + number;
try
{
using (var siloHost = new SiloHost(Console.Title))
{
siloHost.ConfigFileName = "OrleansConfiguration" + number + ".xml";;
siloHost.LoadOrleansConfig();
//siloHost.Config.Globals.LivenessType = GlobalConfiguration.LivenessProviderType.Custom;
//siloHost.Config.Globals.MembershipTableAssembly = "OrleansConsulUtils";
//siloHost.Config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.Disabled;
siloHost.InitializeOrleansSilo();
var startedOk = siloHost.StartOrleansSilo();
Console.WriteLine("Silo started successfully");
Console.WriteLine("Press enter to exit...");
Console.ReadLine();
siloHost.ShutdownOrleansSilo();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.ReadLine();
}
static void Main(string[] args)
{
Console.Title = "Silo";
try
{
using (var siloHost = new SiloHost(Console.Title))
{
siloHost.ConfigFileName = "OrleansConfiguration.xml";
siloHost.LoadOrleansConfig();
siloHost.InitializeOrleansSilo();
var startedOk = siloHost.StartOrleansSilo();
Console.WriteLine("Silo started successfully");
Console.WriteLine("Press enter to exit...");
Console.ReadLine();
siloHost.ShutdownOrleansSilo();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.ReadLine();
}
public static SiloHost InitializeSilo(string deploymentId, int port, int proxy, Action <ClusterConfiguration> configure = null)
{
var config = new ClusterConfiguration();
config.Globals.DeploymentId = deploymentId;
config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.Disabled;
config.Defaults.SetDefaults("localhost", port, "localhost", proxy, true, Severity.Info);
if (configure == null)
{
config.Globals.SetGlobals();
}
else
{
configure(config);
}
var siloHost = new SiloHost($"{Dns.GetHostName()}-{port}", config);
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));
}
return(siloHost);
}
static void Main(string[] args)
{
Console.Title = "ClusterSilo3";
try
{
using (var silo = new SiloHost(Console.Title))
{
silo.ConfigFileName = "OrleansConfiguration.config";
silo.LoadOrleansConfig();
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Silo start successfully");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
silo.ShutdownOrleansSilo();
}
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
}
Console.ReadLine();
}
static void Main(string[] args)
{
// First, configure and start a local silo
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();
siloHost.StartOrleansSilo();
Metric.Config
.WithHttpEndpoint("http://localhost:8000/")
.WithAllCounters();
Console.WriteLine("Silo started.");
//
// This is the place for your test code.
//
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
// Shut down
//client.Close();
siloHost.ShutdownOrleansSilo();
}
static void Main(string[] args)
{
var silo = new SiloHost("SILO");
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
System.Console.ReadKey();
}
internal void Start()
{
host.LoadOrleansConfig();
host.InitializeOrleansSilo();
if (!host.StartOrleansSilo()) // weird decision made by Orleans team (what about fail fast?)
{
throw new Exception("Silo failed to start. Check the logs");
}
}
public bool Start()
{
host.LoadOrleansConfig();
host.InitializeOrleansSilo();
startup = Task.Factory.StartNew(() =>
{
return(host.StartOrleansSilo());
});
return(true);
}
protected void Application_Start(object sender, EventArgs e)
{
siloHost = new SiloHost(System.Net.Dns.GetHostName());
siloHost.ConfigFileName = Server.MapPath("~/OrleansConfiguration.xml");
siloHost.InitializeOrleansSilo();
if (!siloHost.StartOrleansSilo())
{
throw new SystemException("Failed to start Orleans silo");
}
}
private static void InitSilo( string[] args )
{
siloHost = new SiloHost( "Primary" ) {
ConfigFileName = "DevTestServerConfiguration.xml",
DeploymentId = "1"
};
siloHost.InitializeOrleansSilo();
var ok = siloHost.StartOrleansSilo();
if( !ok )
throw new SystemException( string.Format( "Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type ) );
}
public static void Main(string[] args)
{
var config = BuildAzureClusterConfig();
var siloHost = new SiloHost(Dns.GetHostName(), config);
siloHost.LoadOrleansConfig();
siloHost.InitializeOrleansSilo();
siloHost.StartOrleansSilo(false);
Thread.Sleep(Timeout.Infinite);
}
public static void Main(string[] args)
{
CreateWebHostBuilder(args).Build().Run();
// First, configure and start a local silo
var siloConfig = ClusterConfiguration.LocalhostPrimarySilo();
var silo = new SiloHost("TestSilo", siloConfig);
silo.InitializeOrleansSilo();
silo.StartOrleansSilo();
Console.WriteLine("Silo started.");
// Then configure and connect a client.
var clientConfig = ClientConfiguration.LocalhostSilo();
var client = new ClientBuilder().UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
//
var saludo = client.GetGrain <MergeInterface.IMergeSort>(Guid.NewGuid());
var resultado = ReadFileYeah(@"C: \Users\Chino Guzman\source\repos\DistributedMergeSort\oraciones.txt").ToList();
/*var valores = decoder(resultado);
* var resultadofinal = MergeSort(saludo, 0, valores, 1, valores.Count);
* foreach(List<int> x in resultadofinal)
* {
* Console.WriteLine(x[0]);
* }
* var valoresfinales = encoder(resultadofinal);
* foreach (char[] x in valoresfinales) {
* foreach (char hola in x) {
* Console.Write(hola);
* }
* Console.WriteLine("");
* }*/
var yeah = MergeSort(saludo, resultado, 1, resultado.Count);
foreach (string x in yeah)
{
Console.WriteLine(x);
}
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
// Shut down
client.Close();
silo.ShutdownOrleansSilo();
}
private static void InitSilo( string[] args )
{
// this is a hack to replace the local azure storage emulator for a real storage account
// which is stored in an environment variable in travis ci
const string SILO_SETTINGS_FILE = "DevTestServerConfiguration.xml";
string connectionString = null;
if (null != (connectionString = Environment.GetEnvironmentVariable("DataConnectionString")))
{
Console.WriteLine("rewritten DataConnectinString variable");
var settings = File.ReadAllText(SILO_SETTINGS_FILE).Replace("UseDevelopmentStorage=true", connectionString);
File.WriteAllText(SILO_SETTINGS_FILE, settings);
}
siloHost = new SiloHost( "Primary" ) {
ConfigFileName = SILO_SETTINGS_FILE,
DeploymentId = "1"
};
siloHost.InitializeOrleansSilo();
var ok = siloHost.StartOrleansSilo();
if( !ok )
throw new SystemException( string.Format( "Failed to start Orleans silo '{0}' as a {1} node.", siloHost.Name, siloHost.Type ) );
}
