public void when_handling_trusted_write_on_internal_service() { ManualResetEvent waiter = new ManualResetEvent(false); ClientMessage.WriteEvents publishedWrite = null; var evnt = new Event(Guid.NewGuid(), "TestEventType", true, new byte[] { }, new byte[] { }); var write = new TcpClientMessageDto.WriteEvents( Guid.NewGuid().ToString(), ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent(evnt.EventId.ToByteArray(), evnt.EventType, evnt.IsJson ? 1 : 0, 0, evnt.Data, evnt.Metadata) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); var dummyConnection = new DummyTcpConnection(); var publisher = InMemoryBus.CreateTest(); publisher.Subscribe(new AdHocHandler<ClientMessage.WriteEvents>(x => { publishedWrite = x; waiter.Set(); })); var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.Internal, new ClientTcpDispatcher(), publisher, dummyConnection, publisher, new InternalAuthenticationProvider(new Core.Helpers.IODispatcher(publisher, new NoopEnvelope()), new StubPasswordHashAlgorithm(), 1), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }); tcpConnectionManager.ProcessPackage(package); if (!waiter.WaitOne(TimeSpan.FromSeconds(5))) { throw new Exception("Timed out waiting for events."); } Assert.AreEqual(evnt.EventId, publishedWrite.Events.First().EventId, "Expected the published write to be the event that was sent through the tcp connection manager to be the event {0} but got {1}", evnt.EventId, publishedWrite.Events.First().EventId); }
private static TcpPackage WrapWriteEvents(ClientMessage.WriteEvents msg) { var dto = new TcpClientMessageDto.WriteEvents( msg.EventStreamId, msg.ExpectedVersion, msg.Events.Select(x => new TcpClientMessageDto.ClientEvent(x.EventId.ToByteArray(), x.EventType, x.IsJson, x.Data, x.Metadata)).ToArray(), msg.AllowForwarding); return new TcpPackage(TcpCommand.WriteEvents, msg.CorrelationId, dto.Serialize()); }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var expectedVersion = ExpectedVersion.Any; var data = GenerateTestData(); 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 writeDto = new TcpClientMessageDto.WriteEvents( eventStreamId, expectedVersion, new[] { new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "JsonDataEvent", 1,0, Helper.UTF8NoBom.GetBytes(data), Helper.UTF8NoBom.GetBytes(metadata ?? string.Empty)) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), writeDto.Serialize()); var sw = new Stopwatch(); bool dataReceived = false; context.Client.CreateTcpConnection( context, connectionEstablished: conn => { context.Log.Info("[{0}, L{1}]: Writing...", conn.RemoteEndPoint, conn.LocalEndPoint); sw.Start(); conn.EnqueueSend(package.AsByteArray()); }, handlePackage: (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } dataReceived = true; sw.Stop(); var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { context.Log.Info("Successfully written. EventId: {0}.", package.CorrelationId); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds); } else { context.Log.Info("Error while writing: {0} ({1}).", dto.Message, dto.Result); } context.Log.Info("Write request took: {0}.", sw.Elapsed); conn.Close(); context.Success(); }, connectionClosed: (connection, error) => { if (dataReceived && error == SocketError.Success) context.Success(); else context.Fail(); }); context.WaitForCompletion(); return true; }
private void Flood(CommandProcessorContext context, string eventStreamId, int clientsCnt, int minPerSecond, int maxPerSecond, int runTimeMinutes) { context.IsAsync(); var clients = new List<TcpTypedConnection<byte[]>>(); var threads = new List<Thread>(); var doneEvent = new ManualResetEvent(false); var done = 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++) { var esId = eventStreamId ?? "Stream-" + Thread.CurrentThread.ManagedThreadId % 3; var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { var succDone = Interlocked.Increment(ref succ); if (succDone%maxPerSecond == 0) Console.Write("."); Interlocked.Increment(ref requestsCnt); } else Interlocked.Increment(ref fail); Interlocked.Increment(ref received); }, connectionClosed: (conn, err) => { if (!done) context.Fail(reason: "Socket was closed, but not all requests were completed."); else context.Success(); }); clients.Add(client); threads.Add(new Thread(() => { 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) { done = true; 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 dataSize = dataSizeCoefficient * 8; var write = new TcpClientMessageDto.WriteEvents( esId, ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent( Guid.NewGuid().ToByteArray(), "TakeSomeSpaceEvent", 0,0, Helper.UTF8NoBom.GetBytes("DATA" + dataSize.ToString(" 00000 ") + new string('*', dataSize)), Helper.UTF8NoBom.GetBytes("METADATA" + new string('$', 100))) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); client.EnqueueSend(package.AsByteArray()); 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(); foreach (var client in clients) { client.Close(); } 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(); }
private void WriteFlood(CommandProcessorContext context, int writeCnt, int clientsCnt, long requestsCnt) { const string data = "test-data"; context.IsAsync(); var clients = new List<TcpTypedConnection<byte[]>>(); var threads = new List<Thread>(); var doneEvent = new ManualResetEventSlim(false); long succ = 0; long fail = 0; long all = 0; for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); var localDoneEvent = new AutoResetEvent(false); var eventStreamId = "es" + Guid.NewGuid(); var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { if (Interlocked.Increment(ref succ)%1000 == 0) Console.Write("."); } else { if (Interlocked.Increment(ref fail)%1000 == 0) Console.Write("#"); } if (Interlocked.Increment(ref all) == requestsCnt) { context.Success(); doneEvent.Set(); } localDoneEvent.Set(); }, connectionClosed: (conn, err) => context.Fail(reason: "Connection was closed prematurely.")); clients.Add(client); threads.Add(new Thread(() => { for (int j = 0; j < count; ++j) { var writeDto = new TcpClientMessageDto.WriteEvents( eventStreamId, ExpectedVersion.Any, Enumerable.Range(0, writeCnt).Select(x => new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "type", 0,0, Common.Utils.Helper.UTF8NoBom.GetBytes(data), new byte[0])).ToArray(), false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), writeDto.Serialize()); client.EnqueueSend(package.AsByteArray()); localDoneEvent.WaitOne(); } }) { IsBackground = true }); } var sw = Stopwatch.StartNew(); threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); clients.ForEach(client => client.Close()); 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)Math.Round(sw.Elapsed.TotalMilliseconds / requestsCnt)); if (succ != requestsCnt) context.Fail(reason: "There were errors or not all requests completed."); else context.Success(); }
public bool Execute(CommandProcessorContext context, string[] args) { const string data = "test-data"; var eventStreamId = "test-stream"; var writeCount = 10; var expectedVersion = ExpectedVersion.Any; if (args.Length > 0) { if (args.Length > 3) return false; writeCount = int.Parse(args[0]); if (args.Length >= 2) eventStreamId = args[1]; if (args.Length >= 3) expectedVersion = args[2].Trim().ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[2].Trim()); } context.IsAsync(); var sw = new Stopwatch(); context.Client.CreateTcpConnection( context, connectionEstablished: conn => { context.Log.Info("[{0}, L{1}]: Writing...", conn.RemoteEndPoint, conn.LocalEndPoint); var writeDto = new TcpClientMessageDto.WriteEvents( eventStreamId, expectedVersion, Enumerable.Range(0, writeCount).Select(x => new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "type", 0,0, Helper.UTF8NoBom.GetBytes(data), new byte[0])).ToArray(), false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), writeDto.Serialize()).AsByteArray(); sw.Start(); conn.EnqueueSend(package); }, handlePackage: (conn, pkg) => { sw.Stop(); context.Log.Info("Write request took: {0}.", sw.Elapsed); if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { context.Log.Info("Successfully written {0} events.", writeCount); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)Math.Round(sw.Elapsed.TotalMilliseconds)); context.Success(); } else { context.Log.Info("Error while writing: {0}.", dto.Result); context.Fail(); } conn.Close(); }, connectionClosed: (connection, error) => context.Fail(reason: "Connection was closed prematurely.")); context.WaitForCompletion(); return true; }
private void WriteFlood(CommandProcessorContext context, int clientsCnt, int requestsCnt) { context.IsAsync(); var clients = new List<TcpTypedConnection<byte[]>>(); var threads = new List<Thread>(); var autoResetEvent = new AutoResetEvent(false); var succ = 0; var fail = 0; var all = 0; for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); var autoEvent = new AutoResetEvent(false); var eventStreamId = "es" + Guid.NewGuid(); var received = 0; var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } Interlocked.Increment(ref received); var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { if (Interlocked.Increment(ref succ)%1000 == 0) Console.Write("."); } else Interlocked.Increment(ref fail); if (Interlocked.Increment(ref all) == requestsCnt) autoResetEvent.Set(); autoEvent.Set(); }, connectionClosed: (conn, err) => { if (received < count) context.Fail(null, "Socket was closed, but not all requests were completed."); else context.Success(); }); clients.Add(client); threads.Add(new Thread(() => { for (int j = 0; j < count; ++j) { var write = new TcpClientMessageDto.WriteEvents( eventStreamId, ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "TakeSomeSpaceEvent", false, Encoding.UTF8.GetBytes("DATA" + new string('*', 256)), Encoding.UTF8.GetBytes("METADATA" + new string('$', 100))) }, true); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); client.EnqueueSend(package.AsByteArray()); autoEvent.WaitOne(); } })); } var sw = Stopwatch.StartNew(); foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } autoResetEvent.WaitOne(); sw.Stop(); foreach (var client in clients) { client.Close(); } 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).", 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), 100 * fail / (fail + succ)); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int) (sw.ElapsedMilliseconds/requestsCnt)); context.Success(); }
private static TcpPackage WrapWriteEvents(ClientMessage.WriteEvents msg) { var events = new TcpClientMessageDto.NewEvent[msg.Events.Length]; for (int i = 0; i < events.Length; ++i) { var e = msg.Events[i]; events[i] = new TcpClientMessageDto.NewEvent(e.EventId.ToByteArray(), e.EventType, e.IsJson ? 1 : 0, 0, e.Data, e.Metadata); } var dto = new TcpClientMessageDto.WriteEvents(msg.EventStreamId, msg.ExpectedVersion, events, msg.RequireMaster); return CreateWriteRequestPackage(TcpCommand.WriteEvents, msg, dto); }
private void WriteFlood(CommandProcessorContext context, int clientsCnt, long requestsCnt, int streamsCnt) { context.IsAsync(); var doneEvent = new AutoResetEvent(false); var clients = new List<TcpTypedConnection<byte[]>>(); var threads = new List<Thread>(); long succ = 0; long fail = 0; long prepTimeout = 0; long commitTimeout = 0; long forwardTimeout = 0; long wrongExpVersion = 0; long streamDeleted = 0; long all = 0; var streams = Enumerable.Range(0, streamsCnt).Select(x => Guid.NewGuid().ToString()).ToArray(); var sw2 = new Stopwatch(); for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); int sent = 0; int received = 0; var rnd = new Random(); var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); switch((OperationErrorCode)dto.ErrorCode) { case OperationErrorCode.Success: Interlocked.Increment(ref succ); break; case OperationErrorCode.PrepareTimeout: Interlocked.Increment(ref prepTimeout); break; case OperationErrorCode.CommitTimeout: Interlocked.Increment(ref commitTimeout); break; case OperationErrorCode.ForwardTimeout: Interlocked.Increment(ref forwardTimeout); break; case OperationErrorCode.WrongExpectedVersion: Interlocked.Increment(ref wrongExpVersion); break; case OperationErrorCode.StreamDeleted: Interlocked.Increment(ref streamDeleted); break; default: throw new ArgumentOutOfRangeException(); } if (dto.ErrorCode != (int)OperationErrorCode.Success) Interlocked.Increment(ref fail); Interlocked.Increment(ref received); var localAll = Interlocked.Increment(ref all); if (localAll % 1000 == 0) Console.Write("."); if (localAll % 100000 == 0) { var elapsed = sw2.Elapsed; sw2.Restart(); context.Log.Trace("\nDONE TOTAL {0} WRITES IN {1} ({2:0.0}/s).", localAll, elapsed, 1000.0*100000/elapsed.TotalMilliseconds); } if (localAll == requestsCnt) doneEvent.Set(); }, connectionClosed: (conn, err) => { if (all < requestsCnt) context.Fail(null, "Socket was closed, but not all requests were completed."); else context.Success(); }); clients.Add(client); threads.Add(new Thread(() => { for (int j = 0; j < count; ++j) { var write = new TcpClientMessageDto.WriteEvents( streams[rnd.Next(streamsCnt)], ExpectedVersion.Any, new[] { new TcpClientMessageDto.ClientEvent(Guid.NewGuid().ToByteArray(), "TakeSomeSpaceEvent", false, Encoding.UTF8.GetBytes("DATA" + new string('*', 256)), Encoding.UTF8.GetBytes("METADATA" + new string('$', 100))) }, true); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); client.EnqueueSend(package.AsByteArray()); Interlocked.Increment(ref sent); while (sent - received > context.Client.Options.WriteWindow) Thread.Sleep(1); } })); } var sw = Stopwatch.StartNew(); sw2.Start(); foreach (var thread in threads) { thread.IsBackground = true; thread.Start(); } doneEvent.WaitOne(); sw.Stop(); foreach (var client in clients) { client.Close(); } context.Log.Info("Completed. Successes: {0}, failures: {1} (WRONG VERSION: {2}, P: {3}, C: {4}, F: {5}, D: {6})", succ, fail, wrongExpVersion, prepTimeout, commitTimeout, forwardTimeout, streamDeleted); 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.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)); if (succ < fail) context.Fail(reason: "Number of failures is greater than number of successes"); else context.Success(); }
private void Write(Status status, int writerIdx, CommandProcessorContext context, int requests, ManualResetEventSlim finish) { TcpTypedConnection<byte[]> connection; var iteration = new AutoResetEvent(false); var sent = 0; var prepareTimeouts = 0; var commitTimeouts = 0; var forwardTimeouts = 0; var wrongExpectedVersion = 0; var streamsDeleted = 0; var failed = 0; var rnd = new Random(); var streamIdx = -1; var head = -1; Action<TcpTypedConnection<byte[]>, TcpPackage> packageHandler = (conn, pkg) => { var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); switch (dto.Result) { case TcpClientMessageDto.OperationResult.Success: lock (_heads) { var currentHead = _heads[streamIdx]; Ensure.Equal(currentHead, head, "currentHead"); _heads[streamIdx]++; } break; case TcpClientMessageDto.OperationResult.PrepareTimeout: prepareTimeouts++; failed++; break; case TcpClientMessageDto.OperationResult.CommitTimeout: commitTimeouts++; failed++; break; case TcpClientMessageDto.OperationResult.ForwardTimeout: forwardTimeouts++; failed++; break; case TcpClientMessageDto.OperationResult.WrongExpectedVersion: wrongExpectedVersion++; failed++; break; case TcpClientMessageDto.OperationResult.StreamDeleted: streamsDeleted++; failed++; break; default: throw new ArgumentOutOfRangeException(); } sent++; if (sent % 1000 == 0) status.ReportWritesProgress(writerIdx, sent, prepareTimeouts, commitTimeouts, forwardTimeouts, wrongExpectedVersion, streamsDeleted, failed, requests); if (sent == requests) finish.Set(); iteration.Set(); }; Action<TcpTypedConnection<byte[]>> established = _ => { }; Action<TcpTypedConnection<byte[]>, SocketError> closed = null; closed = (_, __) => { Thread.Sleep(TimeSpan.FromSeconds(1)); connection = context.Client.CreateTcpConnection(context, packageHandler, cn => iteration.Set(), closed, false); }; connection = context.Client.CreateTcpConnection(context, packageHandler, established, closed, false); for (var i = 0; i < requests; ++i) { streamIdx = NextStreamForWriting(rnd, writerIdx); lock (_heads) { head = _heads[streamIdx]; } var evnt = CreateEvent(_streams[streamIdx], head + 1); var write = new TcpClientMessageDto.WriteEvents( _streams[streamIdx], head, new[] { new TcpClientMessageDto.NewEvent(evnt.EventId.ToByteArray(), evnt.EventType,evnt.IsJson ? 1 : 0, 0, evnt.Data, evnt.Metadata) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); connection.EnqueueSend(package.AsByteArray()); iteration.WaitOne(); } status.ReportWritesProgress(writerIdx, sent, prepareTimeouts, commitTimeouts, forwardTimeouts, wrongExpectedVersion, streamsDeleted, failed, requests); status.FinilizeStatus(writerIdx, failed != sent); connection.Close(); }
private void WriteFlood(CommandProcessorContext context, int clientsCnt, long requestsCnt, int streamsCnt, int size) { context.IsAsync(); var doneEvent = new ManualResetEventSlim(false); var clients = new List<TcpTypedConnection<byte[]>>(); var threads = new List<Thread>(); long succ = 0; long fail = 0; long prepTimeout = 0; long commitTimeout = 0; long forwardTimeout = 0; long wrongExpVersion = 0; long streamDeleted = 0; long all = 0; var streams = Enumerable.Range(0, streamsCnt).Select(x => Guid.NewGuid().ToString()).ToArray(); //var streams = Enumerable.Range(0, streamsCnt).Select(x => string.Format("stream-{0}", x)).ToArray(); 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; var rnd = new Random(); var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); _monitor.EndOperation(pkg.CorrelationId); switch(dto.Result) { case TcpClientMessageDto.OperationResult.Success: if (Interlocked.Increment(ref succ) % 1000 == 0) Console.Write('.'); break; case TcpClientMessageDto.OperationResult.PrepareTimeout: Interlocked.Increment(ref prepTimeout); break; case TcpClientMessageDto.OperationResult.CommitTimeout: Interlocked.Increment(ref commitTimeout); break; case TcpClientMessageDto.OperationResult.ForwardTimeout: Interlocked.Increment(ref forwardTimeout); break; case TcpClientMessageDto.OperationResult.WrongExpectedVersion: Interlocked.Increment(ref wrongExpVersion); break; case TcpClientMessageDto.OperationResult.StreamDeleted: Interlocked.Increment(ref streamDeleted); break; default: throw new ArgumentOutOfRangeException(); } if (dto.Result != TcpClientMessageDto.OperationResult.Success) if (Interlocked.Increment(ref fail)%1000 == 0) Console.Write('#'); Interlocked.Increment(ref received); var localAll = Interlocked.Increment(ref all); if (localAll % 100000 == 0) { var elapsed = sw2.Elapsed; sw2.Restart(); context.Log.Trace("\nDONE TOTAL {0} WRITES IN {1} ({2:0.0}/s) [S:{3}, F:{4} (WEV:{5}, P:{6}, C:{7}, F:{8}, D:{9})].", localAll, elapsed, 1000.0*100000/elapsed.TotalMilliseconds, succ, fail, wrongExpVersion, prepTimeout, commitTimeout, forwardTimeout, streamDeleted); } if (localAll == requestsCnt) { context.Success(); doneEvent.Set(); } }, connectionClosed: (conn, err) => context.Fail(reason: "Connection was closed prematurely.")); clients.Add(client); threads.Add(new Thread(() => { for (int j = 0; j < count; ++j) { var corrid = Guid.NewGuid(); var write = new TcpClientMessageDto.WriteEvents( streams[rnd.Next(streamsCnt)], ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "TakeSomeSpaceEvent", 1,0, Common.Utils.Helper.UTF8NoBom.GetBytes("{ \"DATA\" : \"" + new string('*', size) + "\"}"), Common.Utils.Helper.UTF8NoBom.GetBytes("{ \"METADATA\" : \"" + new string('$', 100) + "\"}")) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, corrid, write.Serialize()); _monitor.StartOperation(corrid); client.EnqueueSend(package.AsByteArray()); var localSent = Interlocked.Increment(ref sent); while (localSent - Interlocked.Read(ref received) > context.Client.Options.WriteWindow/clientsCnt) { Thread.Sleep(1); } } }) { IsBackground = true }); } var sw = Stopwatch.StartNew(); sw2.Start(); threads.ForEach(thread => thread.Start()); doneEvent.Wait(); sw.Stop(); clients.ForEach(client => client.Close()); context.Log.Info("Completed. Successes: {0}, failures: {1} (WRONG VERSION: {2}, P: {3}, C: {4}, F: {5}, D: {6})", succ, fail, wrongExpVersion, prepTimeout, commitTimeout, forwardTimeout, streamDeleted); 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.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))); var failuresRate = (int) (100 * fail / (fail + succ)); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), failuresRate); PerfUtils.LogTeamCityGraphData(string.Format("{0}-c{1}-r{2}-st{3}-s{4}-reqPerSec", Keyword, clientsCnt, requestsCnt, streamsCnt, size), (int)reqPerSec); PerfUtils.LogTeamCityGraphData(string.Format("{0}-c{1}-r{2}-st{3}-s{4}-failureSuccessRate", Keyword, clientsCnt, requestsCnt, streamsCnt, size), failuresRate); _monitor.GetMeasurementDetails(); if (Interlocked.Read(ref succ) != requestsCnt) context.Fail(reason: "There were errors or not all requests completed."); else context.Success(); }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var expectedVersion = ExpectedVersion.Any; var data = "test-data"; string metadata = null; bool isJson = false; string login = null; string pass = null; if (args.Length > 0) { if (args.Length < 3 || args.Length > 7 || args.Length == 6) 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]; if (args.Length >= 5) isJson = bool.Parse(args[4]); if (args.Length >= 7) { login = args[5]; pass = args[6]; } } context.IsAsync(); var sw = new Stopwatch(); context.Client.CreateTcpConnection( context, connectionEstablished: conn => { context.Log.Info("[{0}, L{1}]: Writing...", conn.RemoteEndPoint, conn.LocalEndPoint); var writeDto = new TcpClientMessageDto.WriteEvents( eventStreamId, expectedVersion, new[] { new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray(), "TakeSomeSpaceEvent", isJson ? 1: 0, 0, Helper.UTF8NoBom.GetBytes(data), Helper.UTF8NoBom.GetBytes(metadata ?? string.Empty)) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, login == null ? TcpFlags.None : TcpFlags.Authenticated, Guid.NewGuid(), login, pass, writeDto.Serialize()).AsByteArray(); sw.Start(); conn.EnqueueSend(package); }, handlePackage: (conn, pkg) => { sw.Stop(); context.Log.Info("Write request took: {0}.", sw.Elapsed); if (pkg.Command != TcpCommand.WriteEventsCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } var dto = pkg.Data.Deserialize<TcpClientMessageDto.WriteEventsCompleted>(); if (dto.Result == TcpClientMessageDto.OperationResult.Success) { context.Log.Info("Successfully written."); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)Math.Round(sw.Elapsed.TotalMilliseconds)); context.Success(); } else { context.Log.Info("Error while writing: {0} ({1}).", dto.Message, dto.Result); context.Fail(); } conn.Close(); }, connectionClosed: (connection, error) => context.Fail(reason: "Connection was closed prematurely.")); context.WaitForCompletion(); return true; }