protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting DUCK TYPE TEST"); var helloObject = new HelloClass(); var iHello = helloObject.ActAs <IHello>(); dynamic helloDynamic = new HelloDynamicObject(); var iHelloDynamic = ((object)helloDynamic).ActAs <IHello>(); helloObject.Test(Guid.NewGuid(), "ES"); iHello.Test(Guid.NewGuid(), "ES"); helloDynamic.Test(Guid.NewGuid(), "ES"); iHelloDynamic.Test(Guid.NewGuid(), "ES"); // Core.Log.InfoBasic(helloObject.Suma(12, 12).ToString()); Core.Log.InfoBasic(iHello.Suma(12, 12).ToString()); Core.Log.InfoBasic(helloDynamic.Suma(12, 12).ToString()); Core.Log.InfoBasic(iHelloDynamic.Suma(12, 12).ToString()); for (var i = 0; i < 50; i++) { Core.Log.InfoBasic("Calling the object method"); helloObject.SayHello(); Core.Log.InfoBasic("Calling the interface method on static object"); iHello.SayHello(); Core.Log.InfoBasic("Calling the dynamic method"); helloDynamic.SayHello(); Core.Log.InfoBasic("Calling the interface method on dynamic object"); iHelloDynamic.SayHello(); } }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting HASH TEST"); var gId = Guid.NewGuid(); var gIdBytes = gId.ToByteArray(); Core.Log.InfoBasic("Guid: {0}", gId); var sha1 = gIdBytes.GetHashSHA1(); Core.Log.InfoBasic("SHA1 {0}", sha1); var sha256 = gIdBytes.GetHashSHA256(); Core.Log.InfoBasic("SHA256: {0}", sha256); var sha384 = gIdBytes.GetHashSHA384(); Core.Log.InfoBasic("SHA384: {0}", sha384); var sha512 = gIdBytes.GetHashSHA512(); Core.Log.InfoBasic("SHA512: {0}", sha512); var md5 = gIdBytes.GetHashMD5(); Core.Log.InfoBasic("MD5: {0}", md5); }
protected override void OnHandler(ParameterHandlerInfo info) { var instance1 = Core.Injector.New <IInjectTestA>("Default"); var instance2 = Core.Injector.New <IInjectTestA>("Default"); if (instance1 != instance2) { Core.Log.InfoBasic("The instance are differents. OK"); } else { Core.Log.Error("The instance is the same. Error"); } var guid1 = instance1.GetGuid(); var guid2 = instance2.GetGuid(); if (guid1 != guid2) { Core.Log.InfoBasic("The Guid are differents. OK"); } else { Core.Log.Error("The Guid are the same. Error"); } }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting COMPRESSOR TEST"); Core.Log.InfoBasic("Generating Random Bytes"); var rnd = new Random(); var bytes = new byte[ushort.MaxValue * 2000]; for (var i = 0; i < bytes.Length; i++) { bytes[i] = (byte)rnd.Next(50, 60); } Core.Log.InfoBasic("Total Bytes = {0}", bytes.Length.ToReadableBytes()); Core.Log.InfoBasic("Creating GZip Compressor"); var gzipCompressor = CompressorManager.GetByEncodingType("gzip"); using (Watch.Create("GZIP COMPRESSOR")) { var gzipBytes = gzipCompressor.Compress(bytes); Core.Log.InfoBasic("Total GZIP Bytes = {0} - {1:0.000}%", gzipBytes.Count.ToReadableBytes(), ((double)gzipBytes.Count * 100) / bytes.Length); } Core.Log.InfoBasic("Creating Deflate Compressor"); var deflateCompressor = CompressorManager.GetByEncodingType("deflate"); using (Watch.Create("DEFLATE COMPRESSOR")) { var deflateBytes = deflateCompressor.Compress(bytes); Core.Log.InfoBasic("Total DEFLATE Bytes = {0} - {1:0.000}%", deflateBytes.Count.ToReadableBytes(), ((double)deflateBytes.Count * 100) / bytes.Length); } }
protected override void OnHandler(ParameterHandlerInfo info) { var queues = Core.Services.GetDefaultQueuesConfiguration(); if (queues == null) { Core.Log.Warning("Nothing to do."); return; } Core.Log.WriteEmptyLine(); Core.Log.InfoBasic("Checking, Creating and settings permissions to the Queues:"); Core.Log.WriteEmptyLine(); foreach (var queue in queues.Items) { Core.Log.InfoBasic("Processing queue = {0}", queue.Name); if (queue.Types.Admin.IsNotNullOrEmpty()) { var manager = queue.GetQueueManager(); manager.CreateClientQueues(); manager.CreateServerQueues(); } else { Core.Log.Warning("Queue was skipped because the Admin type wasn't found in the queues.xml"); } Core.Log.WriteEmptyLine(); } }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { Core.DebugMode = true; Core.Log.Warning("Slack Bot Test"); Core.Log.InfoBasic("Please enter the Bot Token:"); var token = Console.ReadLine(); var slackTransport = new SlackBotTransport(token); var botEngine = new BotEngine(slackTransport); botEngine.Commands.Add(msg => msg.StartsWith("Hello"), (bot, message) => { Core.Log.Warning(message.SerializeToJson()); bot.SendTextMessageAsync(message.Chat, "Message Received"); return(true); }); Core.Log.Warning("Connecting..."); await botEngine.StartListenerAsync().ConfigureAwait(false); Core.Log.Warning("Connected."); Console.ReadLine(); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting STATUS TEST"); var rootNodeOne = new Node { Name = "Root Node 1", Value = "Root Value 1" }; var rootNodeTwo = new Node { Name = "Root Node 2", Value = "Root Value 2" }; var nodeOne = new Node { Name = "Node 1", Value = "Value 1" }; var nodeTwo = new Node { Name = "Node 2", Value = "Value 2" }; var lst = new List <Node>(); var lst2 = new List <Node>(); var dct = new Dictionary <string, Node>(); //Core.Status.AttachChild(nodeOne, this); Core.Status.AttachChild(nodeTwo, this); Core.Status.AttachChild(lst, this); Core.Status.AttachChild(lst2, this); Core.Status.AttachObject(dct); Core.Status.AttachChild(rootNodeOne, this); Core.Status.AttachChild(nodeOne, rootNodeOne); Console.ReadLine(); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting WEAK TEST"); WeakSample(); Console.ReadLine(); }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { var settings = Config.DeserializeFromXml <CacheSettings>(); Core.Services.SetDefaultCacheClientSettings(settings); var cacheClient = await Core.Services.GetCacheClientAsync("Agsw.Services.Cache").ConfigureAwait(false); var keys = await cacheClient.GetKeysAsync().ConfigureAwait(false); Core.Log.InfoBasic("Keys: {0}", keys.Length); }
protected override void OnHandler(ParameterHandlerInfo info) { Lru2QStorageTest(); Core.Log.InfoBasic("Press ENTER to continue."); Console.ReadLine(); FileStorageTest(); Core.Log.InfoBasic("Press ENTER to continue."); Console.ReadLine(); CombinedTest(); Core.Log.InfoBasic("Press ENTER to exit."); Console.ReadLine(); }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { for (var i = 0; i < 100; i++) { Core.Log.Error("NUMBER: {0}", i); await Task.WhenAll( CacheSingleTest(), CacheSingleTest() ).ConfigureAwait(false); await Task.Delay(2000).ConfigureAwait(false); } }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { Core.DebugMode = false; Core.Log.Warning("Starting CACHE Async TEST"); var cacheService = new TestCacheService(); cacheService.OnStart(null); using (var cachePool = new CacheClientPoolAsync("Pool Test") { Serializer = GlobalSerializer, ForceAtLeastOneNetworkItemEnabled = false, WriteNetworkItemsToMemoryOnGet = true }) { var cacheClient = await CacheClientProxy.GetClientAsync(new DefaultTransportClient("127.0.0.1", 20051, 3, GlobalSerializer)).ConfigureAwait(false); cachePool.Add("localhost:20051", cacheClient, StorageItemMode.ReadAndWrite); //cachePool.Add("memory", new LRU2QStorage(2000), StorageItemMode.ReadAndWrite); var res = await cachePool.GetMetaAsync("metaValue").ConfigureAwait(false); await cachePool.GetKeysAsync().ConfigureAwait(false); using (var watch = Watch.Create("GetKeysAsync")) { for (var i = 0; i < 1000; i++) { await cachePool.GetKeysAsync().ConfigureAwait(false); } Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 1000); } Console.ReadLine(); using (var watch = Watch.Create("Get And Sets")) { for (var i = 0; i < 5000; i++) { var key = "test-" + (i % 500); await cachePool.GetAsync(key).ConfigureAwait(false); await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false); } Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 5000); } } cacheService.OnStop(); Console.ReadLine(); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting Cache Timeout Collection Test"); var cacheTimeoutCollection = CacheTimeoutCollection <string, object> .CreateFromLRU2Q(100); cacheTimeoutCollection.OnItemTimeout += CacheTimeoutCollection_OnItemTimeout; cacheTimeoutCollection.OnRemovedByPaging += CacheTimeoutCollection_OnRemovedByPaging; for (var i = 0; i < 1000; i++) { cacheTimeoutCollection.TryAdd("Key - " + i, null, TimeSpan.FromSeconds(5)); } Task.Delay(10000).WaitAsync(); }
protected override void OnHandler(ParameterHandlerInfo info) { Thread.Sleep(1000); Core.Log.Warning("Starting HIT TEST"); Run(0, 50_000, 10_000_000, 50_000); Thread.Sleep(2000); Core.Log.WriteEmptyLine(); Core.Log.WriteEmptyLine(); Core.Log.Warning("Starting INSERTION/DELETE TEST"); Run(0, 200_000_000, 10_000_000, 50_000); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting ENCRYPTION TEST"); var message = "Hola Mundo esto es una prueba de encriptación, espero que funcione"; var skp = new SymmetricKeyProvider(); Core.Log.InfoBasic(message); var enc = skp.Encrypt(message, "password"); Core.Log.InfoBasic(enc); var dec = skp.Decrypt(enc, "password"); Core.Log.InfoBasic(dec); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting String Hash Test"); var str = "Lorem ipsum dolor sit amet"; int number = 10_000_000; int normalHash = 0; uint superFastHash = 0; uint murmurhash2 = 0; uint murmurhash3 = 0; str.GetHashCode(); str.GetSuperFastHash(); str.GetMurmurHash2(); str.GetMurmurHash3(); using (Watch.Create("Normal Hash - GetHashCode()")) { for (var i = 0; i < number; i++) { normalHash = (str + i).GetHashCode(); } } using (Watch.Create("Superfast Hash - GetSuperFastHash()")) { for (var i = 0; i < number; i++) { superFastHash = (str + i).GetSuperFastHash(); } } using (Watch.Create("MurmurHash2 Hash - GetMurmurHash2()")) { for (var i = 0; i < number; i++) { murmurhash2 = (str + i).GetMurmurHash2(); } } using (Watch.Create("MurmurHash3 Hash - GetMurmurHash3()")) { for (var i = 0; i < number; i++) { murmurhash3 = (str + i).GetMurmurHash3(); } } Core.Log.InfoBasic("Normal Hash: {0}", normalHash); Core.Log.InfoBasic("Superfast Hash: {0}", superFastHash); Core.Log.InfoBasic("MurmurHash2 Hash: {0}", murmurhash2); Core.Log.InfoBasic("MurmurHash3 Hash: {0}", murmurhash3); }
protected override void OnHandler(ParameterHandlerInfo info) { var consumer = new AsyncConsumerEnumerable <string> { Task.Run(() => "Hola"), Task.Delay(5000).ContinueWith(t => "Esperó 5 segundos"), Task.Delay(2000).ContinueWith(t => "Mundo (tenia una espera de 2 pero ya se habia cumplido)"), Task.Run(() => new[] { "Tambien", "Soporto", "Arrays" }) }; foreach (var c in consumer) { Console.WriteLine(c); } Console.ReadLine(); }
protected override void OnHandler(ParameterHandlerInfo info) { var n2obj1 = Core.Injector.New <IInjectTestA>("Default"); var n2obj2 = Core.Injector.New <IInjectTestB>("Default"); var instance1 = Core.Injector.New <IInjectTestA>("Default"); var instance2 = Core.Injector.New <IInjectTestA>("Default"); var times = 10_000_000; Core.Log.InfoBasic("Injector Number of times: {0}", times); using (var w = Watch.Create("Injector Object A")) for (var i = 0; i < times; i++) { Core.Injector.New <IInjectTestA>("Default"); } using (var w = Watch.Create("Injector Object B")) for (var i = 0; i < times; i++) { Core.Injector.New <IInjectTestB>("Default"); } if (instance1 != instance2) { Core.Log.InfoBasic("The instance are differents. OK"); } else { Core.Log.Error("The instance is the same. Error"); } var guid1 = instance1.GetGuid(); var guid2 = instance2.GetGuid(); if (guid1 != guid2) { Core.Log.InfoBasic("The Guid are differents. OK"); } else { Core.Log.Error("The Guid are the same. Error"); } }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting HTTP TEST"); info.Service = new TaskService(async token => { var server = new SimpleHttpServer() .AddGetHandler("/", context => { context.Response.WriteLine("Hola Mundo"); }) .AddHttpControllerRoutes <MyController>(); await server.StartAsync(8085).ConfigureAwait(false); Core.Log.InfoBasic("Listening to port 8085"); await Task.Run(() => token.WaitHandle.WaitOne(), token).ConfigureAwait(false); await server.StopAsync().ConfigureAwait(false); }); info.ShouldEndExecution = false; }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { var serializer = new NBinarySerializer(); var service = new SampleProvider(); Core.Log.InfoBasic("Setting RPC Server"); var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer)); rpcServer.AddService(typeof(ISampleProvider), service); await rpcServer.StartAsync().ConfigureAwait(false); Core.Log.InfoBasic("Setting RPC Client"); var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer)); var hClient = await rpcClient.CreateDynamicProxyAsync <ISampleProvider>().ConfigureAwait(false); var client = hClient.ActAs <ISampleProvider>(); Core.Log.InfoBasic("GetSampleAsync"); var sampleTsk = await client.GetSampleAsync().ConfigureAwait(false); Core.Log.InfoBasic("DelayTestAsync"); await client.DelayTestAsync().ConfigureAwait(false); Core.Log.InfoBasic("GetSample"); var sample = client.GetSample(); Core.Log.InfoBasic("GetSample as Async"); var sampleSimAsync = ((dynamic)hClient).GetSample2Async().Result; var pClient = await rpcClient.CreateProxyAsync <SampleProxy>().ConfigureAwait(false); Core.Log.InfoBasic("GetSampleAsync"); var sampleTsk2 = await pClient.GetSampleAsync().ConfigureAwait(false); Core.Log.InfoBasic("DelayTestAsync"); await pClient.DelayTestAsync().ConfigureAwait(false); Core.Log.InfoBasic("GetSample"); var sample2 = pClient.GetSample(); rpcClient.Dispose(); await rpcServer.StopAsync().ConfigureAwait(false); }
protected override void OnHandler(ParameterHandlerInfo info) { var consumer = new ProducerConsumerEnumerable <string>(async(producer, token) => { for (var i = 0; i < 2500; i++) { producer.Add("Valor: " + i); await Task.Delay(1, token).ConfigureAwait(false); } }); Task.Run(async() => { await consumer.ForEachAsync(value => { Console.WriteLine(value); }).ConfigureAwait(false); Console.WriteLine("Async Finished 1"); }); Task.Run(async() => { await consumer.ForEachAsync(value => { Console.WriteLine(value); }).ConfigureAwait(false); Console.WriteLine("Async Finished 2"); }); Task.Run(async() => { await consumer.ForEachAsync(value => { Console.WriteLine(value); }).ConfigureAwait(false); Console.WriteLine("Async Finished 3"); }); Console.ReadLine(); }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { try { Core.Log.Warning("Starting BROWSER EMULATOR TEST"); var be = new BrowserEmulator(); Core.Log.Verbose("Getting: www.google.com"); var br = await be.NavigateAsync(new BrowserRequest { RequestUrl = "http://www.google.com" }).ConfigureAwait(false); var response = Encoding.UTF8.GetString(br.Content); Core.Log.Verbose("Results:"); Core.Log.InfoBasic(response); Core.Log.InfoBasic("END"); } catch (Exception ex) { Core.Log.Write(ex); } }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting SQL Server Test"); IDalCity dalCity = new DalCity(); using (Watch.Create("Sync Test")) { for (var i = 0; i < 30; i++) { using (var w = Watch.Create()) { var values = dalCity.GetAll(); w.Tap("GetAll"); var arr = values.ToArray(); w.Tap($"Entity Binding: {arr.Length} items"); } } } Console.ReadLine(); Task.Run(async() => { using (Watch.Create("Async Test")) { for (var i = 0; i < 30; i++) { using (var w = Watch.Create()) { var values = await dalCity.GetAllAsync().ConfigureAwait(false); w.Tap("GetAll"); var arr = values.ToArray(); w.Tap($"Entity Binding: {arr.Length} items"); } } } }); Console.ReadLine(); }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { Core.Log.Warning("Starting MemoryQueue Test"); #region Set Config var mqConfig = GetConfig(); #endregion JsonTextSerializerExtensions.Serializer.Indent = true; mqConfig.SerializeToXmlFile("memoryqConfig.xml"); mqConfig.SerializeToJsonFile("memoryqConfig.json"); var manager = mqConfig.GetQueueManager(); manager.CreateClientQueues(); //Core.DebugMode = true; //Core.Log.MaxLogLevel = Diagnostics.Log.LogLevel.InfoDetail; Core.Log.Warning("Starting with Normal Listener and Client"); await NormalTest(mqConfig).ConfigureAwait(false); }
protected override void OnHandler(ParameterHandlerInfo info) { var lstMetadatas = new KeyValue[] { new KeyValue("Key01", "Value01"), new KeyValue("Key02", "Value02"), new KeyValue("Key01", "Value01 - New Value"), new KeyValue("Key02", "Value02 - New Value"), new KeyValue("Key03", "Value03") }; var mergeEnumerable = lstMetadatas.Merge(item => item.Key, values => { return(new KeyValue(values.First().Key, string.Join(", ", values.Select(v => v.Value)))); }); var mergeList = mergeEnumerable.ToList(); foreach (var keyValue in mergeList) { Console.WriteLine($"Key = {keyValue.Key}, Value = {keyValue.Value}"); } }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting Serializer TEST"); if (info.Arguments?.Contains("/complex") == true) { var file = "c:\\temp\\complex.test.nbin.gz"; var serializer = SerializerManager.GetByFileName(file); AssemblyResolverManager.RegisterDomain(new[] { @"C:\AGSW_GIT\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" }); //AssemblyResolverManager.RegisterDomain(new[] { @"C:\Repo\AgswGit\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" }); object value = null; try { value = serializer.DeserializeFromFile <object>(file); //value = rMsg.Body.GetValue(); } catch (DeserializerException exGO) { var jsonSerializer = new JsonTextSerializer { Indent = true }; jsonSerializer.SerializeToFile(exGO.Value, "c:\\temp\\complexObject-GenericObject.json"); var val = exGO.Value["Products"][5]; } RunTestEx(value, 500, null); //GC.Collect(); //GC.WaitForFullGCComplete(); //RunTestEx(value, 200, new GZipCompressor()); //GC.Collect(); //GC.WaitForFullGCComplete(); //RunTestEx(value, 200, new DeflateCompressor()); return; } var sTest = new STest { FirstName = "Daniel", LastName = "Redondo", Age = 33, value = 166 }; var collection = new List <List <STest> >(); for (var i = 0; i <= 10; i++) { var colSTest = new List <STest> { sTest, sTest, sTest, sTest, sTest, sTest, sTest, sTest, sTest, sTest, sTest, sTest, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 0, Age = 1, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 1, Age = 2, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 2, Age = 3, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 3, Age = 4, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 4, Age = 5, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 5, Age = 6, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 6, Age = 7, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 7, Age = 8, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 8, Age = 9, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 9, Age = 10, Brother = sTest }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 10, Age = 11 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 11, Age = 12 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 12, Age = 13 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 13, Age = 14 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 14, Age = 15 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 15, Age = 16 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 16, Age = 17 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 17, Age = 18 }, new STest { FirstName = "Person", LastName = "Person" + i + "." + i + 18, Age = 19 }, //new STest2 { FirstName = "Person" , LastName = "Person" + i + "." + i+19, Age = 20, New = "This is a test" } }; collection.Add(colSTest); } var lt = new List <STest> { new STest { FirstName = "Name1", LastName = "LName1", Age = 11 }, //new STest2 { FirstName = "Name2" , LastName = "LName2", Age = 20, New = "This is a test" } }; var lt2 = new List <Test3> { new Test3 { Values = new List <int> { 2, 3, 4, 5 } }, new Test3 { Values = new List <int> { 10, 11, 12, 13 } } }; var dct = new Dictionary <string, int> { ["Value1"] = 1, ["Value2"] = 2, ["Value3"] = 3, }; var colClone = collection[0].DeepClone(); var clone = collection.DeepClone(); if (info.Arguments?.Contains("/parallel") == true) { RunSingleTest(collection[0], 2, false); Core.Log.InfoBasic("Press ENTER to Start:"); Console.ReadLine(); Task.WaitAll( Enumerable.Range(0, 8).Select(i => Task.Run(() => RunSingleTest(collection[0], 200_000, false))).ToArray() ); Console.ReadLine(); return; } RunTest(collection[0], 200_000, false); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting Redis Test"); #region Set Config var mqConfig = new MQPairConfig { Name = "QueueTest", Types = new MQObjectTypes { ClientType = typeof(RedisQueueClient), ServerType = typeof(RedisQueueServer) }, RawTypes = new MQObjectTypes { ClientType = typeof(RedisQueueRawClient), ServerType = typeof(RedisQueueRawServer) }, ClientQueues = new List <MQClientQueues> { new MQClientQueues { EnvironmentName = "", MachineName = "", SendQueues = new List <MQConnection> { new MQConnection("localhost", "TEST_RQ", null) }, RecvQueue = new MQConnection("localhost", "TEST_RS", null) } }, ServerQueues = new List <MQServerQueues> { new MQServerQueues { EnvironmentName = "", MachineName = "", RecvQueues = new List <MQConnection> { new MQConnection("localhost", "TEST_RQ", null) } } }, RequestOptions = new MQRequestOptions { SerializerMimeType = SerializerManager.DefaultBinarySerializer.MimeTypes[0], //CompressorEncodingType = "gzip", ClientSenderOptions = new MQClientSenderOptions { Label = "TEST REQUEST", MessageExpirationInSec = 30, MessagePriority = MQMessagePriority.Normal, Recoverable = false }, ServerReceiverOptions = new MQServerReceiverOptions { MaxSimultaneousMessagesPerQueue = 20000, ProcessingWaitOnFinalizeInSec = 10, SleepOnExceptionInSec = 1000 } }, ResponseOptions = new MQResponseOptions { SerializerMimeType = SerializerManager.DefaultBinarySerializer.MimeTypes[0], //CompressorEncodingType = "gzip", ClientReceiverOptions = new MQClientReceiverOptions(60, new KeyValue <string, string>("SingleResponseQueue", "true") ), ServerSenderOptions = new MQServerSenderOptions { Label = "TEST RESPONSE", MessageExpirationInSec = 30, MessagePriority = MQMessagePriority.Normal, Recoverable = false } } }; #endregion JsonTextSerializerExtensions.Serializer.Indent = true; mqConfig.SerializeToXmlFile("redisConfig.xml"); mqConfig.SerializeToJsonFile("redisConfig.json"); var manager = mqConfig.GetQueueManager(); manager.CreateClientQueues(); //Core.DebugMode = true; //Core.Log.MaxLogLevel = Diagnostics.Log.LogLevel.InfoDetail; Core.Log.Warning("Starting with Normal Listener and Client"); NormalTest(mqConfig); mqConfig.ResponseOptions.ClientReceiverOptions.Parameters["SingleResponseQueue"] = "true"; Core.Log.Warning("Starting with RAW Listener and Client"); RawTest(mqConfig); }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { var serializer = new NBinarySerializer(); var service = new SampleProvider(); Core.Log.InfoBasic("Setting RPC Server"); var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer)); rpcServer.AddService(typeof(ISampleProvider), service); await rpcServer.StartAsync().ConfigureAwait(false); Core.Log.InfoBasic("Setting RPC Client"); var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer)); var hClient = await rpcClient.CreateDynamicProxyAsync <ISampleProvider>().ConfigureAwait(false); var client = hClient.ActAs <ISampleProvider>(); double perItemMs; try { var intEnumerable = await client.GetInt().ConfigureAwait(false); } catch (Exception ex) { Core.Log.Write(ex); } using (var watch = Watch.Create("GetSampleAsync")) { Sample res; for (var i = 0; i < 100000; i++) { res = await client.GetSampleAsync().ConfigureAwait(false); } perItemMs = watch.GlobalElapsedMilliseconds / 100000; } Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms"); Console.ReadLine(); Core.Log.InfoBasic("DelayTestAsync"); await client.DelayTestAsync().ConfigureAwait(false); Core.Log.InfoBasic("GetSample"); var sample = client.GetSample(); Core.Log.InfoBasic("GetSample as Async"); var sampleSimAsync = ((dynamic)hClient).GetSample2Async().Result; Console.ReadLine(); var pClient = await rpcClient.CreateProxyAsync <SampleProxy>().ConfigureAwait(false); using (var watch = Watch.Create("GetSampleAsync")) { Sample res; for (var i = 0; i < 100000; i++) { res = await pClient.GetSampleAsync().ConfigureAwait(false); } perItemMs = watch.GlobalElapsedMilliseconds / 100000; } Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms"); Console.ReadLine(); Core.Log.InfoBasic("DelayTestAsync"); await pClient.DelayTestAsync().ConfigureAwait(false); Core.Log.InfoBasic("GetSample"); var sample2 = pClient.GetSample(); rpcClient.Dispose(); await rpcServer.StopAsync().ConfigureAwait(false); }
protected override void OnHandler(ParameterHandlerInfo info) { Core.Log.Warning("Starting MEMORY STREAMS TEST"); Core.Log.WriteEmptyLine(); Core.Log.InfoBasic("Press Enter to Start RecycleMemoryStream Test."); Console.ReadLine(); var xbuffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; using (Watch.Create("RecycleMemoryStream")) { for (var m = 0; m < 50000; m++) { using (var rms = new RecycleMemoryStream()) { for (var x = 0; x < 1; x++) { for (int i = 0; i < 10000; i++) { rms.Write(xbuffer, 0, xbuffer.Length); } } rms.Position = 0; for (var x = 0; x < 10; x++) { for (int i = 0; i < 2000; i++) { var bt = rms.ReadByte(); } } } } } Core.Log.WriteEmptyLine(); Core.Log.InfoBasic("Press Enter to Start MemoryStream Test."); Console.ReadLine(); using (Watch.Create("MemoryStream")) { for (var m = 0; m < 50000; m++) { using (var rms = new MemoryStream()) { for (var x = 0; x < 1; x++) { for (var i = 0; i < 10000; i++) { rms.Write(xbuffer, 0, xbuffer.Length); } } rms.Position = 0; for (var x = 0; x < 10; x++) { for (var i = 0; i < 2000; i++) { var bt = rms.ReadByte(); } } } } } Core.Log.WriteEmptyLine(); Core.Log.InfoBasic("Press Enter to Start CircularBufferStream Test. Press Enter Again to finish the test."); Console.ReadLine(); using (var cbs = new CircularBufferStream(50)) { var cts = new CancellationTokenSource(); Task.Run(async() => { var i = 0; while (!cts.Token.IsCancellationRequested) { i++; cbs.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 }); if (i % 50 == 0) { Core.Log.InfoMedium("Write {0}", i); } await Task.Delay(1, cts.Token).ConfigureAwait(false); } }); Task.Run(async() => { var i = 0; var buffer = new byte[15]; while (!cts.Token.IsCancellationRequested) { i++; cbs.Read(buffer, 0, 7); if (i % 50 == 0) { Core.Log.InfoMedium("Read {0}", i); } await Task.Delay(1, cts.Token).ConfigureAwait(false); } }); Console.ReadLine(); cts.Cancel(); } Core.Log.WriteEmptyLine(); Core.Log.InfoBasic("Press Enter to Start SharedMemoryStream Test. Press Enter Again to finish the test."); Console.ReadLine(); using (var sharedms = new SharedMemoryStream("test", 2000)) { var cts = new CancellationTokenSource(); Task.Run(async() => { var i = 0; while (!cts.Token.IsCancellationRequested) { i++; sharedms.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 }); if (i % 50 == 0) { Core.Log.InfoMedium("Write {0}", i); } await Task.Delay(1, cts.Token).ConfigureAwait(false); } }); Task.Run(async() => { var i = 0; var buffer = new byte[15]; while (!cts.Token.IsCancellationRequested) { i++; sharedms.Read(buffer, 0, 7); if (i % 50 == 0) { Core.Log.InfoMedium("Read {0}", i); } await Task.Delay(1, cts.Token).ConfigureAwait(false); } }); Console.ReadLine(); } }
protected override async Task OnHandlerAsync(ParameterHandlerInfo info) { Core.DebugMode = true; Core.Log.Warning("Starting CACHE TEST"); var cacheService = new TestCacheService(); cacheService.OnStart(null); using (var cachePool = new CacheClientPoolAsync("Pool Test") { Serializer = GlobalSerializer }) { var cacheClient = await CacheClientProxy.GetClientAsync(new DefaultTransportClient("127.0.0.1", 20051, 3, GlobalSerializer)).ConfigureAwait(false); cachePool.Add("localhost:20051", cacheClient, StorageItemMode.ReadAndWrite); await cachePool.SetAsync("expTest", "testData", TimeSpan.FromSeconds(20), new[] { "test" }).ConfigureAwait(false); Console.ReadLine(); var asto = await cachePool.GetAsync("test").ConfigureAwait(false); if (asto is null) { await cachePool.SetAsync("test", "value").ConfigureAwait(false); asto = await cachePool.GetAsync("test").ConfigureAwait(false); } var guid = Guid.NewGuid(); await cachePool.CopyAsync("test", guid.ToString("N")).ConfigureAwait(false); var asto2 = await cachePool.GetAsync(guid.ToString("N")).ConfigureAwait(false); var guid2 = Guid.NewGuid(); await cachePool.CopyAsync("test", guid2.ToString("N")).ConfigureAwait(false); var asto3 = await cachePool.GetAsync(guid2.ToString("N")).ConfigureAwait(false); var guid3 = Guid.NewGuid(); await cachePool.CopyAsync("test", guid3.ToString("N")).ConfigureAwait(false); var asto4 = await cachePool.GetAsync(guid3.ToString("N")).ConfigureAwait(false); Console.ReadLine(); var tagValue1 = await cachePool.GetByTagAsync(new [] { "test" }).ConfigureAwait(false); await Task.Delay(600).ConfigureAwait(false); var tagValue2 = await cachePool.GetByTagAsync(new [] { "test" }).ConfigureAwait(false); await Task.Delay(600).ConfigureAwait(false); await cachePool.SetAsync("expTest2", "testData2", TimeSpan.FromMinutes(1), new[] { "test" }).ConfigureAwait(false); await Task.Delay(600).ConfigureAwait(false); var tagValue3 = await cachePool.GetByTagAsync(new[] { "test" }).ConfigureAwait(false); await Task.Delay(600).ConfigureAwait(false); var tagValue4 = await cachePool.SetMultiAsync(new[] { "testa", "testb" }, "Hola mundo", TimeSpan.FromSeconds(10)).ConfigureAwait(false); await Task.Delay(600).ConfigureAwait(false); var response = await cachePool.ExecuteExtensionAsync("SampleExtension", "Echo", new object[] { "value1", "value2" }); Core.Log.Warning("Extension Response: {0}", response); Console.ReadLine(); try { for (var i = 0; i < 15; i++) { await cachePool.GetKeysAsync().ConfigureAwait(false); } Console.ReadLine(); for (var i = 0; i < 100; i++) { var key = "test-" + i; await cachePool.GetAsync(key).ConfigureAwait(false); await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false); } Console.ReadLine(); for (var i = 0; i < 100; i++) { var key = "test-" + i; await cachePool.GetAsync(key).ConfigureAwait(false); await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false); } } catch (Exception ex) { Core.Log.Write(ex); } } cacheService.OnStop(); }