|
public WriteAsync ( |
||
| payload | The buffer data to send. | |
| return | Task |
|
public void ConnectionShouldAttemptMultipleTimesWhenConnectionFails()
{
var count = 0;
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _badServerUrl))
{
test.WriteAsync(1.ToBytes().ToPayload()); //will force a connection
test.OnReconnectionAttempt += x => Interlocked.Increment(ref count);
TaskTest.WaitFor(() => count > 1, 10000);
Assert.That(count, Is.GreaterThan(1));
}
}
public void SocketShouldReconnectEvenAfterCancelledWrite()
{
int connectionAttempt = 0;
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
using (var token = new CancellationTokenSource())
{
test.OnReconnectionAttempt += i => Interlocked.Exchange(ref connectionAttempt, i);
var taskResult = test.WriteAsync(new KafkaDataPayload { Buffer = 1.ToBytes() }, token.Token);
TaskTest.WaitFor(() => connectionAttempt > 1);
var attemptsMadeSoFar = connectionAttempt;
token.Cancel();
TaskTest.WaitFor(() => connectionAttempt > attemptsMadeSoFar);
Assert.That(connectionAttempt, Is.GreaterThan(attemptsMadeSoFar));
}
}
public void WriteShouldCancelWhileSendingData()
{
var writeAttempts = 0;
using (var server = new FakeTcpServer(FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
using (var token = new CancellationTokenSource())
{
test.OnWriteToSocketAttempt += payload => Interlocked.Increment(ref writeAttempts);
test.WriteAsync(new KafkaDataPayload { Buffer = 1.ToBytes() }, token.Token);
TaskTest.WaitFor(() => server.ConnectionEventcount > 0);
TaskTest.WaitFor(() => writeAttempts > 0);
Assert.That(writeAttempts, Is.EqualTo(1), "Socket should have attempted to write.");
//create a buffer write that will take a long time
var taskResult = test.WriteAsync(
new KafkaDataPayload { Buffer = Enumerable.Range(0, 1000000).Select(b => (byte)b).ToArray() },
token.Token);
token.Cancel();
taskResult.SafeWait(TimeSpan.FromMilliseconds(5000));
Assert.That(taskResult.IsCanceled, Is.True, "Task should have cancelled.");
}
}
public void WriteShouldCancelWhileAwaitingReconnection()
{
int connectionAttempt = 0;
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
using (var token = new CancellationTokenSource())
{
test.OnReconnectionAttempt += i => connectionAttempt = i;
var taskResult = test.WriteAsync(new KafkaDataPayload { Buffer = 1.ToBytes() }, token.Token);
TaskTest.WaitFor(() => connectionAttempt > 1);
token.Cancel();
taskResult.SafeWait(TimeSpan.FromMilliseconds(1000));
Assert.That(taskResult.IsCanceled, Is.True);
}
}
public void WriteAndReadShouldBeAsynchronous()
{
var write = new List<int>();
var read = new List<int>();
var expected = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
using (var server = new FakeTcpServer(FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
{
server.OnBytesReceived += data => write.AddRange(data.Batch(4).Select(x => x.ToArray().ToInt32()));
var tasks = Enumerable.Range(1, 10)
.SelectMany(i => new[]
{
test.WriteAsync(i.ToBytes().ToPayload()),
test.ReadAsync(4).ContinueWith(t => read.Add(t.Result.ToInt32())),
server.SendDataAsync(i.ToBytes())
}).ToArray();
Task.WaitAll(tasks);
Assert.That(write.OrderBy(x => x), Is.EqualTo(expected));
Assert.That(read.OrderBy(x => x), Is.EqualTo(expected));
}
}
public void WriteShouldHandleLargeVolumeSendAsynchronously()
{
var write = new List<int>();
using (var server = new FakeTcpServer(FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
{
server.OnBytesReceived += data => write.AddRange(data.Batch(4).Select(x => x.ToArray().ToInt32()));
var tasks = Enumerable.Range(1, 10000)
.SelectMany(i => new[]
{
test.WriteAsync(i.ToBytes().ToPayload()),
}).ToArray();
Task.WaitAll(tasks);
Assert.That(write.OrderBy(x => x), Is.EqualTo(Enumerable.Range(1, 10000)));
}
}
public void WriteAsyncShouldSendData()
{
using (var server = new FakeTcpServer(FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
{
const int testData = 99;
int result = 0;
server.OnBytesReceived += data => result = data.ToInt32();
test.WriteAsync(testData.ToBytes().ToPayload()).Wait(TimeSpan.FromSeconds(1));
TaskTest.WaitFor(() => result > 0);
Assert.That(result, Is.EqualTo(testData));
}
}
public void WriteAsyncShouldAllowMoreThanOneWrite()
{
using (var server = new FakeTcpServer(FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
{
const int testData = 99;
var results = new List<byte>();
server.OnBytesReceived += results.AddRange;
Task.WaitAll(test.WriteAsync(testData.ToBytes().ToPayload()), test.WriteAsync(testData.ToBytes().ToPayload()));
TaskTest.WaitFor(() => results.Count >= 8);
Assert.That(results.Count, Is.EqualTo(8));
}
}
public void KafkaTcpSocketShouldDisposeEvenWhileWriting()
{
using (var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl))
{
int writeSize = 0;
test.OnWriteToSocketAttempt += payload => writeSize = payload.Buffer.Length;
var taskResult = test.WriteAsync(4.ToBytes().ToPayload());
TaskTest.WaitFor(() => writeSize > 0);
using (test)
{
} //allow the sockets to set
taskResult.ContinueWith(t => taskResult = t).Wait(TimeSpan.FromSeconds(20));
Assert.That(taskResult.IsCompleted, Is.True);
Assert.That(taskResult.IsFaulted, Is.True, "Task should result indicate a fault.");
Assert.That(taskResult.Exception.InnerException, Is.TypeOf<ObjectDisposedException>(),
"Exception should be a disposed exception.");
}
}
public void KafkaTcpSocketShouldDisposeEvenWhileWriting()
{
var test = new KafkaTcpSocket(new DefaultTraceLog(), _fakeServerUrl);
var taskResult = test.WriteAsync(4.ToBytes());
using (test) { } //allow the sockets to set
taskResult.ContinueWith(t => taskResult = t).Wait(TimeSpan.FromSeconds(20));
Assert.That(taskResult.IsCompleted, Is.True);
Assert.That(taskResult.IsFaulted, Is.True, "Task should result indicate a fault.");
Assert.That(taskResult.Exception.InnerException, Is.TypeOf<ObjectDisposedException>(), "Exception should be a disposed exception.");
}
public async Task WriteShouldCancelWhileSendingData()
{
var writeAttempts = 0;
using (var server = new FakeTcpServer(_log, FakeServerPort))
using (var test = new KafkaTcpSocket(_log, _fakeServerUrl, _maxRetry))
using (var token = new CancellationTokenSource())
{
test.OnWriteToSocketAttempt += payload => Interlocked.Increment(ref writeAttempts);
test.WriteAsync(new KafkaDataPayload { Buffer = 1.ToBytes() }, token.Token);
await TaskTest.WaitFor(() => server.ConnectionEventcount > 0);
await TaskTest.WaitFor(() => writeAttempts > 0);
Assert.That(writeAttempts, Is.EqualTo(1), "Socket should have attempted to write.");
//create a buffer write that will take a long time
var data = Enumerable.Range(0, 100000000).Select(b => (byte)b).ToArray();
token.Cancel();
var taskResult = test.WriteAsync(
new KafkaDataPayload { Buffer = data },
token.Token);
await Task.WhenAny(taskResult, Task.Delay(TimeSpan.FromSeconds(5))).ConfigureAwait(false);
Assert.That(taskResult.IsCanceled, Is.True, "Task should have cancelled.");
}
}
public void WriteShouldHandleLargeVolumeSendAsynchronously()
{
AutoResetEvent allEventAreArrived = new AutoResetEvent(false);
var write = new ConcurrentBag<int>();
int percent = 0;
using (var server = new FakeTcpServer(_log, FakeServerPort))
using (var test = new KafkaTcpSocket(new DefaultTraceLog(LogLevel.Warn), _fakeServerUrl, _maxRetry))
{
int numberOfWrite = 10000;
server.OnBytesReceived += data =>
{
var d = data.Batch(4).Select(x => x.ToArray().ToInt32());
foreach (var item in d)
{
write.Add(item);
}
if (write.Count % (numberOfWrite / 100) == 0)
{
Console.WriteLine("*************** done percent:" + percent);
percent++;
}
if (write.Count == numberOfWrite)
{
allEventAreArrived.Set();
}
};
var tasks = Enumerable.Range(1, 10000).SelectMany(i => new[] { test.WriteAsync(i.ToBytes().ToPayload()), }).ToArray();
Task.WaitAll(tasks);
Assert.IsTrue(allEventAreArrived.WaitOne(2000), "not get all event on time");
Assert.That(write.OrderBy(x => x), Is.EqualTo(Enumerable.Range(1, numberOfWrite)));
}
}
public void WriteAndReadShouldBeAsynchronous()
{
// for (int j = 0; j < 1000; j++)
// {
var expected = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var write = new ConcurrentBag<int>();
var read = new ConcurrentBag<int>();
AutoResetEvent allEventAreArrived = new AutoResetEvent(false);
AutoResetEvent allrReadEventAreArrived = new AutoResetEvent(false);
using (var server = new FakeTcpServer(_log, FakeServerPort))
using (var test = new KafkaTcpSocket(_log, _fakeServerUrl, _maxRetry))
{
server.OnBytesReceived += data =>
{
var d = data.Batch(4).Select(x => x.ToArray().ToInt32());
foreach (var item in d)
{
write.Add(item);
}
if (expected.Count == write.Count)
{
allEventAreArrived.Set();
}
};
var tasks = Enumerable.Range(1, 10)
.SelectMany(i => new[]
{
test.WriteAsync(i.ToBytes().ToPayload()),
test.ReadAsync(4).ContinueWith(t =>
{
read.Add(t.Result.ToInt32());
if (read.Count == expected.Count)
{
allrReadEventAreArrived.Set();
}
}),
server.SendDataAsync(i.ToBytes())
}).ToArray();
Task.WaitAll(tasks);
Assert.IsTrue(allEventAreArrived.WaitOne(3000), "not Get all write event in time");
Assert.IsTrue(allrReadEventAreArrived.WaitOne(3000), "not Get all read event in time");
var w = write.OrderBy(x => x);
var r = read.OrderBy(x => x);
for (int i = 0; i < expected.Count; i++)
{
// _log.InfoFormat("write was {0} expected {1}", w.ElementAt(i), expected[i]);
Assert.That(w.ElementAt(i), Is.EqualTo(expected[i]));
}
for (int i = 0; i < expected.Count; i++)
{
// _log.InfoFormat("read was {0} expected {1}", r.ElementAt(i), expected[i]);
Assert.That(r.ElementAt(i), Is.EqualTo(expected[i]));
}
}
// }
}