public async Task SimpleSQLStore_Delete()
{
Guid id = Guid.NewGuid();
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize(HostedCluster.ClientConfiguration);
}
ISimpleSQLStorageTestGrain grain = GrainClient.GrainFactory.GetGrain <ISimpleSQLStorageTestGrain>(id);
await grain.DoWrite(1);
await grain.DoDelete();
int val = await grain.GetValue(); // Should this throw instead?
Assert.Equal(0, val); // "Value after Delete");
await grain.DoWrite(2);
val = await grain.GetValue();
Assert.Equal(2, val); // "Value after Delete + New Write");
}
public void ClientInit_ErrorDuringInitialize()
{
ClientConfiguration cfg = TestClusterOptions.BuildClientConfiguration(HostedCluster.ClusterConfiguration);
cfg.TraceFileName = "TestOnlyThrowExceptionDuringInit.log";
// First initialize will have been done by orleans unit test base class, so uninitialize back to null state
GrainClient.Uninitialize();
Assert.IsFalse(GrainClient.IsInitialized, "GrainClient.IsInitialized");
Assert.IsFalse(LogManager.IsInitialized, "Logger.IsInitialized");
try
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = true;
Xunit.Assert.Throws <InvalidOperationException>(() =>
GrainClient.Initialize(cfg));
Assert.IsFalse(GrainClient.IsInitialized, "GrainClient.IsInitialized");
Assert.IsFalse(LogManager.IsInitialized, "Logger.IsInitialized");
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
GrainClient.Initialize(cfg);
Assert.IsTrue(GrainClient.IsInitialized, "GrainClient.IsInitialized");
Assert.IsTrue(LogManager.IsInitialized, "Logger.IsInitialized");
}
finally
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
}
}
public void ClientInit_ErrorDuringInitialize()
{
ClientConfiguration cfg = this.fixture.ClientConfiguration;
// First initialize will have been done by orleans unit test base class, so uninitialize back to null state
GrainClient.Uninitialize();
GrainClient.ConfigureLoggingDelegate = builder => builder.AddFile("TestOnlyThrowExceptionDuringInit.log");
Assert.False(GrainClient.IsInitialized, "GrainClient.IsInitialized");
try
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = true;
Assert.Throws <InvalidOperationException>(() =>
GrainClient.Initialize(cfg));
Assert.False(GrainClient.IsInitialized, "GrainClient.IsInitialized");
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
GrainClient.Initialize(cfg);
Assert.True(GrainClient.IsInitialized, "GrainClient.IsInitialized");
}
finally
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
}
}
public async Task TestGrains()
{
var rnd = new Random();
var rndId1 = rnd.Next();
var rndId2 = rnd.Next();
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize(HostedCluster.ClientConfiguration);
}
// insert your grain test code here
var grain = this.HostedCluster.GrainFactory.GetGrain <IMyGrain>(rndId1);
var thing4 = new DateTime();
var thing3 = Guid.NewGuid();
var thing1 = 1;
var thing2 = "ggggggggggggggggg";
var things = new List <int> {
5, 6, 7, 8, 9
};
await grain.SaveSomething(thing1, thing2, thing3, thing4, things);
Assert.Equal(thing1, await grain.GetThing1());
Assert.Equal(thing2, await grain.GetThing2());
Assert.Equal(thing3, await grain.GetThing3());
Assert.Equal(thing4, await grain.GetThing4());
var res = await grain.GetThings1();
Assert.Equal(things, res.ToList());
}
static void RunOrleans()
{
var config = ClientConfiguration.LocalhostSilo(26224);
try
{
GrainClient.Initialize(config);
Console.WriteLine("Client successfully connect to silo host");
}
catch (Exception ex)
{
Console.WriteLine($"Orleans client initialization failed failed due to {ex}");
Console.ReadLine();
return;
}
var friend = GrainClient.GrainFactory.GetGrain <IHello>(0);
var name = "world";
CodeTimerAdvance.TimeByConsole("orleans", _count, (i) =>
{
var response = friend.SayHello(new RpcTest_OrleansServer.Interfaces.HelloRequest
{
Name = name
}).Result;
}, _threadcount);
Console.WriteLine("Press Enter to terminate...");
Console.ReadLine();
}
public ClientWrapperBase(string name, int gatewayport, string clusterId, Action <ClientConfiguration> clientconfig_customizer)
{
this.Name = name;
Console.WriteLine("Initializing client {0} in AppDomain {1}", name, AppDomain.CurrentDomain.FriendlyName);
ClientConfiguration config = null;
try
{
config = clientconfiguration.Value;
}
catch (Exception) { }
if (config == null)
{
Assert.True(false, "Error loading client configuration file");
}
config.GatewayProvider = ClientConfiguration.GatewayProviderType.Config;
config.Gateways.Clear();
config.Gateways.Add(new IPEndPoint(IPAddress.Loopback, gatewayport));
clientconfig_customizer?.Invoke(config);
GrainClient.Initialize(config);
}
private static void test(int id, string msg = null)
{
// Then configure and connect a client.
//var clientConfig = ClientConfiguration.LoadFromFile("ClientConfiguration.xml");
var clientConfig = ClientConfiguration.LocalhostSilo();
IClusterClient client = new ClientBuilder()
.UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
if (string.IsNullOrEmpty(msg))
{
Console.WriteLine("Write some msg.");
msg = Console.ReadLine();
}
GrainClient.Initialize(clientConfig);
var friend = GrainClient.GrainFactory.GetGrain <IHello>(id);
var result = friend.SayHello(msg).Result;
Console.WriteLine(result);
Chat c = new Chat();
var obj = GrainClient.GrainFactory.CreateObjectReference <IChat>(c).Result;
friend.Subscribe(obj);
friend.SendUpdateMessage("456");
client.Close();
}
private static void InitializeImpl_FromConfig(ClientConfiguration config)
{
if (GrainClient.IsInitialized)
{
Trace.TraceInformation("Connection to Orleans gateway silo already initialized.");
return;
}
//// Find endpoint info for the gateway to this Orleans silo cluster
//Trace.WriteLine("Searching for Orleans gateway silo via Orleans instance table...");
var deploymentId = config.DeploymentId;
var connectionString = config.DataConnectionString;
if (String.IsNullOrEmpty(deploymentId))
{
throw new ArgumentException("Cannot connect to Azure silos with null deploymentId", "config.DeploymentId");
}
if (String.IsNullOrEmpty(connectionString))
{
throw new ArgumentException("Cannot connect to Azure silos with null connectionString", "config.DataConnectionString");
}
bool initSucceeded = false;
Exception lastException = null;
for (int i = 0; i < MaxRetries; i++)
{
try
{
//parse through ConfigureLoggingDelegate to GrainClient
GrainClient.ConfigureLoggingDelegate = ConfigureLoggingDelegate;
// Initialize will throw if cannot find Gateways
GrainClient.Initialize(config);
initSucceeded = true;
break;
}
catch (Exception exc)
{
lastException = exc;
Trace.TraceError("Client.Initialize failed with exc -- {0}. Will try again", exc.Message);
}
// Pause to let Primary silo start up and register
Trace.TraceInformation("Pausing {0} awaiting silo and gateways registration for Deployment={1}", StartupRetryPause, deploymentId);
Thread.Sleep(StartupRetryPause);
}
if (initSucceeded)
{
return;
}
OrleansException err;
err = lastException != null ? new OrleansException(String.Format("Could not Initialize Client for DeploymentId={0}. Last exception={1}",
deploymentId, lastException.Message), lastException) : new OrleansException(String.Format("Could not Initialize Client for DeploymentId={0}.", deploymentId));
Trace.TraceError("Error starting Orleans Azure client application -- {0} -- bailing. {1}", err.Message, LogFormatter.PrintException(err));
throw err;
}
static void Main(string[] args)
{
GrainClient.Initialize("ClientConfiguration.xml");
var grain = GrainClient.GrainFactory.GetGrain <IGoodsInfoGrain>("suiji");
var goodsList = grain.GetAllGoods().Result;
Console.WriteLine("按任意键开始购买:");
Console.ReadKey();
if (goodsList != null && goodsList.Count > 0)
{
Task tsk1 = new Task(() =>
{
//Random rd = new Random(10);
for (int i = 0; i < 1000; i++)
{
foreach (var item in goodsList)
{
BuyGoods(item, 1, "张三");
}
}
Console.WriteLine("李四购买结束");
});
Task tsk2 = new Task(() =>
{
//Random rd = new Random(10);
for (int i = 0; i < 1000; i++)
{
foreach (var item in goodsList)
{
BuyGoods(item, 1, "李四");
}
}
Console.WriteLine("李四购买结束");
});
Task tsk3 = new Task(() =>
{
Random rd = new Random(10);
for (int i = 0; i < 1000; i++)
{
foreach (var item in goodsList)
{
BuyGoods(item, rd.Next(1, 10), "王二");
}
}
Console.WriteLine("王二购买结束");
});
tsk1.Start();
tsk2.Start();
tsk3.Start();
}
Console.ReadLine();
Console.Write(strBuild);
}
public void ClientInit_UnThenReinitialize()
{
GrainClient.Uninitialize();
Assert.IsFalse(GrainClient.IsInitialized);
GrainClient.Initialize(HostedCluster.ClientConfiguration);
Assert.IsTrue(GrainClient.IsInitialized);
}
public ClientInitTests(ITestOutputHelper output)
{
this.output = output;
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize("ClientConfigurationForTesting.xml");
}
}
public void ClientInit_InitializeWithDelegate()
{
var wasCalled = false;
GrainClient.ConfigureClientDelegate = clientBuilder => wasCalled = true;
GrainClient.Initialize(this.fixture.ClientConfiguration);
Assert.True(wasCalled);
}
protected void Application_Start()
{
var path = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "ClientConfiguration.xml");
GlobalConfiguration.Configure(WebApiConfig.Register);
GrainClient.Initialize(path);
MonitorsBootstrap.Register();
}
static void Main(string[] args)
{
GrainClient.Initialize("DevTestClientConfiguration.xml");
Run().Wait();
Console.Read();
}
public void ClientInit_UnThenReinitialize()
{
GrainClient.Uninitialize();
Assert.False(GrainClient.IsInitialized);
GrainClient.Initialize(fixture.ClientConfiguration);
Assert.True(GrainClient.IsInitialized);
}
public async Task Start(CancellationToken cancellationToken)
{
Console.WriteLine("Initializing Grain Client...");
GrainClient.Initialize("OrleansClientConfig.xml");
_listener.HandleClient += Listener_HandleClient;
Console.WriteLine("Listening on {0}...", _endPoint);
await _listener.StartListen(_endPoint, cancellationToken);
}
public ClientInitTests(Fixture fixture)
{
this.fixture = fixture;
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize(fixture.ClientConfiguration);
}
}
public void ClientInit_UnThenReinitialize()
{
GrainClient.Uninitialize();
Assert.IsFalse(GrainClient.IsInitialized);
GrainClient.Initialize("ClientConfigurationForTesting.xml");
Assert.IsTrue(GrainClient.IsInitialized);
}
public void Initialize()
{
if (GrainClient.IsInitialized)
{
return;
}
GrainClient.Initialize(_configuration);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
var config = Orleans.Runtime.Configuration.ClientConfiguration.LocalhostSilo();
GrainClient.Initialize(config);
}
public ClientInitTests(DefaultClusterFixture fixture)
{
this.HostedCluster = fixture.HostedCluster;
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize(fixture.HostedCluster.ClientConfiguration);
}
}
static async Task DoClientWork()
{
// basic configuration
var clientconfig = new Orleans.Runtime.Configuration.ClientConfiguration();
clientconfig.Gateways.Add(new IPEndPoint(IPAddress.Loopback, 30000));
GrainClient.Initialize(clientconfig);
var idE1 = "5ad92744-a0b1-487b-a9e7-e6b91e9a9826";
var idE2 = "2eef0ac5-540f-4421-b9a9-79d89400f7ab";
var e1 = GrainClient.GrainFactory.GetGrain <IEmployee>(Guid.Parse(idE1));
var e2 = GrainClient.GrainFactory.GetGrain <IEmployee>(Guid.Parse(idE2));
Console.WriteLine("Current State:");
await e1.Print();
await e2.Print();
if (!await e1.SpendCurrency(10))
{
Console.WriteLine("Employee {0} does not have 10 currency to spend", idE1);
}
if (!await e2.SpendCurrency(10))
{
Console.WriteLine("Employee {0} does not have 10 currency to spend", idE2);
}
await e1.AddCurrency(20);
await e2.AddGoods(10);
await e1.Print();
await e2.Print();
var transaction = new TransactionHelper <EmployeeStateTransfer>();
transaction.Add(e1, new EmployeeStateTransfer()
{
Currency = -5, Goods = 5
});
transaction.Add(e2, new EmployeeStateTransfer()
{
Currency = 5, Goods = -5
});
Console.WriteLine("Executing transaction to trade 5 currency for 5 goods... ");
await transaction.Execute();
Console.WriteLine("Transaction complete.");
await e1.Print();
await e2.Print();
Console.WriteLine("Done!");
}
//---------------------------------------------------------------------
public OrleansClientWrapper(string name, string orleansConfigFile)
{
this.Name = name;
this.AppDomain = AppDomain.CurrentDomain;
Console.WriteLine("Initializing OrleansClientWrapperBase in AppDomain {0}", this.AppDomain.FriendlyName);
GrainClient.Initialize(orleansConfigFile);
}
/// <summary>
/// Initializes the silo client.
/// </summary>
/// <param name="serviceName">
/// The Windows Fabric service name.
/// </param>
/// <param name="config">
/// The configuration, or <see langword="null"/> to load from the current directory.
/// </param>
public static void Initialize(ClientConfiguration config = null)
{
if (config == null)
{
config = ClientConfiguration.StandardLoad();
}
GrainClient.Initialize(config);
}
public static void GrainTestsClassInitialize(TestContext testContext)
{
hostDomain = AppDomain.CreateDomain("OrleansHost", null, new AppDomainSetup {
AppDomainInitializer = InitSilo,
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
});
GrainClient.Initialize("DevTestClientConfiguration.xml");
}
static async Task Start(string[] args)
{
try
{
//var SyncContext = new SynchronizationContext();
//SynchronizationContext.SetSynchronizationContext(SyncContext);
// The Orleans silo environment is initialized in its own app domain in order to more
// closely emulate the distributed situation, when the client and the server cannot
// pass data via shared memory.
var hostDomain = AppDomain.CreateDomain("OrleansHost", null, new AppDomainSetup
{
AppDomainInitializer = InitSilo,
AppDomainInitializerArguments = args,
});
var config = ClientConfiguration.LocalhostSilo();
config.AddSimpleMessageStreamProvider("SimpleStreamProvider");
GrainClient.Initialize(config);
// TODO: once the previous call returns, the silo is up and running.
// This is the place your custom logic, for example calling client logic
// or initializing an HTTP front end for accepting incoming requests.
// configure and start the reporting of silo metrics
// UNCOMMENT BELOW to override configuration defaults
var metrics = GrainClient.GrainFactory.GetGrain <IClusterMetricsGrain>(Guid.Empty);
await metrics.Configure(new MetricsConfiguration
{
Enabled = true, // default
SamplingInterval = TimeSpan.FromSeconds(1), // default
ConfigurationInterval = TimeSpan.FromSeconds(10), // default
StaleSiloMetricsDuration = TimeSpan.FromSeconds(10), // default
LogExceptions = true,
TrackExceptionCounters = true,
TrackMethodGrainCalls = true,
StreamingProviderName = "SimpleStreamProvider",
HistoryLength = 30 // default
});
// TODO: put together a better demo
// start our silly demo simulation
var sim = GrainClient.GrainFactory.GetGrain <ISimulatorGrain>(Guid.Empty);
await sim.StartSimulation(TimeSpan.FromMinutes(10), 200, 200, true);
await SubscribeToStream();
Console.WriteLine("Orleans Silo is running.\nPress Enter to terminate...");
Console.ReadLine();
hostDomain.DoCallBack(ShutdownSilo);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
protected void Application_Start()
{
GrainClient.Initialize(Server.MapPath("ClientConfiguration.xml"));
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
static void Main(string[] args)
{
// The Orleans silo environment is initialized in its own app domain in order to more
// closely emulate the distributed situation, when the client and the server cannot
// pass data via shared memory.
AppDomain hostDomain = AppDomain.CreateDomain("OrleansHost", null, new AppDomainSetup
{
AppDomainInitializer = InitSilo,
AppDomainInitializerArguments = args,
});
GrainClient.Initialize(); // default OrleansClientConfiguration.xml
// TODO: once the previous call returns, the silo is up and running.
// This is the place your custom logic, for example calling client logic
// or initializing an HTTP front end for accepting incoming requests.
Console.WriteLine("Orleans Silo is running.\nEnter exit to terminate...");
Console.ReadLine();
const string systemGrainName1 = "vehicle1";
const string systemGrainName2 = "vehicle2";
foreach (var deviceGrainId in Enumerable.Range(1, 11))
{
GrainClient.GrainFactory.GetGrain <IDeviceGrain>(deviceGrainId)
.JoinSystem(deviceGrainId > 5 ? systemGrainName2 : systemGrainName1)
.Wait();
}
var observer = GrainClient.GrainFactory.CreateObjectReference <ISystemObserver>(new SystemObserver()).Result;
GrainClient.GrainFactory.GetGrain <ISystemGrain>(systemGrainName1).Subscribe(observer);
GrainClient.GrainFactory.GetGrain <ISystemGrain>(systemGrainName2).Subscribe(observer);
var grain = GrainClient.GrainFactory.GetGrain <IDecodeGrain>(1);
string line = null;
while (line != "exit")
{
line = Console.ReadLine();
var parts = line.Split(',');
if (parts.Length == 2 && int.TryParse(parts[0], out int res) && double.TryParse(parts[1], out double temperature))
{
grain.Decode(line);
}
else if (line == "exit")
{
hostDomain.DoCallBack(ShutdownSilo);
}
else
{
Console.WriteLine("Not supported command");
}
}
}
public void ClientInit_MultiInitialize()
{
// First initialize will have been done by orleans unit test base class
GrainClient.Initialize(this.fixture.ClientConfiguration);
Assert.True(GrainClient.IsInitialized);
GrainClient.Initialize(this.fixture.ClientConfiguration);
Assert.True(GrainClient.IsInitialized);
}
public void ClientInit_MultiInitialize()
{
// First initialize will have been done by orleans unit test base class
GrainClient.Initialize("ClientConfigurationForTesting.xml");
Assert.IsTrue(GrainClient.IsInitialized);
GrainClient.Initialize("ClientConfigurationForTesting.xml");
Assert.IsTrue(GrainClient.IsInitialized);
}
