public void TestSendFourHandlers_10_000_000()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
var count1 = new CounterHandler();
var count2 = new CounterHandler();
var count3 = new CounterHandler();
var count4 = new CounterHandler();
channel.Subscribe(count1);
channel.Subscribe(count2);
channel.Subscribe(count3);
channel.Subscribe(count4);
var message = new GenericMessage("test");
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(10000000 / 4, count1.Count);
Assert.Equal(10000000 / 4, count2.Count);
Assert.Equal(10000000 / 4, count3.Count);
Assert.Equal(10000000 / 4, count4.Count);
}
public void TestSendTwoHandlers_10_000_000()
{
/*
* INT-3308 - used to run 6.4 million/sec
* 1. Skip empty iterators as above 7.2 million/sec
* 2. optimize for single handler 6.7 million/sec (small overhead added)
* 3. remove LB rwlock from UnicastingDispatcher 7.2 million/sec
* 4. Move single handler optimization to dispatcher 7.3 million/sec
*/
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
var count1 = new CounterHandler();
var count2 = new CounterHandler();
channel.Subscribe(count1);
channel.Subscribe(count2);
var message = new GenericMessage("test");
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(5000000, count1.Count);
Assert.Equal(5000000, count2.Count);
}
public void DirectChannel_Send_10_000_000_TwoHandlers()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
var count1 = new CounterHandler();
var count2 = new CounterHandler();
channel.Subscribe(count1);
channel.Subscribe(count2);
var message = new GenericMessage("test");
for (var i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
if (count1.Count != 5000000)
{
throw new InvalidOperationException("Handler count1 invalid");
}
if (count2.Count != 5000000)
{
throw new InvalidOperationException("Handler count2 invalid");
}
}
public void DirectChannel_Send_10_000_000_SingleHandler()
{
var services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
services.AddSingleton <IConfiguration>(config);
services.AddSingleton <IApplicationContext, GenericApplicationContext>();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var directChannel = new DirectChannel(provider.GetService <IApplicationContext>());
var handler = new CounterHandler();
directChannel.Subscribe(handler);
var message = Message.Create("test");
directChannel.Send(message);
for (var i = 0; i < 10_000_000; i++)
{
directChannel.Send(message);
}
if (handler.Count != 10_000_000 + 1)
{
throw new InvalidOperationException("Handler count invalid");
}
}
public void TestSendOneHandler_10_000_000()
{
/*
* INT-3308 - used to run 12 million/sec
* 1. optimize for single handler 20 million/sec
* 2. Don't iterate over empty datatypes 23 million/sec
* 3. Don't iterate over empty interceptors 31 million/sec
* 4. Move single handler optimization to dispatcher 34 million/sec
*
* 29 million per second with increment counter in the handler
*/
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = new GenericMessage("test");
Assert.True(channel.Send(message));
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(10000001, handler.Count);
}
public void DirectChannel_Send_10_000_000_FourHandlers()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
var count1 = new CounterHandler();
var count2 = new CounterHandler();
var count3 = new CounterHandler();
var count4 = new CounterHandler();
channel.Subscribe(count1);
channel.Subscribe(count2);
channel.Subscribe(count3);
channel.Subscribe(count4);
var message = Message.Create("test");
for (var i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
if (count1.Count != 10_000_000 / 4)
{
throw new InvalidOperationException("Handler count1 invalid");
}
if (count2.Count != 10_000_000 / 4)
{
throw new InvalidOperationException("Handler count2 invalid");
}
if (count3.Count != 10_000_000 / 4)
{
throw new InvalidOperationException("Handler count3 invalid");
}
if (count4.Count != 10_000_000 / 4)
{
throw new InvalidOperationException("Handler count4 invalid");
}
}
public void testSend()
{
DirectChannel channel = new DirectChannel();
ThreadNameExtractingTestTarget target = new ThreadNameExtractingTestTarget();
channel.Subscribe(target);
StringMessage message = new StringMessage("test");
Assert.IsTrue(channel.Send(message));
Assert.That(target.ThreadName, Is.EqualTo(Thread.CurrentThread.Name));
}
public async Task TestWaitToWriteAsync()
{
var provider = services.BuildServiceProvider();
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
channel.Subscribe(target);
Assert.True(await channel.Writer.WaitToWriteAsync());
channel.Unsubscribe(target);
Assert.False(await channel.Writer.WaitToWriteAsync());
}
public async Task TestWaitToWriteAsync()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider);
channel.Subscribe(target);
Assert.True(await channel.Writer.WaitToWriteAsync());
channel.Unsubscribe(target);
Assert.False(await channel.Writer.WaitToWriteAsync());
}
public async Task TestSendAsync()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider);
channel.Subscribe(target);
var message = new GenericMessage("test");
Assert.True(await channel.SendAsync(message));
}
public async Task TestWriteAsync()
{
var provider = services.BuildServiceProvider();
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
channel.Subscribe(target);
var message = Message.Create("test");
var currentId = Task.CurrentId;
var curThreadId = Thread.CurrentThread.ManagedThreadId;
await channel.Writer.WriteAsync(message);
Assert.Equal(currentId, target.TaskId);
Assert.Equal(curThreadId, target.ThreadId);
}
public void testSendInSeparateThread()
{
CountDownLatch latch = new CountDownLatch(1);
DirectChannel channel = new DirectChannel();
ThreadNameExtractingTestTarget target = new ThreadNameExtractingTestTarget(latch);
channel.Subscribe(target);
StringMessage message = new StringMessage("test");
Thread t = new Thread(new ThreadStart(delegate { channel.Send(message); }));
t.Name = "test-thread";
t.Start();
latch.Await(new TimeSpan(0, 0, 0, 0, 1000));
Assert.That(target.ThreadName, Is.EqualTo("test-thread"));
}
public void TestTryWrite()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider);
channel.Subscribe(target);
var message = new GenericMessage("test");
var currentId = Task.CurrentId;
var curThreadId = Thread.CurrentThread.ManagedThreadId;
Assert.True(channel.Writer.TryWrite(message));
Assert.Equal(currentId, target.TaskId);
Assert.Equal(curThreadId, target.ThreadId);
}
public void TestSendInSeparateThread()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var latch = new CountdownEvent(1);
var channel = new DirectChannel(provider);
var target = new ThreadNameExtractingTestTarget(latch);
channel.Subscribe(target);
var message = new GenericMessage("test");
var thread = new Thread(() => channel.Send(message));
thread.Name = "test-thread";
thread.Start();
latch.Wait(1000);
Assert.Equal("test-thread", target.ThreadName);
}
public async Task ValidateExceptionIfSendToErrorChannelFails()
{
var provider = services.BuildServiceProvider();
var outChannel = new DirectChannel(provider.GetService <IApplicationContext>());
var handler = new ExceptionHandler();
outChannel.Subscribe(handler);
var errorChannel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>());
errorChannel.Subscribe(handler);
var mps = new TestMessageProducerSupportEndpoint(provider.GetService <IApplicationContext>());
mps.OutputChannel = outChannel;
mps.ErrorChannel = errorChannel;
await mps.Start();
Assert.Throws <MessageDeliveryException>(() => mps.SendMessage(Message.Create("hello")));
}
public async Task TestSendAsyncOneHandler_10_000_000()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = new GenericMessage("test");
Assert.True(await channel.SendAsync(message));
for (var i = 0; i < 10000000; i++)
{
await channel.SendAsync(message);
}
Assert.Equal(10000001, handler.Count);
}
public async Task DirectChannel_SendAsync_10_000_000_SingleHandler()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var directChannel = new DirectChannel(provider);
var handler = new CounterHandler();
directChannel.Subscribe(handler);
var message = new GenericMessage("test");
await directChannel.SendAsync(message);
for (var i = 0; i < 10_000_000; i++)
{
await directChannel.SendAsync(message);
}
if (handler.Count != 10_000_000 + 1)
{
throw new InvalidOperationException("Handler count invalid");
}
}
