protected CommunicationController(IPublisher publisher) { Ensure.NotNull(publisher, "publisher"); _publisher = publisher; Client = new HttpAsyncClient(); }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var expectedVersion = ExpectedVersion.Any; string metadata = "{'user' : 'test'}"; var requireMaster = false; var data = "{'a' : 3 }"; if (args.Length > 0) { if (args.Length != 5) return false; eventStreamId = args[0]; expectedVersion = args[1].ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]); data = args[2]; metadata = args[3]; requireMaster = bool.Parse(args[4]); } context.IsAsync(); var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId); context.Log.Info("Writing to {0}...", url); var msg = "[{'eventType': 'fooevent', 'eventId' : '" + Guid.NewGuid() + "'" + ",'data' : " + data + ", 'metadata' : " + metadata + "}]"; var sw = Stopwatch.StartNew(); client.Post( url, msg, Codec.Json.ContentType, new Dictionary<string, string> { {SystemHeaders.ExpectedVersion, expectedVersion.ToString()}, {SystemHeaders.RequireMaster, requireMaster ? "True" : "False"} }, TimeSpan.FromMilliseconds(10000), response => { sw.Stop(); if (response.HttpStatusCode == HttpStatusCode.Created) context.Log.Info("Successfully written"); else { context.Log.Info("Error while writing: [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); context.Log.Info("Response:\n{0}\n\n{1}\n", string.Join("\n", response.Headers.AllKeys.Select(x => string.Format("{0,-20}: {1}", x, response.Headers[x]))), response.Body); } context.Log.Info("Write request took: {0}.", sw.Elapsed); context.Success(); }, e => { context.Log.ErrorException(e, "Error during POST"); context.Fail(e, "Error during POST."); }); return true; }
public void SetUp() { _bus = new InMemoryBus(string.Format("bus_{0}", _serverEndPoint.Port)); _service = new HttpService(ServiceAccessibility.Private, _bus, 1, _serverEndPoint.ToHttpUrl()); _client = new HttpAsyncClient(); HttpBootstrap.Subscribe(_bus, _service); }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var expectedVersion = ExpectedVersion.Any; var data = "test-data"; string metadata = null; if (args.Length > 0) { if (args.Length < 3 || args.Length > 4) return false; eventStreamId = args[0]; expectedVersion = args[1].ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]); data = args[2]; if (args.Length == 4) metadata = args[3]; } context.IsAsync(); var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId); context.Log.Info("Writing to {0}...", url); var request = Codec.Xml.To(new ClientMessageDto.WriteEventText( Guid.Empty, expectedVersion, new[] { new ClientMessageDto.EventText(Guid.NewGuid(), "type", data, metadata) })); var sw = Stopwatch.StartNew(); client.Post( url, request, Codec.Xml.ContentType, response => { sw.Stop(); if (response.HttpStatusCode == HttpStatusCode.Created) context.Log.Info("Successfully written"); else context.Log.Info("Error while writing: [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); context.Log.Info("Write request took: {0}.", sw.Elapsed); context.Success(); }, e => { context.Log.ErrorException(e, "Error during POST"); context.Fail(e, "Error during POST."); }); return true; }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var eventNumber = 0; var resolveLinkTos = false; var requireMaster = false; if (args.Length > 0) { if (args.Length > 3) return false; eventStreamId = args[0]; if (args.Length >= 2) eventNumber = int.Parse(args[1]); if (args.Length >= 3) requireMaster = bool.Parse(args[2]); } context.IsAsync(); var client = new HttpAsyncClient(); var readUrl = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/{1}?format=json", eventStreamId, eventNumber == -1 ? "head" : eventNumber.ToString()); context.Log.Info("[{0}]: Reading...", context.Client.HttpEndpoint); var sw = Stopwatch.StartNew(); client.Get(readUrl, new Dictionary<string, string> { {SystemHeaders.ResolveLinkTos, resolveLinkTos ? "True" : "False"}, {SystemHeaders.RequireMaster, requireMaster ? "True" : "False"} }, TimeSpan.FromMilliseconds(10000), response => { sw.Stop(); context.Log.Info("[{0} ({1})]: READ events from <{2}>.", response.HttpStatusCode, response.StatusDescription, eventStreamId); context.Log.Info("Response:\n{0}\n\n{1}\n", string.Join("\n", response.Headers.AllKeys.Select(x => string.Format("{0,-20}: {1}", x, response.Headers[x]))), response.Body); context.Log.Info("Read request took: {0}.", sw.Elapsed); context.Success(); }, e => context.Fail(e, string.Format("READ events from <{0}>: FAILED", eventStreamId))); return true; }
public void SetUp() { _bus = new InMemoryBus(string.Format("bus_{0}", _serverEndPoint.Port)); { var pipelineBus = InMemoryBus.CreateTest(); var queue = new QueuedHandlerThreadPool(pipelineBus, "Test", true, TimeSpan.FromMilliseconds(50)); _multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[]{queue}, null); var httpAuthenticationProviders = new HttpAuthenticationProvider[] {new AnonymousHttpAuthenticationProvider()}; _service = new HttpService(ServiceAccessibility.Private, _bus, new NaiveUriRouter(), _multiQueuedHandler, false, _serverEndPoint.ToHttpUrl()); HttpService.CreateAndSubscribePipeline(pipelineBus, httpAuthenticationProviders); _client = new HttpAsyncClient(_timeout); } HttpBootstrap.Subscribe(_bus, _service); }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var version = 0; if (args.Length > 0) { if (args.Length > 2) return false; eventStreamId = args[0]; if (args.Length == 2) version = int.Parse(args[1]); } context.IsAsync(); var client = new HttpAsyncClient(); var readUrl = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/event/{1}", eventStreamId, version); context.Log.Info("[{0}]: Reading...", context.Client.HttpEndpoint); var sw = Stopwatch.StartNew(); client.Get(readUrl, response => { sw.Stop(); context.Log.Info("READ events from <{0}>: {1}", eventStreamId, response.Body); context.Log.Info("Read request took: {0}.", sw.Elapsed); context.Success(); }, e => context.Fail(e, string.Format("READ events from <{0}>: FAILED", eventStreamId))); return true; }
private void Flood(CommandProcessorContext context, int clientsCnt, int minPerSecond, int maxPerSecond, int runTimeMinutes) { context.IsAsync(); var threads = new List<Thread>(); var autoResetEvent = new AutoResetEvent(false); var succ = 0; var fail = 0; var requestsCnt = 0; int sent = 0; int received = 0; var watchLockRoot = new object(); var sw = Stopwatch.StartNew(); for (int i = 0; i < clientsCnt; i++) { threads.Add(new Thread(() => { var client = new HttpAsyncClient(); Action<HttpResponse> succHandler = response => { var succDone = Interlocked.Increment(ref succ); if (succDone % maxPerSecond == 0) Console.Write("."); Interlocked.Increment(ref requestsCnt); Interlocked.Increment(ref received); }; var sentCount = 0; var sleepTime = 0; var currentMinute = -1; while (true) { TimeSpan elapsed; lock (watchLockRoot) elapsed = sw.Elapsed; if (elapsed.TotalMinutes > runTimeMinutes) { autoResetEvent.Set(); break; } if (sentCount == 0) { int elapsedMinutesInt = (int)elapsed.TotalMinutes; lock (_randomLockRoot) { sentCount = minPerSecond == maxPerSecond ? maxPerSecond : _random.Next(minPerSecond, maxPerSecond); } if (currentMinute != elapsedMinutesInt) { currentMinute = elapsedMinutesInt; context.Log.Info(Environment.NewLine + "Elapsed {0} of {1} minutes, sent {2}", elapsedMinutesInt, runTimeMinutes, sent); } sleepTime = 1000 / sentCount; } var url = context.Client.HttpEndpoint.ToHttpUrl("/ping"); client.Get(url, succHandler, exc => context.Log.ErrorException(exc, "Error during GET.")); Interlocked.Increment(ref sent); Thread.Sleep(sleepTime); sentCount -= 1; while (sent - received > context.Client.Options.PingWindow/clientsCnt) { Thread.Sleep(1); } } })); } foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } autoResetEvent.WaitOne(); sw.Stop(); context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail); var reqPerSec = (requestsCnt + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", requestsCnt, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData( Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail)) ); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int) reqPerSec); PerfUtils.LogTeamCityGraphData( string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), (int) ((fail/(succ + 0.0))*100)); context.Success(); }
public void of_http_requests_routing() { const int iterations = 100000; IPublisher inputBus = new NoopPublisher(); var bus = InMemoryBus.CreateTest(); var queue = new QueuedHandlerThreadPool(bus, "Test", true, TimeSpan.FromMilliseconds(50)); var multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[]{queue}, null); var providers = new AuthenticationProvider[] {new AnonymousAuthenticationProvider()}; var httpService = new HttpService(ServiceAccessibility.Public, inputBus, new TrieUriRouter(), multiQueuedHandler, "http://localhost:12345/"); HttpService.CreateAndSubscribePipeline(bus, providers); var fakeController = new FakeController(iterations, null); httpService.SetupController(fakeController); httpService.Handle(new SystemMessage.SystemInit()); var rnd = new Random(); var sw = Stopwatch.StartNew(); var httpClient = new HttpAsyncClient(); for (int i = 0; i < iterations; ++i) { var route = fakeController.BoundRoutes[rnd.Next(0, fakeController.BoundRoutes.Count)]; switch (route.Item2) { case HttpMethod.Get: httpClient.Get(route.Item1,TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception();}); break; case HttpMethod.Post: httpClient.Post(route.Item1, "abracadabra", ContentType.Json, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); }); break; case HttpMethod.Delete: httpClient.Delete(route.Item1, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); }); break; case HttpMethod.Put: httpClient.Put(route.Item1, "abracadabra", ContentType.Json, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); }); break; default: throw new Exception(); } } fakeController.CountdownEvent.Wait(); sw.Stop(); Console.WriteLine("{0} request done in {1} ({2:0.00} per sec)", iterations, sw.Elapsed, 1000.0 * iterations / sw.ElapsedMilliseconds); httpService.Shutdown(); multiQueuedHandler.Stop(); }
private void Flood(CommandProcessorContext context, string eventStreamId, int clientsCnt, int minPerSecond, int maxPerSecond, int runTimeMinutes, int dataSize) { context.IsAsync(); var threads = new List<Thread>(); var doneEvent = new ManualResetEvent(false); var succ = 0; var fail = 0; var requestsCnt = 0; int sent = 0; int received = 0; var watchLockRoot = new object(); var sw = Stopwatch.StartNew(); for (int i = 0; i < clientsCnt; i++) { threads.Add(new Thread(() => { var esId = eventStreamId ?? "Stream-" + Thread.CurrentThread.ManagedThreadId % 3; var client = new HttpAsyncClient(); Action<HttpResponse> succHandler = response => { if (response.HttpStatusCode == HttpStatusCode.Created) { var succDone = Interlocked.Increment(ref succ); if (succDone % maxPerSecond == 0) Console.Write("."); } else { if (Interlocked.Increment(ref fail) % 10 == 0) { context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); } } Interlocked.Increment(ref requestsCnt); Interlocked.Increment(ref received); }; var sentCount = 0; var sleepTime = 0; var dataSizeCoefficient = 1; var currentMinute = -1; while (true) { TimeSpan elapsed; lock (watchLockRoot) elapsed = sw.Elapsed; if (elapsed.TotalMinutes > runTimeMinutes) { doneEvent.Set(); break; } if (sentCount == 0) { int elapsedMinutesInt = (int)elapsed.TotalMinutes; lock (_randomLockRoot) { sentCount = minPerSecond == maxPerSecond ? maxPerSecond : _random.Next(minPerSecond, maxPerSecond); dataSizeCoefficient = _random.Next(8, 256); } if (currentMinute != elapsedMinutesInt) { currentMinute = elapsedMinutesInt; context.Log.Info("\nElapsed {0} of {1} minutes, sent {2}; next block coef. {3}", elapsedMinutesInt, runTimeMinutes, sent, dataSizeCoefficient); } sleepTime = 1000 / sentCount; } var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId); var dataResultingSize = dataSizeCoefficient * dataSize; var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(), "type", "DATA" + dataResultingSize.ToString(" 00000 ") + new string('*', dataResultingSize), "METADATA" + new string('$', 100))}; var request = Codec.Xml.To(write); client.Post(url, request, Codec.Xml.ContentType, TimeSpan.FromMilliseconds(10000), succHandler, exc => { Interlocked.Increment(ref fail); Interlocked.Increment(ref requestsCnt); context.Log.ErrorException(exc, "Error during POST."); }); Interlocked.Increment(ref sent); Thread.Sleep(sleepTime); sentCount -= 1; while (sent - received > context.Client.Options.WriteWindow/clientsCnt) { Thread.Sleep(1); } } })); } foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } doneEvent.WaitOne(); sw.Stop(); context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail); var reqPerSec = (requestsCnt + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", requestsCnt, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData( Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail)) ); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-{3}-{4}-reqPerSec", Keyword, clientsCnt, minPerSecond, maxPerSecond, runTimeMinutes), (int)reqPerSec); PerfUtils.LogTeamCityGraphData( string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), 100 * fail / (fail + succ)); context.Success(); }
private void ReadFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, int requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var autoResetEvent = new AutoResetEvent(false); var readsCnt = 0; for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); int sent = 0; int received = 0; threads.Add(new Thread(() => { var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/event/{1}", eventStreamId, 0); Action<HttpResponse> onSuccess = response => { var readsLocal = Interlocked.Increment(ref readsCnt); Interlocked.Increment(ref received); if (readsLocal % 1000 == 0) Console.Write("."); if (readsLocal == requestsCnt) autoResetEvent.Set(); }; for (int j = 0; j < count; ++j) { client.Get(url, onSuccess, e => { context.Log.ErrorException(e, "Error during GET"); var readsLocal = Interlocked.Increment(ref readsCnt); if (readsLocal == requestsCnt) autoResetEvent.Set(); }); Interlocked.Increment(ref sent); while (sent - received > context.Client.Options.ReadWindow) Thread.Sleep(1); } })); } var sw = Stopwatch.StartNew(); foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } autoResetEvent.WaitOne(); sw.Stop(); context.Log.Info("Completed. READS done: {0}.", readsCnt); var reqPerSec = (requestsCnt + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", requestsCnt, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData( Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("readsCnt", readsCnt))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int) reqPerSec); context.Success(); }
private void WriteFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, long requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var doneEvent = new ManualResetEventSlim(false); long all = 0; long succ = 0; long fail = 0; var sw = new Stopwatch(); var sw2 = new Stopwatch(); for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); long sent = 0; long received = 0; threads.Add(new Thread(() => { var esId = eventStreamId ?? ("es" + Guid.NewGuid()); var client = new HttpAsyncClient(); Action onReceived = () => { Interlocked.Increment(ref received); var localAll = Interlocked.Increment(ref all); if (localAll % 10000 == 0) { var elapsed = sw2.Elapsed; sw2.Restart(); context.Log.Trace("\nDONE TOTAL {0} WRITES IN {1} ({2:0.0}/s).", localAll, elapsed, 1000.0 * 10000 / elapsed.TotalMilliseconds); } if (localAll == requestsCnt) doneEvent.Set(); }; Action<HttpResponse> onSuccess = response => { if (response.HttpStatusCode == HttpStatusCode.Created) { if (Interlocked.Increment(ref succ) % 100 == 0) Console.Write('.'); } else { var localFail = Interlocked.Increment(ref fail); if (localFail % 100 == 0) Console.Write('#'); if (localFail % 10 == 0) context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); } onReceived(); }; Action<Exception> onException = exc => { context.Log.ErrorException(exc, "Error during POST."); if (Interlocked.Increment(ref fail) % 100 == 0) Console.Write('#'); onReceived(); }; for (int j = 0; j < count; ++j) { var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId); var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(), "type", "DATA" + new string('*', 256), "METADATA" + new string('$', 100)) }; var requestString = Codec.Json.To(write); client.Post( url, requestString, Codec.Json.ContentType, new Dictionary<string, string> { }, TimeSpan.FromMilliseconds(10000), onSuccess, onException); var localSent = Interlocked.Increment(ref sent); while (localSent - Interlocked.Read(ref received) > context.Client.Options.WriteWindow/clientsCnt) { Thread.Sleep(1); } } }) { IsBackground = true }); } sw.Start(); sw2.Start(); threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); var reqPerSec = (all + 0.0) / sw.ElapsedMilliseconds * 1000; context.Log.Info("Completed. Successes: {0}, failures: {1}", Interlocked.Read(ref succ), Interlocked.Read(ref fail)); context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData(Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), (int)(100.0*fail/(fail + succ))); if (Interlocked.Read(ref succ) != requestsCnt) context.Fail(reason: "There were errors or not all requests completed."); else context.Success(); }
private void WriteFlood(CommandProcessorContext context, int clientsCnt, int requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var doneEvent = new ManualResetEventSlim(false); var succ = 0; var fail = 0; var all = 0; var sw = Stopwatch.StartNew(); for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); threads.Add(new Thread(() => { var autoEvent = new AutoResetEvent(false); var eventStreamId = "es" + Guid.NewGuid(); var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId); Action<HttpResponse> succHandler = response => { if (response.HttpStatusCode == HttpStatusCode.Created) { if (Interlocked.Increment(ref succ)%1000 == 0) Console.Write("."); } else { if (Interlocked.Increment(ref fail)%10 == 0) context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); } if (Interlocked.Increment(ref all) == requestsCnt) doneEvent.Set(); autoEvent.Set(); }; for (int j = 0; j < count; ++j) { var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(), "type", "DATA" + new string('*', 256), "METADATA" + new string('$', 100))}; var request = Codec.Xml.To(write); client.Post(url, request, Codec.Xml.ContentType, TimeSpan.FromMilliseconds(10000), succHandler, exc => { context.Log.ErrorException(exc, "Error during POST."); Interlocked.Increment(ref fail); if (Interlocked.Increment(ref all) == requestsCnt) doneEvent.Set(); autoEvent.Set(); }); autoEvent.WaitOne(); } }) { IsBackground = true }); } threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); var reqPerSec = (all + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail); context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData(Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int) reqPerSec); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), (int)(100.0*fail/(fail + succ))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)(sw.ElapsedMilliseconds / requestsCnt)); if (succ != requestsCnt) context.Fail(reason: "There were errors or not all requests completed."); else context.Success(); }
private void ReadFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, long requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var doneEvent = new ManualResetEventSlim(false); long succ = 0; long fail = 0; long all = 0; var sw2 = new Stopwatch(); for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); long sent = 0; long received = 0; threads.Add(new Thread(() => { var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/{1}?format=json", eventStreamId, 0); Action onReceived = () => { Interlocked.Increment(ref received); var localAll = Interlocked.Increment(ref all); if (localAll % 10000 == 0) { var elapsed = sw2.Elapsed; sw2.Restart(); context.Log.Trace("\nDONE TOTAL {0} READS IN {1} ({2:0.0}/s).", localAll, elapsed, 1000.0 * 10000 / elapsed.TotalMilliseconds); } if (localAll == requestsCnt) doneEvent.Set(); }; Action<HttpResponse> onSuccess = response => { if (Interlocked.Increment(ref succ) % 100 == 0) Console.Write("."); onReceived(); }; Action<Exception> onException = exc => { context.Log.ErrorException(exc, "Error during GET"); if (Interlocked.Increment(ref fail) % 100 == 0) Console.Write("#"); onReceived(); }; for (int j = 0; j < count; ++j) { client.Get(url, TimeSpan.FromMilliseconds(10000), onSuccess, onException); var localSent = Interlocked.Increment(ref sent); while (localSent - Interlocked.Read(ref received) > context.Client.Options.ReadWindow/clientsCnt) { Thread.Sleep(1); } } }) { IsBackground = true }); } var sw = Stopwatch.StartNew(); sw2.Start(); threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); var reqPerSec = (all + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("Completed. READS succ: {0}, fail: {1}.", Interlocked.Read(ref succ), Interlocked.Read(ref fail)); context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData(Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("readsCnt", all))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int) reqPerSec); if (Interlocked.Read(ref succ) == requestsCnt) context.Success(); else context.Fail(); }
private void PingFlood(CommandProcessorContext context, int clientsCnt, long requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var doneEvent = new ManualResetEventSlim(false); long all = 0; long succ = 0; long fail = 0; for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); long received = 0; long sent = 0; threads.Add(new Thread(() => { var client = new HttpAsyncClient(); var url = context.Client.HttpEndpoint.ToHttpUrl("/ping"); Action<HttpResponse> onSuccess = response => { Interlocked.Increment(ref received); if (Interlocked.Increment(ref succ) % 1000 == 0) Console.Write('.'); if (Interlocked.Increment(ref all) == requestsCnt) doneEvent.Set(); }; Action<Exception> onException = e => { context.Log.ErrorException(e, "Error during GET"); Interlocked.Increment(ref received); if (Interlocked.Increment(ref fail) % 1000 == 0) Console.Write('#'); if (Interlocked.Increment(ref all) == requestsCnt) doneEvent.Set(); }; for (int j = 0; j < count; ++j) { client.Get(url, TimeSpan.FromMilliseconds(10000), onSuccess, onException); var localSent = Interlocked.Increment(ref sent); while (localSent - Interlocked.Read(ref received) > context.Client.Options.PingWindow/clientsCnt) { Thread.Sleep(1); } } }) { IsBackground = true }); } var sw = Stopwatch.StartNew(); threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); var reqPerSec = (all + 0.0) / sw.ElapsedMilliseconds * 1000; context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData(Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds))); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec); if (Interlocked.Read(ref succ) == requestsCnt) context.Success(); else context.Fail(); }
private void WriteFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, int requestsCnt) { context.IsAsync(); var threads = new List<Thread>(); var autoResetEvent = new AutoResetEvent(false); var succ = 0; var fail = 0; var all = 0; var sw = Stopwatch.StartNew(); for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); int sent = 0; int received = 0; threads.Add(new Thread(() => { var esId = eventStreamId ?? "es" + Guid.NewGuid(); var client = new HttpAsyncClient(); Action<HttpResponse> succHandler = response => { if (response.HttpStatusCode == HttpStatusCode.Created) { if (Interlocked.Increment(ref succ) % 100 == 0) Console.Write("."); } else { if (Interlocked.Increment(ref fail) % 10 == 0) { context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription); } } Interlocked.Increment(ref received); if (Interlocked.Increment(ref all) == requestsCnt) autoResetEvent.Set(); }; for (int j = 0; j < count; ++j) { var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId); var write = new ClientMessageDto.WriteEventText( Guid.Empty, ExpectedVersion.Any, new[] { new ClientMessageDto.EventText(Guid.NewGuid(), "type", "DATA" + new string('*', 256), "METADATA" + new string('$', 100)) }); var requestString = Codec.Xml.To(write); client.Post(url, requestString, Codec.Xml.ContentType, succHandler, exc => { context.Log.ErrorException(exc, "Error during POST."); Interlocked.Increment(ref fail); if (Interlocked.Increment(ref all) == requestsCnt) autoResetEvent.Set(); }); Interlocked.Increment(ref sent); while (sent - received > context.Client.Options.WriteWindow) Thread.Sleep(1); } })); } foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } autoResetEvent.WaitOne(); sw.Stop(); context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail); var reqPerSec = (requestsCnt + 0.0)/sw.ElapsedMilliseconds*1000; context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", requestsCnt, sw.ElapsedMilliseconds, reqPerSec); PerfUtils.LogData( Keyword, PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt), PerfUtils.Col("requestsCnt", requestsCnt), PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)), PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail)) ); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec); PerfUtils.LogTeamCityGraphData( string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), 100*fail/(fail + succ)); context.Success(); }