static void Main(string[] args)
{
while (true)
{
try
{
GrainClient.Initialize();
break;
}
catch (Exception)
{
Task.Delay(500).Wait();
}
}
Console.WriteLine("Waiting");
Task.Delay(2000).Wait();
Console.WriteLine("Starting");
//var testObserver = GrainClient.GrainFactory.GetGrain<ITestObserver>(0);
var testObserver = new TestObserver();
testObserver.Subscribe().Wait();
Console.ReadLine();
}
private static void InitializeWithRetries(ClientConfiguration config, int initializeAttemptsBeforeFailing)
{
int attempt = 0;
while (true)
{
try
{
GrainClient.Initialize(config);
Console.WriteLine("Client successfully connect to silo host");
break;
}
catch (Exception ex)
{
attempt++;
Console.WriteLine(
$"Attempt {attempt} of {initializeAttemptsBeforeFailing} failed to initialize the Orleans client.");
if (attempt > initializeAttemptsBeforeFailing)
{
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(5));
}
}
}
public Task <Tuple <TExtension, TExtensionInterface> > BindExtension <TExtension, TExtensionInterface>(Func <TExtension> newExtensionFunc)
where TExtension : IGrainExtension
where TExtensionInterface : IGrainExtension
{
// Hookup Extension.
IAddressable currentGrain = RuntimeClient.Current.CurrentActivationData.GrainInstance;
TExtension extension;
if (!TryGetExtensionHandler(out extension))
{
extension = newExtensionFunc();
if (!TryAddExtension(extension))
{
throw new OrleansException("Failed to register " + typeof(TExtension).Name);
}
}
var factoryName = String.Format("{0}.{1}Factory", typeof(TExtensionInterface).Namespace, typeof(TExtensionInterface).Name.Substring(1)); // skip the I
var currentTypedGrain = (TExtensionInterface)GrainClient.InvokeStaticMethodThroughReflection(
typeof(TExtensionInterface).Assembly.FullName,
factoryName,
"Cast",
new Type[] { typeof(IAddressable) },
new object[] { currentGrain });
return(Task.FromResult(Tuple.Create(extension, currentTypedGrain)));
}
public async Task CartCanUpdateCartAsync()
{
// Arrange
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize();
}
IGrainCart cartGrain = GrainFactory.GetGrain <IGrainCart>(Guid.NewGuid());
Cart cart = new Cart();
// Act
cart = await cartGrain.AddCartItemAsync(_cartItem);
await cartGrain.UpdateCartAsync();
cart = await cartGrain.GetCartAsync();
// Assert
Assert.IsNotNull(cart);
Assert.IsInstanceOfType(cart, typeof(Cart));
Assert.IsNotNull(cart.CartItems);
Assert.AreEqual(cart.Total, 2.58M);
// Clean up
await cartGrain.ClearStateAsync();
GrainClient.Uninitialize();
}
public async Task CartCanRemoveCartItemAsync()
{
// Arrange
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize();
}
IGrainCart cartGrain = GrainFactory.GetGrain <IGrainCart>(Guid.NewGuid());
Cart cart = new Cart(); // do we have CartItems?
// Act
cart = await cartGrain.AddCartItemAsync(_cartItem);
cart = await cartGrain.RemoveCartItemAsync(_cartItem);
var t = cart.CartItems.Find(i => i.CartItemId == _cartItem.CartItemId);
// Assert
Assert.IsNotNull(cart);
Assert.IsInstanceOfType(cart, typeof(Cart));
Assert.IsNotNull(cart.CartItems);
Assert.AreEqual(cart.CartItems.Count, 0);
// Clean up
await cartGrain.ClearStateAsync();
GrainClient.Uninitialize();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
if (AzureEnvironment.IsInAzure)
{
// running in Azure
if (AzureClient.IsInitialized == false)
{
var clientConfigurationFile = AzureConfigUtils.ClientConfigFileLocation;
if (clientConfigurationFile.Exists == false)
{
throw new FileNotFoundException(string.Format("Cannot find orleans config file for initialization at {0}", clientConfigurationFile.FullName), clientConfigurationFile.FullName);
}
AzureClient.Initialize(clientConfigurationFile);
}
}
else
{
// not running in Azure
GrainClient.Initialize(Server.MapPath("/ClientOrleansConfiguration.xml"));
}
}
protected void Application_Start()
{
const int InitializeAttemptsBeforeFailing = 5;
var config = ClientConfiguration.LocalhostSilo();
int attempt = 0;
while (true)
{
try
{
GrainClient.Initialize("client.xml");
Trace.WriteLine("Client successfully connect to silo host");
break;
}
catch (SiloUnavailableException)
{
attempt++;
Trace.TraceWarning($"Attempt {attempt} of {InitializeAttemptsBeforeFailing} failed to initialize the Orleans client.");
if (attempt > InitializeAttemptsBeforeFailing)
{
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(2));
}
}
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleTable.EnableOptimizations = false;
BundleConfig.RegisterBundles(BundleTable.Bundles);
//XapianLogic xl = new XapianLogic();
//Thread thread = new Thread(new ThreadStart(XapianLogic.easyforthread));
//thread.IsBackground = true;//这样能随主程序一起结束
//thread.Start();
}
private void InitGameServer()
{
//var config = ClientConfiguration.LocalhostSilo();
GrainClient.Initialize(new System.IO.FileInfo("ClientConfiguration.xml"));
//var config = Orleans.Runtime.Configuration.ClientConfiguration.LocalhostSilo(6667);
//GrainClient.Initialize(config);
}
async Task IMessagesMonitor.StartTracking()
{
var provider = GrainClient.GetStreamProvider("SMSProvider");
var room = provider.GetStream <RoomMessage>(Streams.Id, "default");
handle = await room.SubscribeAsync(this);
}
public async Task BingLocationCanGetGeocodeAsyncFromGeoLocation()
{
// Arrange
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize();
}
var geoLocation = new GeoLocation()
{
addressLine = "2400 NW 80th St. #163",
locality = "Seattle",
adminDistrict = "WA",
postalCode = "98117",
countryRegion = "US",
};
// Act
var testGrain = GrainFactory.GetGrain <IServiceGrainBingLocation>(Guid.NewGuid());
var testGrainResult = await testGrain.GetGeocodeAsync(geoLocation);
// Assert
Assert.IsNotNull(testGrainResult);
Assert.IsInstanceOfType(testGrainResult, typeof(GeoLocation));
Assert.IsNotNull(testGrainResult.latitude);
Assert.IsNotNull(testGrainResult.longitude);
// Clean up
GrainClient.Uninitialize();
}
public virtual void Dispose()
{
if (GrainClient.IsInitialized)
{
GrainClient.Uninitialize();
}
if (ServiceAppDomain != null)
{
ServiceAppDomain.RunOnContext(() =>
{
Host.Stop();
Host.Dispose();
var completed = StopTask.Wait(60000);
if (!completed)
{
throw new TimeoutException("ServiceTester: The service failed to shutdown within the 60 second limit.");
}
});
Kill();
}
LogListener.Close();
}
protected override void ProcessRecord()
{
if (GrainClient.IsInitialized)
{
GrainClient.Uninitialize();
}
}
#pragma warning restore IDE0022 // Use expression body for methods
private static void UseOrleansLocally()
{
Program.userName = Program.GetUserName();
var config = ClientConfiguration.LocalhostSilo(30000);
while (true)
{
try
{
var client =
new ClientBuilder().UseConfiguration(config).Build();
client.Connect().GetAwaiter().GetResult();
break;
}
// TODO: Get Rocky to stop laughing at me.
catch
{
Task.Delay(TimeSpan.FromSeconds(1));
}
}
GrainClient.Initialize(config);
Console.Out.WriteLine("Begin...");
using (var keyLogger = new BufferedEventedNativeKeyWatcher(Program.BufferSize))
{
keyLogger.KeysLogged += Program.OnKeysLogged;
Application.Run();
}
}
public void GatewaySelection_ClientInit_EmptyList()
{
var cfg = new ClientConfiguration();
cfg.Gateways = null;
bool failed = false;
try
{
GrainClient.Initialize(cfg);
}
catch (Exception exc)
{
Console.WriteLine(exc);
failed = true;
}
Assert.IsTrue(failed, "GatewaySelection_EmptyList failed as GatewayManager did not throw on empty Gateway list.");
// Note: This part of the test case requires a silo local to be running in order to work successfully.
//var listProvider = new TestListProvider(gatewayAddressUris);
//cfg.Gateways = listProvider.GetGateways().Select(uri =>
//{
// return new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port);
//}).ToList();
//Client.Initialize(cfg);
}
public async Task SubscribeFromClientTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
var producer = GrainClient.GrainFactory.GetGrain <ISampleStreaming_ProducerGrain>(Guid.NewGuid());
int eventCount = 0;
var provider = GrainClient.GetStreamProvider(streamProviderName);
var stream = provider.GetStream <int>(streamGuid, streamNamespace);
var handle = await stream.SubscribeAsync((e, t) =>
{
eventCount++;
return(TaskDone.Done);
});
// produce some messages
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
// check
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, () => eventCount, lastTry), Timeout);
// unsubscribe
await handle.UnsubscribeAsync();
}
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(TraceLogger.IsInitialized, "Logger.IsInitialized");
try
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = true;
Xunit.Assert.Throws <InvalidOperationException>(() =>
GrainClient.Initialize(cfg));
Assert.IsFalse(GrainClient.IsInitialized, "GrainClient.IsInitialized");
Assert.IsFalse(TraceLogger.IsInitialized, "Logger.IsInitialized");
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
GrainClient.Initialize(cfg);
Assert.IsTrue(GrainClient.IsInitialized, "GrainClient.IsInitialized");
Assert.IsTrue(TraceLogger.IsInitialized, "Logger.IsInitialized");
}
finally
{
OutsideRuntimeClient.TestOnlyThrowExceptionDuringInit = false;
}
}
//-------------------------------------------------------------------------
static void Main(string[] args)
{
GrainClient.Initialize("BaseClientConfiguration.xml");
Console.Title = "FishingBase";
ProgramConfig config = new ProgramConfig();
config.load("./FishingBase.exe.config");
EsEngineSettings settings;
settings.NodeType = 2;
settings.NodeTypeString = "Base";
settings.ListenIp = config.ListenIp;
settings.ListenPort = config.ListenPort;
settings.RootEntityType = "EtRoot";
settings.EnableCoSupersocket = true;
settings.Log4NetConfigPath = "../../../Media/Fishing/Config/FishingBase.log4net.config";
try
{
EsEngine e = new EsEngine(ref settings, new EsEngineListener());
e.run();
}
catch (System.Exception ex)
{
EbLog.Note(ex.ToString());
}
GrainClient.Uninitialize();
}
public DevelopmentOrleansClientContext()
{
var config = ClientConfiguration.LocalhostSilo(30000);
config.DefaultTraceLevel = Severity.Warning;
GrainClient.Initialize(config);
}
static void Main(string[] args)
{
//var clientConfig = ClientConfiguration.LocalhostSilo(30000);
var client = new ClientBuilder().LoadConfiguration("ClientConfiguration.xml").Build();//.UseConfiguration(clientConfig).Build();
client.Connect().Wait();
Console.WriteLine("Client connected.");
//GrainClient.Initialize(clientConfig);
GrainClient.Initialize();
var nomnioGrain = GrainClient.GrainFactory.GetGrain <ICacheGrain>("nomnio.com");
Console.WriteLine("\n\n{0}\n\n", nomnioGrain.AddEmail("*****@*****.**").Result);
Console.WriteLine("\n\n{0}\n\n", nomnioGrain.GetEmail("*****@*****.**").Result);
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
client.Close();
}
public void Initialize()
{
if (strategyKind != AnalysisStrategyKind.ONDEMAND_ORLEANS)
{
return;
}
System.Console.WriteLine("Initializing Orleans silo...");
var applicationPath = Environment.CurrentDirectory;
var appDomainSetup = new AppDomainSetup
{
AppDomainInitializer = InitSilo,
ApplicationBase = applicationPath,
ApplicationName = "CallGraphGeneration",
AppDomainInitializerArguments = new string[] { },
ConfigurationFile = "CallGraphGeneration.exe.config"
};
// set up the Orleans silo
hostDomain = AppDomain.CreateDomain("OrleansHost", null, appDomainSetup);
var xmlConfig = "ClientConfigurationForTesting.xml";
Contract.Assert(File.Exists(xmlConfig), "Can't find " + xmlConfig);
GrainClient.Initialize(xmlConfig);
System.Console.WriteLine("Orleans silo initialized successfully");
}
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);
}
static void Main(string[] args)
{
Console.Title = "Client";
var config = ClientConfiguration.LoadFromFile("ClientConfiguration.xml");
while (true)
{
try
{
GrainClient.Initialize(config);
Console.WriteLine("Connected to silo");
break;
}
catch (SiloUnavailableException)
{
Console.WriteLine("Silo not available! Retrying in 3 seconds.");
Thread.Sleep(3000);
}
}
var joe = GrainClient.GrainFactory.GetGrain <IPersonGrain>("Joe");
joe.SayHelloAsync();
joe.SayHelloAsync();
var sam = GrainClient.GrainFactory.GetGrain <IPersonGrain>("Sam");
sam.SayHelloAsync();
sam.SayHelloAsync();
Console.ReadLine();
}
public async Task CartCanAddCartItemAsync()
{
// Arrange
if (!GrainClient.IsInitialized)
{
GrainClient.Initialize();
}
IGrainCart cartGrain = GrainFactory.GetGrain <IGrainCart>(Guid.NewGuid());
Cart cart = new Cart();
// Act
try
{
cart = await cartGrain.AddCartItemAsync(_cartItem);
}
catch (Exception ex)
{
throw;
}
// Assert
Assert.IsNotNull(cart);
Assert.IsInstanceOfType(cart, typeof(Cart));
Assert.IsNotNull(cart.CartItems);
Assert.AreEqual(cart.CartItems.Count, 1);
// Clean up
await cartGrain.ClearStateAsync();
GrainClient.Uninitialize();
}
public 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,
});
var config = ClientConfiguration.LocalhostSilo();
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.
Console.WriteLine("Orleans Silo is running.");
MainAsync().Wait();
Console.WriteLine("\nPress Enter to terminate...");
Console.ReadLine();
hostDomain.DoCallBack(ShutdownSilo);
}
public async Task MultipleImplicitSubscriptionTest()
{
logger.Info("************************ MultipleImplicitSubscriptionTest *********************************");
var streamId = Guid.NewGuid();
const int nRedEvents = 5, nBlueEvents = 3;
var provider = GrainClient.GetStreamProvider(StreamTestsConstants.SMS_STREAM_PROVIDER_NAME);
var redStream = provider.GetStream <int>(streamId, "red");
var blueStream = provider.GetStream <int>(streamId, "blue");
for (int i = 0; i < nRedEvents; i++)
{
await redStream.OnNextAsync(i);
}
for (int i = 0; i < nBlueEvents; i++)
{
await blueStream.OnNextAsync(i);
}
var grain = GrainClient.GrainFactory.GetGrain <IMultipleImplicitSubscriptionGrain>(streamId);
var counters = await grain.GetCounters();
Assert.AreEqual(nRedEvents, counters.Item1);
Assert.AreEqual(nBlueEvents, counters.Item2);
}
private async Task GenerateEvents(string streamNamespace, int streamCount, int eventsInStream)
{
IStreamProvider streamProvider = GrainClient.GetStreamProvider(StreamProviderName);
IAsyncStream <GeneratedEvent>[] producers =
Enumerable.Range(0, streamCount)
.Select(i => streamProvider.GetStream <GeneratedEvent>(Guid.NewGuid(), streamNamespace))
.ToArray();
for (int i = 0; i < eventsInStream - 1; i++)
{
// send event on each stream
for (int j = 0; j < streamCount; j++)
{
await producers[j].OnNextAsync(new GeneratedEvent {
EventType = GeneratedEvent.GeneratedEventType.Fill
});
}
}
// send end events
for (int j = 0; j < streamCount; j++)
{
await producers[j].OnNextAsync(new GeneratedEvent {
EventType = GeneratedEvent.GeneratedEventType.End
});
}
}
private async Task GenerateEvents(string streamNamespace, List <Guid> streamGuids, int eventsInStream, int payloadSize)
{
IStreamProvider streamProvider = GrainClient.GetStreamProvider(StreamProviderName);
IAsyncStream <GeneratedEvent>[] producers = streamGuids
.Select(streamGuid => streamProvider.GetStream <GeneratedEvent>(streamGuid, streamNamespace))
.ToArray();
for (int i = 0; i < eventsInStream - 1; i++)
{
// send event on each stream
for (int j = 0; j < streamGuids.Count; j++)
{
await producers[j].OnNextAsync(new GeneratedEvent {
EventType = GeneratedEvent.GeneratedEventType.Fill, Payload = new int[payloadSize]
});
}
}
// send end events
for (int j = 0; j < streamGuids.Count; j++)
{
await producers[j].OnNextAsync(new GeneratedEvent {
EventType = GeneratedEvent.GeneratedEventType.Report, Payload = new int[payloadSize]
});
}
}
static void Main(string[] args)
{
Console.Title = "Client";
var config = ClientConfiguration.LoadFromFile("ClientConfiguration.xml");
while (true)
{
try
{
GrainClient.Initialize(config);
Console.WriteLine("Connected to silo");
break;
}
catch (SiloUnavailableException)
{
Console.WriteLine("Silo not available! Retrying in 3 seconds.");
Thread.Sleep(3000);
}
}
var random = new Random();
while (true)
{
var grainId = random.Next();
var grain = GrainClient.GrainFactory.GetGrain <IPersonGrain>("beck" + grainId);
grain.SayHelloAsync().Wait();
}
}
public void ConfigureGrainClient()
{
var config = ClientConfiguration.LocalhostSilo();
config.AddSimpleMessageStreamProvider(MetricsStreamProvider);
// Attempt to connect a few times to overcome transient failures and to give the silo enough
// time to start up when starting at the same time as the client (useful when deploying or during development).
const int initializeAttemptsBeforeFailing = 5;
int attempt = 0;
while (true)
{
try
{
GrainClient.Initialize(config);
break;
}
catch (SiloUnavailableException e)
{
attempt++;
if (attempt >= initializeAttemptsBeforeFailing)
{
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(2));
}
}
}
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,
});
var config = ClientConfiguration.LocalhostSilo();
GrainClient.Initialize(config);
var sender = GrainClient.GrainFactory.GetGrain <ISender>(0);
Task t = sender.DoSomething(10);
Console.WriteLine("SILO ???");
//System.Diagnostics.Contracts.Contract.Assert(false);
Console.WriteLine("Orleans Silo is running.\nPress Enter to terminate...");
Console.ReadLine();
hostDomain.DoCallBack(ShutdownSilo);
}
