本文整理汇总了C#中CommandProcessorContext.WaitForCompletion方法的典型用法代码示例。如果您正苦于以下问题：C# CommandProcessorContext.WaitForCompletion方法的具体用法？C# CommandProcessorContext.WaitForCompletion怎么用？C# CommandProcessorContext.WaitForCompletion使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类CommandProcessorContext的用法示例。
在下文中一共展示了CommandProcessorContext.WaitForCompletion方法的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
context.IsAsync();
var package = new TcpPackage(TcpCommand.Ping, Guid.NewGuid(), null);
context.Log.Info("[{0}:{1}]: PING...", context.Client.Options.Ip, context.Client.Options.TcpPort);
var connection = context.Client.CreateTcpConnection(
context,
(conn, pkg) =>
{
if (pkg.Command != TcpCommand.Pong)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
context.Log.Info("[{0}:{1}]: PONG!", context.Client.Options.Ip, context.Client.Options.TcpPort);
conn.Close();
context.Success();
},
null,
(typedConnection, error) =>
{
if (error == SocketError.Success)
context.Success();
else
context.Fail();
});
connection.EnqueueSend(package.AsByteArray());
context.WaitForCompletion();
return true;
}示例2: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
context.IsAsync();
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
var package = new TcpPackage(TcpCommand.Ping, Guid.NewGuid(), null);
context.Log.Info("[{0}:{1}]: PING...", context.Client.Options.Ip, context.Client.Options.TcpPort);
conn.EnqueueSend(package.AsByteArray());
},
handlePackage: (conn, pkg) =>
{
if (pkg.Command != TcpCommand.Pong)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
context.Log.Info("[{0}:{1}]: PONG!", context.Client.Options.Ip, context.Client.Options.TcpPort);
context.Success();
conn.Close();
},
connectionClosed: (typedConnection, error) => context.Fail(reason: "Connection was closed prematurely."));
context.WaitForCompletion();
return true;
}示例3: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var expectedVersion = ExpectedVersion.Any;
if (args.Length > 0)
{
if (args.Length > 2)
return false;
eventStreamId = args[0];
if (args.Length == 2)
expectedVersion = args[1].Trim().ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]);
}
context.IsAsync();
var sw = new Stopwatch();
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}, L{1}]: Trying to delete event stream '{2}'...", conn.RemoteEndPoint, conn.LocalEndPoint, eventStreamId);
var corrid = Guid.NewGuid();
var deleteDto = new TcpClientMessageDto.DeleteStream(eventStreamId, expectedVersion, false, true);
var package = new TcpPackage(TcpCommand.DeleteStream, corrid, deleteDto.Serialize()).AsByteArray();
sw.Start();
conn.EnqueueSend(package);
},
handlePackage: (conn, pkg) =>
{
sw.Stop();
context.Log.Info("Delete request took: {0}.", sw.Elapsed);
if (pkg.Command != TcpCommand.DeleteStreamCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<TcpClientMessageDto.DeleteStreamCompleted>();
if (dto.Result == TcpClientMessageDto.OperationResult.Success)
{
context.Log.Info("DELETED event stream {0}.", eventStreamId);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)Math.Round(sw.Elapsed.TotalMilliseconds));
context.Success();
}
else
{
context.Log.Info("DELETION FAILED for event stream {0}: {1} ({2}).", eventStreamId, dto.Message, dto.Result);
context.Fail();
}
conn.Close();
},
connectionClosed:(connection, error) => context.Fail(reason: "Connection was closed prematurely."));
context.WaitForCompletion();
return true;
}示例4: Execute
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;
}示例5: Execute
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 readDto = new ClientMessageDto.ReadEvent(Guid.NewGuid(), eventStreamId, fromNumber);
var package = new TcpPackage(TcpCommand.ReadEvent, 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;
}示例6: Execute
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;
}示例7: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
const string data = "test-data";
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 writeDto = new ClientMessageDto.WriteEvents(
Guid.Empty,
eventStreamId,
expectedVersion,
Enumerable.Range(0, writeCount).Select(x =>
new ClientMessageDto.Event(Guid.NewGuid(),
"type",
Encoding.UTF8.GetBytes(data),
new byte[0])).ToArray());
var package = new TcpPackage(TcpCommand.WriteEvents, writeDto.Serialize());
var sw = new Stopwatch();
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}]: Writing...", conn.EffectiveEndPoint);
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;
}
sw.Stop();
var dto = pkg.Data.Deserialize<ClientMessageDto.WriteEventsCompleted>();
if (dto.ErrorCode == (int)OperationErrorCode.Success)
{
context.Log.Info("Successfully written {0} events. CorrelationId: {1}.",
writeCount,
dto.CorrelationId);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds);
}
else
{
context.Log.Info("Error while writing: {0}. CorrelationId: {1}.", dto.Error, dto.CorrelationId);
}
context.Log.Info("Write request took: {0}.", sw.Elapsed);
conn.Close();
context.Success();
},
connectionClosed:(connection, error) =>
{
if(error == SocketError.Success)
context.Success();
else
context.Fail();
});
context.WaitForCompletion();
return true;
}示例8: Execute
//.........这里部分代码省略.........
}
context.IsAsync();
int total = 0;
var sw = new Stopwatch();
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}]: Reading all {0}...", conn.EffectiveEndPoint, forward ? "FORWARD" : "BACKWARD");
sw.Start();
var readDto = forward
? (object)new TcpClientMessageDto.ReadAllEventsForward(commitPos, preparePos, 10, false)
: new TcpClientMessageDto.ReadAllEventsBackward(commitPos, preparePos, 10, false);
var package = new TcpPackage(forward ? TcpCommand.ReadAllEventsForward : TcpCommand.ReadAllEventsBackward,
Guid.NewGuid(),
readDto.Serialize());
conn.EnqueueSend(package.AsByteArray());
},
handlePackage: (conn, pkg) =>
{
TcpClientMessageDto.EventLinkPair[] records;
long nextCommitPos;
long nextPreparePos;
if (forward)
{
if (pkg.Command != TcpCommand.ReadAllEventsForwardCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<TcpClientMessageDto.ReadAllEventsForwardCompleted>();
records = dto.Events;
nextCommitPos = dto.NextCommitPosition;
nextPreparePos = dto.NextPreparePosition;
}
else
{
if (pkg.Command != TcpCommand.ReadAllEventsBackwardCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<TcpClientMessageDto.ReadAllEventsBackwardCompleted>();
records = dto.Events;
nextCommitPos = dto.NextCommitPosition;
nextPreparePos = dto.NextPreparePosition;
}
if (records == null || records.Length == 0)
{
sw.Stop();
context.Log.Info("=== Reading ALL {2} completed in {0}. Total read: {1}",
sw.Elapsed,
total,
forward ? "FORWARD" : "BACKWARD");
conn.Close();
context.Success();
return;
}
var sb = new StringBuilder();
for (int i = 0; i < records.Length; ++i)
{
var evnt = records[i].Event;
sb.AppendFormat("\n{0}:\tStreamId: {1},\n\tEventNumber: {2},\n\tData:\n{3},\n\tEventType: {4}\n",
total,
evnt.EventStreamId,
evnt.EventNumber,
Encoding.UTF8.GetString(evnt.Data),
evnt.EventType);
total += 1;
}
context.Log.Info("Next {0} events read:\n{1}", records.Length, sb.ToString());
var readDto = forward
? (object)new TcpClientMessageDto.ReadAllEventsForward(nextCommitPos, nextPreparePos, 10, false)
: new TcpClientMessageDto.ReadAllEventsBackward(nextCommitPos, nextPreparePos, 10, false);
var package = new TcpPackage(forward ? TcpCommand.ReadAllEventsForward : TcpCommand.ReadAllEventsBackward,
Guid.NewGuid(),
readDto.Serialize());
conn.EnqueueSend(package.AsByteArray());
},
connectionClosed: (connection, error) =>
{
if (error == SocketError.Success)
context.Success();
else
context.Fail();
});
context.WaitForCompletion();
return true;
}示例9: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
context.IsAsync();
var streamByCorrId = new Dictionary<Guid, string>();
var connection = context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
},
handlePackage: (conn, pkg) =>
{
switch (pkg.Command)
{
case TcpCommand.SubscriptionConfirmation:
{
var dto = pkg.Data.Deserialize<TcpClientMessageDto.SubscriptionConfirmation>();
context.Log.Info("Subscription to <{0}> WAS CONFIRMED! Subscribed at {1} ({2})",
streamByCorrId[pkg.CorrelationId], dto.LastCommitPosition, dto.LastEventNumber);
break;
}
case TcpCommand.StreamEventAppeared:
{
var dto = pkg.Data.Deserialize<TcpClientMessageDto.StreamEventAppeared>();
context.Log.Info("NEW EVENT:\n\n"
+ "\tEventStreamId: {0}\n"
+ "\tEventNumber: {1}\n"
+ "\tEventType: {2}\n"
+ "\tData: {3}\n"
+ "\tMetadata: {4}\n",
dto.Event.Event.EventStreamId,
dto.Event.Event.EventNumber,
dto.Event.Event.EventType,
Common.Utils.Helper.UTF8NoBom.GetString(dto.Event.Event.Data ?? new byte[0]),
Common.Utils.Helper.UTF8NoBom.GetString(dto.Event.Event.Metadata ?? new byte[0]));
break;
}
case TcpCommand.SubscriptionDropped:
{
pkg.Data.Deserialize<TcpClientMessageDto.SubscriptionDropped>();
context.Log.Error("Subscription to <{0}> WAS DROPPED!", streamByCorrId[pkg.CorrelationId]);
break;
}
default:
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
break;
}
},
connectionClosed: (c, error) =>
{
if (error == SocketError.Success)
context.Success();
else
context.Fail();
});
if (args.Length == 0)
{
context.Log.Info("SUBSCRIBING TO ALL STREAMS...");
var cmd = new TcpClientMessageDto.SubscribeToStream(string.Empty, resolveLinkTos: false);
Guid correlationId = Guid.NewGuid();
streamByCorrId[correlationId] = "$all";
connection.EnqueueSend(new TcpPackage(TcpCommand.SubscribeToStream, correlationId, cmd.Serialize()).AsByteArray());
}
else
{
foreach (var stream in args)
{
context.Log.Info("SUBSCRIBING TO STREAM <{0}>...", stream);
var cmd = new TcpClientMessageDto.SubscribeToStream(stream, resolveLinkTos: false);
var correlationId = Guid.NewGuid();
streamByCorrId[correlationId] = stream;
connection.EnqueueSend(new TcpPackage(TcpCommand.SubscribeToStream, correlationId, cmd.Serialize()).AsByteArray());
}
}
context.WaitForCompletion();
return true;
}示例10: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
context.IsAsync();
var connection = context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
},
handlePackage: (conn, pkg) =>
{
switch (pkg.Command)
{
case TcpCommand.StreamEventAppeared:
{
var dto = pkg.Data.Deserialize<ClientMessageDto.StreamEventAppeared>();
context.Log.Info("NEW EVENT:\n\n"
+ "\tEventStreamId: {0}\n"
+ "\tEventNumber: {1}\n"
+ "\tEventType: {2}\n"
+ "\tData: {3}\n"
+ "\tMetadata: {4}\n",
dto.EventStreamId,
dto.EventNumber,
dto.EventType,
Encoding.UTF8.GetString(dto.Data ?? new byte[0]),
Encoding.UTF8.GetString(dto.Metadata ?? new byte[0]));
break;
}
case TcpCommand.SubscriptionDropped:
{
var dto = pkg.Data.Deserialize<ClientMessageDto.SubscriptionDropped>();
context.Log.Error("Subscription to <{0}> WAS DROPPED!", dto.EventStreamId);
break;
}
case TcpCommand.SubscriptionToAllDropped:
{
var dto = pkg.Data.Deserialize<ClientMessageDto.SubscriptionToAllDropped>();
context.Log.Error("Subscription to ALL WAS DROPPED!");
break;
}
default:
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
break;
}
},
connectionClosed: (c, error) =>
{
if (error == SocketError.Success)
context.Success();
else
context.Fail();
});
if (args.Length == 0)
{
context.Log.Info("SUBSCRIBING TO ALL STREAMS...");
var corrid = Guid.NewGuid();
var cmd = new ClientMessageDto.SubscribeToAllStreams(corrid);
connection.EnqueueSend(new TcpPackage(TcpCommand.SubscribeToAllStreams, corrid, cmd.Serialize()).AsByteArray());
}
else
{
foreach (var stream in args)
{
context.Log.Info("SUBSCRIBING TO STREAM <{0}>...", stream);
var corrid = Guid.NewGuid();
var cmd = new ClientMessageDto.SubscribeToStream(corrid, stream);
connection.EnqueueSend(new TcpPackage(TcpCommand.SubscribeToStream, corrid, cmd.Serialize()).AsByteArray());
}
}
context.WaitForCompletion();
return true;
}示例11: Execute
//.........这里部分代码省略.........
if (dto.Result != TcpClientMessageDto.OperationResult.Success)
{
var msg = string.Format("Error while starting transaction: {0} ({1}).", dto.Message, dto.Result);
context.Log.Info(msg);
context.Fail(reason: msg);
}
else
{
context.Log.Info("Successfully started transaction. TransactionId: {0}.", dto.TransactionId);
context.Log.Info("Now sending transactional events...", dto.TransactionId);
transactionId = dto.TransactionId;
stage = Stage.Writing;
for (int i = 0; i < eventsCnt; ++i)
{
var writeDto = new TcpClientMessageDto.TransactionWrite(
transactionId,
new[]
{
new TcpClientMessageDto.NewEvent(Guid.NewGuid().ToByteArray() ,
"TakeSomeSpaceEvent",
0,0,
Common.Utils.Helper.UTF8NoBom.GetBytes(Guid.NewGuid().ToString()),
Common.Utils.Helper.UTF8NoBom.GetBytes(Guid.NewGuid().ToString()))
},
false);
var package = new TcpPackage(TcpCommand.TransactionWrite, Guid.NewGuid(), writeDto.Serialize());
conn.EnqueueSend(package.AsByteArray());
}
}
break;
}
case Stage.Writing:
{
if (pkg.Command != TcpCommand.TransactionWriteCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<TcpClientMessageDto.TransactionWriteCompleted>();
if (dto.Result != TcpClientMessageDto.OperationResult.Success)
{
var msg = string.Format("Error while writing transactional event: {0} ({1}).", dto.Message, dto.Result);
context.Log.Info(msg);
context.Fail(reason: msg);
}
else
{
writtenEvents += 1;
if (writtenEvents == eventsCnt)
{
context.Log.Info("Written all events. Committing...");
stage = Stage.Committing;
var commitDto = new TcpClientMessageDto.TransactionCommit(transactionId, false);
var package = new TcpPackage(TcpCommand.TransactionCommit, Guid.NewGuid(), commitDto.Serialize());
conn.EnqueueSend(package.AsByteArray());
}
}
break;
}
case Stage.Committing:
{
if (pkg.Command != TcpCommand.TransactionCommitCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
sw.Stop();
var dto = pkg.Data.Deserialize<TcpClientMessageDto.TransactionCommitCompleted>();
if (dto.Result != TcpClientMessageDto.OperationResult.Success)
{
var msg = string.Format("Error while committing transaction: {0} ({1}).", dto.Message, dto.Result);
context.Log.Info(msg);
context.Log.Info("Transaction took: {0}.", sw.Elapsed);
context.Fail(reason: msg);
}
else
{
context.Log.Info("Successfully committed transaction [{0}]!", dto.TransactionId);
context.Log.Info("Transaction took: {0}.", sw.Elapsed);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds);
context.Success();
}
conn.Close();
break;
}
default:
throw new ArgumentOutOfRangeException();
}
},
connectionClosed: (connection, error) => context.Fail(reason: "Connection was closed prematurely."));
context.WaitForCompletion();
return true;
}示例12: Execute
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;
}示例13: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
string metadata = null;
if (args.Length > 0)
{
if (args.Length > 2)
return false;
eventStreamId = args[0];
if (args.Length > 1)
metadata = args[1];
}
context.IsAsync();
var createStreamDto = new TcpClientMessageDto.CreateStream(
eventStreamId,
Guid.NewGuid().ToByteArray(),
Encoding.UTF8.GetBytes(metadata ?? string.Format("{{\"StreamName\": \"{0}\"}}", eventStreamId)),
true,
metadata == null);
var package = new TcpPackage(TcpCommand.CreateStream, Guid.NewGuid(), createStreamDto.Serialize());
var sw = new Stopwatch();
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}]: Trying to create stream '{1}'...", conn.EffectiveEndPoint, eventStreamId);
sw.Start();
conn.EnqueueSend(package.AsByteArray());
},
handlePackage: (conn, pkg) =>
{
if (pkg.Command != TcpCommand.CreateStreamCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
sw.Stop();
var dto = pkg.Data.Deserialize<TcpClientMessageDto.CreateStreamCompleted>();
if (dto.Result == TcpClientMessageDto.OperationResult.Success)
{
context.Log.Info("Successfully created stream '{0}'.", eventStreamId);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds);
}
else
{
context.Log.Info("Error while creating stream {0}: {1} ({2}).", eventStreamId, dto.Message, dto.Result);
}
context.Log.Info("Create stream request took: {0}.", sw.Elapsed);
conn.Close();
context.Success();
},
connectionClosed: (connection, error) =>
{
if (error == SocketError.Success)
context.Success();
else
context.Fail();
});
context.WaitForCompletion();
return true;
}示例14: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
bool forward = true;
long commitPos = 0;
long preparePos = 0;
bool posOverriden = false;
bool resolveLinkTos = false;
bool requireMaster = false;
if (args.Length > 0)
{
if (args.Length != 1 && args.Length != 3 && args.Length != 4)
return false;
if (args[0].ToUpper() == "F")
forward = true;
else if (args[0].ToUpper() == "B")
forward = false;
else
return false;
if (args.Length >= 3)
{
posOverriden = true;
if (!long.TryParse(args[1], out commitPos) || !long.TryParse(args[2], out preparePos))
return false;
}
if (args.Length >= 4)
requireMaster = bool.Parse(args[3]);
}
if (!posOverriden)
{
commitPos = forward ? 0 : -1;
preparePos = forward ? 0 : -1;
}
context.IsAsync();
int total = 0;
var sw = new Stopwatch();
var tcpCommand = forward ? TcpCommand.ReadAllEventsForward : TcpCommand.ReadAllEventsBackward;
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}, L{1}]: Reading all {2}...", conn.RemoteEndPoint, conn.LocalEndPoint, forward ? "FORWARD" : "BACKWARD");
var readDto = new TcpClientMessageDto.ReadAllEvents(commitPos, preparePos, 10, resolveLinkTos, requireMaster);
var package = new TcpPackage(tcpCommand, Guid.NewGuid(), readDto.Serialize()).AsByteArray();
sw.Start();
conn.EnqueueSend(package);
},
handlePackage: (conn, pkg) =>
{
if (pkg.Command != tcpCommand)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<TcpClientMessageDto.ReadAllEventsCompleted>();
if (dto.Events.IsEmpty())
{
sw.Stop();
context.Log.Info("=== Reading ALL {2} completed in {0}. Total read: {1}", sw.Elapsed, total, forward ? "FORWARD" : "BACKWARD");
context.Success();
conn.Close();
return;
}
var sb = new StringBuilder();
for (int i = 0; i < dto.Events.Length; ++i)
{
var evnt = dto.Events[i].Event;
sb.AppendFormat("\n{0}:\tStreamId: {1},\n\tEventNumber: {2},\n\tData:\n{3},\n\tEventType: {4}\n",
total,
evnt.EventStreamId,
evnt.EventNumber,
Helper.UTF8NoBom.GetString(evnt.Data),
evnt.EventType);
total += 1;
}
context.Log.Info("Next {0} events read:\n{1}", dto.Events.Length, sb.ToString());
var readDto = new TcpClientMessageDto.ReadAllEvents(dto.NextCommitPosition, dto.NextPreparePosition, 10, resolveLinkTos, requireMaster);
var package = new TcpPackage(tcpCommand, Guid.NewGuid(), readDto.Serialize()).AsByteArray();
conn.EnqueueSend(package);
},
connectionClosed: (connection, error) => context.Fail(reason: "Connection was closed prematurely."));
context.WaitForCompletion();
return true;
}示例15: Execute
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var expectedVersion = ExpectedVersion.Any;
if (args.Length > 0)
{
if (args.Length > 2)
return false;
eventStreamId = args[0];
if (args.Length == 2)
expectedVersion = args[1].Trim().ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]);
}
context.IsAsync();
var corrid = Guid.NewGuid();
var deleteDto = new ClientMessageDto.DeleteStream(corrid, eventStreamId, expectedVersion);
var package = new TcpPackage(TcpCommand.DeleteStream, corrid, deleteDto.Serialize());
var sw = new Stopwatch();
var done = false;
context.Client.CreateTcpConnection(
context,
connectionEstablished: conn =>
{
context.Log.Info("[{0}]: Trying to delete event stream '{1}'...", conn.EffectiveEndPoint, eventStreamId);
sw.Start();
conn.EnqueueSend(package.AsByteArray());
},
handlePackage: (conn, pkg) =>
{
sw.Stop();
if (pkg.Command != TcpCommand.DeleteStreamCompleted)
{
context.Fail(reason: string.Format("Unexpected TCP package: {0}.", pkg.Command));
return;
}
var dto = pkg.Data.Deserialize<ClientMessageDto.DeleteStreamCompleted>();
if (dto.ErrorCode == (int)OperationErrorCode.Success)
context.Log.Info("DELETED event stream {0}.", eventStreamId);
else
context.Log.Info("DELETION FAILED for event stream {0}: {1} ({2}).",
eventStreamId,
dto.Error,
(OperationErrorCode) dto.ErrorCode);
context.Log.Info("Delete request took: {0}.", sw.Elapsed);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)sw.ElapsedMilliseconds);
done = true;
conn.Close();
context.Success();
},
connectionClosed:(connection, error) =>
{
if (done && error == SocketError.Success)
context.Success();
else
context.Fail();
});
context.WaitForCompletion();
return true;
}