private TcpPackage Pack(Guid correlationId, VerificationEvent evnt) { var readDto = new ClientMessageDto.ReadEvent(correlationId, evnt.EventStreamId, evnt.ShouldBeVersion); return(new TcpPackage(TcpCommand.ReadEvent, readDto.Serialize())); }
public override TcpPackage CreateNetworkPackage(Guid correlationId) { lock (_stepMoveLock) { switch (_step) { case 0: var writeDto = new ClientMessageDto.WriteEvents(correlationId, _event.EventStreamId, _event.ExpectedVersion, new[] { new ClientMessageDto.Event(_event.Event) }); return(new TcpPackage(TcpCommand.WriteEvents, correlationId, writeDto.Serialize())); case 1: var readDto = new ClientMessageDto.ReadEvent(correlationId, _event.EventStreamId, _event.ShouldBeVersion); return(new TcpPackage(TcpCommand.ReadEvent, correlationId, readDto.Serialize())); default: throw new ArgumentOutOfRangeException("_step", "step can be 0 or 1 for write task"); } } }
public bool Execute(CommandProcessorContext context, string[] args) { var eventStreamId = "test-stream"; var fromNumber = 0; if (args.Length > 0) { if (args.Length > 2) { return(false); } eventStreamId = args[0]; if (args.Length == 2) { fromNumber = int.Parse(args[1]); } } context.IsAsync(); var corrid = Guid.NewGuid(); var readDto = new ClientMessageDto.ReadEvent(corrid, eventStreamId, fromNumber); var package = new TcpPackage(TcpCommand.ReadEvent, corrid, readDto.Serialize()); var sw = new Stopwatch(); context.Client.CreateTcpConnection( context, connectionEstablished: conn => { context.Log.Info("[{0}]: Reading...", conn.EffectiveEndPoint); sw.Start(); conn.EnqueueSend(package.AsByteArray()); }, handlePackage: (conn, pkg) => { if (pkg.Command != TcpCommand.ReadEventCompleted) { context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command)); return; } sw.Stop(); var dto = pkg.Data.Deserialize <ClientMessageDto.ReadEventCompleted>(); context.Log.Info("READ events from <{0}>:\n\n" + "\tCorrelationId: {1}\n" + "\tEventStreamId: {2}\n" + "\tEventNumber: {3}\n" + "\tReadResult: {4}\n" + "\tEventType: {5}\n" + "\tData: {6}\n" + "\tMetadata: {7}\n", eventStreamId, dto.CorrelationId, dto.EventStreamId, dto.EventNumber, (SingleReadResult)dto.Result, dto.EventType, Encoding.UTF8.GetString(dto.Data ?? new byte[0]), Encoding.UTF8.GetString(dto.Metadata ?? new byte[0])); context.Log.Info("Read request took: {0}.", sw.Elapsed); PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds); conn.Close(); context.Success(); }, connectionClosed: (connection, error) => { if (error == SocketError.Success) { context.Success(); } else { context.Fail(); } }); context.WaitForCompletion(); return(true); }
private void Read(Status status, int readerIdx, CommandProcessorContext context, AutoResetEvent finishedEvent) { TcpTypedConnection <byte[]> connection; var iteration = new AutoResetEvent(false); var successes = 0; var fails = 0; var rnd = new Random(); var streamIdx = -1; var eventidx = -1; Action <TcpTypedConnection <byte[]>, TcpPackage> packageReceived = (conn, pkg) => { var dto = pkg.Data.Deserialize <ClientMessageDto.ReadEventCompleted>(); switch ((SingleReadResult)dto.Result) { case SingleReadResult.Success: if (Equal(_streams[streamIdx], eventidx, dto.EventType, dto.Data)) { successes++; if (successes % 1000 == 0) { status.ReportReadsProgress(readerIdx, successes, fails); } } else { fails++; status.ReportReadError(readerIdx, _streams[streamIdx], eventidx); } break; case SingleReadResult.NotFound: case SingleReadResult.NoStream: case SingleReadResult.StreamDeleted: fails++; status.ReportNotFoundOnRead(readerIdx, _streams[streamIdx], eventidx); break; default: throw new ArgumentOutOfRangeException(); } iteration.Set(); }; Action <TcpTypedConnection <byte[]> > established = _ => { }; Action <TcpTypedConnection <byte[]>, SocketError> closed = null; closed = (_, __) => { Thread.Sleep(TimeSpan.FromSeconds(1)); connection = context.Client.CreateTcpConnection(context, packageReceived, cn => iteration.Set(), closed, false); }; connection = context.Client.CreateTcpConnection(context, packageReceived, established, closed, false); while (!_stopReading) { streamIdx = NextStreamForReading(rnd, readerIdx); int head; lock (_heads) head = _heads[streamIdx]; if (head > 0) { eventidx = NextRandomEventVersion(rnd, head); var stream = _streams[streamIdx]; var corrid = Guid.NewGuid(); var read = new ClientMessageDto.ReadEvent(corrid, stream, eventidx); var package = new TcpPackage(TcpCommand.ReadEvent, corrid, read.Serialize()); connection.EnqueueSend(package.AsByteArray()); iteration.WaitOne(); } else { Thread.Sleep(100); } } status.ReportReadsProgress(readerIdx, successes, fails); status.FinilizeStatus(readerIdx, fails == 0); connection.Close(); finishedEvent.Set(); }
private void ReadFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, long requestsCnt) { context.IsAsync(); var clients = new List <TcpTypedConnection <byte[]> >(); var threads = new List <Thread>(); var autoResetEvent = new AutoResetEvent(false); var sw2 = new Stopwatch(); long all = 0; for (int i = 0; i < clientsCnt; i++) { var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0); int sent = 0; int received = 0; var client = context.Client.CreateTcpConnection( context, (conn, pkg) => { 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} READS IN {1} ({2:0.0}/s).", localAll, elapsed, 1000.0 * 100000 / elapsed.TotalMilliseconds); } if (localAll == requestsCnt) { autoResetEvent.Set(); } }, connectionClosed: (conn, err) => { if (all < requestsCnt) { context.Fail(null, "Socket was closed, but not all requests were completed."); } else { context.Success(); } }); client.ConnectionClosed += (_, __) => context.Log.Debug("READS sent: {0}, received: {1}", sent, received); clients.Add(client); threads.Add(new Thread(() => { for (int j = 0; j < count; ++j) { var read = new ClientMessageDto.ReadEvent(Guid.NewGuid(), eventStreamId, 0); var package = new TcpPackage(TcpCommand.ReadEvent, read.Serialize()); client.EnqueueSend(package.AsByteArray()); Interlocked.Increment(ref sent); while (sent - received > context.Client.Options.ReadWindow) { Thread.Sleep(1); } } })); } var sw = Stopwatch.StartNew(); sw2.Start(); 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. READS done: {0}.", all); 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", all)) ); PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec); context.Success(); }