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