public void AsyncProducerSendsFewShortFixedMessagesInSeparateSendActions()
{
var prodConfig = this.AsyncProducerConfig1;
using (var producer = new AsyncProducer(prodConfig))
{
var req1 = new ProducerRequest(
CurrentTestTopic,
0,
new List <Message> {
new Message(Encoding.UTF8.GetBytes("Async Test Message 1"))
});
producer.Send(req1);
var req2 = new ProducerRequest(
CurrentTestTopic,
0,
new List <Message> {
new Message(Encoding.UTF8.GetBytes("Async Test Message 2"))
});
producer.Send(req2);
var req3 = new ProducerRequest(
CurrentTestTopic,
0,
new List <Message> {
new Message(Encoding.UTF8.GetBytes("Async Test Message 3"))
});
producer.Send(req3);
}
}
public void AsyncProducerSendsManyLongRandomMessages()
{
var prodConfig = this.AsyncProducerConfig1;
List <Message> messages = GenerateRandomTextMessages(50);
using (var producer = new AsyncProducer(prodConfig))
{
producer.Send(CurrentTestTopic, 0, messages);
}
}
public void AsyncProducerSendsCompressedAndConsumerReceivesSingleSimpleMessage()
{
var prodConfig = this.AsyncProducerConfig1;
var consumerConfig = this.ConsumerConfig1;
var sourceMessage = new Message(Encoding.UTF8.GetBytes("test message"));
var compressedMessage = CompressionUtils.Compress(new List <Message> {
sourceMessage
}, CompressionCodecs.GZIPCompressionCodec);
long currentOffset = TestHelper.GetCurrentKafkaOffset(CurrentTestTopic, consumerConfig);
using (var producer = new AsyncProducer(prodConfig))
{
var producerRequest = new ProducerRequest(
CurrentTestTopic, 0, new List <Message> {
compressedMessage
});
producer.Send(producerRequest);
}
IConsumer consumer = new Consumer(consumerConfig);
var request = new FetchRequest(CurrentTestTopic, 0, currentOffset);
BufferedMessageSet response;
int totalWaitTimeInMiliseconds = 0;
int waitSingle = 100;
while (true)
{
Thread.Sleep(waitSingle);
response = consumer.Fetch(request);
if (response != null && response.Messages.Count() > 0)
{
break;
}
totalWaitTimeInMiliseconds += waitSingle;
if (totalWaitTimeInMiliseconds >= MaxTestWaitTimeInMiliseconds)
{
break;
}
}
Assert.NotNull(response);
Assert.AreEqual(1, response.Messages.Count());
Message resultMessage = response.Messages.First();
Assert.AreEqual(compressedMessage.ToString(), resultMessage.ToString());
}
public void AsyncProducerSendsFewShortFixedMessages()
{
var prodConfig = this.AsyncProducerConfig1;
var messages = new List <Message>
{
new Message(Encoding.UTF8.GetBytes("Async Test Message 1")),
new Message(Encoding.UTF8.GetBytes("Async Test Message 2")),
new Message(Encoding.UTF8.GetBytes("Async Test Message 3")),
new Message(Encoding.UTF8.GetBytes("Async Test Message 4"))
};
using (var producer = new AsyncProducer(prodConfig))
{
producer.Send(CurrentTestTopic, 0, messages);
}
}
public async Task AsyncProducer_SimplyCalls_Ctor_Supplied_Func()
{
var called = 0;
var funcSubstitute = new Func <IProducerBuffer <object>, CancellationToken, Task>((f, t) =>
{
Interlocked.Increment(ref called);
return(Task.CompletedTask);
});
using (var producer = new AsyncProducer <object>(funcSubstitute))
{
Assert.True(producer.InitAsync().Equals(Task.CompletedTask));
await producer.ProduceAsync(Substitute.For <IProducerBuffer <object> >(), CancellationToken.None);
Assert.True(called == 1);
}
}
public void AsyncProducerSendsMessageWithCallback()
{
var prodConfig = this.AsyncProducerConfig1;
var messages = new List <Message>
{
new Message(Encoding.UTF8.GetBytes("Async Test Message 1")),
};
var myHandler = new TestCallbackHandler();
using (var producer = new AsyncProducer(prodConfig))
{
producer.Send(CurrentTestTopic, 0, messages, myHandler.Handle);
}
Thread.Sleep(1000);
Assert.IsTrue(myHandler.WasRun);
}
public static void Start(int consumerCount = 2)
{
if (!(Host.Role.HasRole(ServerRole.Room) || (Host.Role.HasRole(ServerRole.Match))))
{
return;
}
var consumers = new List <AsyncBattleConsumer>();
for (int i = 0; i < consumerCount; i++)
{
var simulator = new BattleSimulator(100);
BATTLE_VERSION = simulator.BattleVersion;
consumers.Add(new AsyncBattleConsumer(simulator));
}
ASYNC_PRODUCER = new AsyncProducer <TBattleRecord, TBattleResult>(consumers);
}
/// <summary>
/// Run the TestRig
/// </summary>
public void run()
{
DateTime startTime = DateTime.Now;
// Start loading all sketches asynchronously
AsyncProducer <string, Sketch.Sketch> sketches = new AsyncProducer <string, Sketch.Sketch>(files, delegate(string file) { return(loadFile(file)); });
// Print the files to be loaded
Console.WriteLine("Files to be processed (" + files.Count + "):");
foreach (string filename in files)
{
Console.WriteLine(" " + filename);
}
ProcessStage stage = null;
foreach (ProcessStage theStage in executionQueue)
{
theStage.start();
}
for (int i = 0; i < files.Count; i++)
{
string Filename = files[i];
#region EXECUTE STAGE QUEUE
// Get a local copy of the execution queue to mess with
Queue <ProcessStage> localExecQueue = new Queue <ProcessStage>(executionQueue);
string File_path = System.IO.Path.GetDirectoryName(Filename);
string File_name = System.IO.Path.GetFileNameWithoutExtension(Filename);
string File_extn = System.IO.Path.GetExtension(Filename);
if (File_extn == "")
{
ExitWithError(Filename + " does not have an extension.");
}
string pointer = "---(" + (i + 1) + "/" + files.Count + ")------------------------> ";
string name = File_name + File_extn;
string top = "";
int len = pointer.Length + name.Length + 1;
for (int m = 0; m < len; ++m)
{
top += '_';
}
Console.WriteLine(top);
Console.WriteLine(pointer + File_name + File_extn + " |");
Console.WriteLine(top + "|");
sketch = sketches.Consume();
while (localExecQueue.Count != 0)
{
stage = localExecQueue.Dequeue();
bool writeIntermediary = generateIntermediaries && localExecQueue.Count != 0 && i == files.Count - 1;
if (catchExceptions)
{
try
{
runStageOnSketch(stage, sketch, Filename, writeIntermediary);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
else
{
runStageOnSketch(stage, sketch, Filename, writeIntermediary);
}
}
// Write output
if (i == files.Count - 1)
{
foreach (ProcessStage outputStage in executionQueue)
{
TextWriter outHandle = null;
string outputFile = "";
try
{
if (consoleOutput)
{
outHandle = Console.Out;
}
else
{
if (outputLocations.ContainsKey(outputStage))
{
outHandle = outputLocations[outputStage];
}
else
{
outputFile = outputPath + outputStage.shortname +
"_" + fileTimeStamp();
string outputFileName = outputFile + outputStage.outputFiletype;
if (System.IO.File.Exists(outputFileName))
{
outputFileName = outputFile + "_0" + outputStage.outputFiletype;
}
outHandle = new StreamWriter(outputFileName);
Console.WriteLine("Writing output to file " + outputFileName);
}
}
outputStage.finalize(outHandle, outputPath);
}
catch (IOException e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine("Due to various errors, there will be no output.");
}
finally
{
if (!consoleOutput && outHandle != null)
{
outHandle.Close();
}
}
}
}
#endregion
}
Console.WriteLine("------------------------------------");
DateTime endTime = DateTime.Now;
TimeSpan elapsedTime = endTime - startTime;
Console.WriteLine("Execution took " + elapsedTime.TotalSeconds + "s");
// Cleanup
// Allow each stage to do some post-processing (usually only necessary for test stages)
while (executionQueue.Count != 0)
{
ProcessStage current_stage = (ProcessStage)executionQueue.Dequeue();
current_stage.finalize();
}
if (pause)
{
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
}
